blob: 276a617d1ac3e6515e201a7d1e9d1a9e7c907791 [file] [log] [blame]
Eugene Zelenko1ced5092016-02-12 22:53:10 +00001//===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===//
Douglas Gregor5101c242008-12-05 18:15:24 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Eugene Zelenko1ced5092016-02-12 22:53:10 +00007//===----------------------------------------------------------------------===//
Douglas Gregor5101c242008-12-05 18:15:24 +00008//
9// This file implements semantic analysis for C++ templates.
Eugene Zelenko1ced5092016-02-12 22:53:10 +000010//===----------------------------------------------------------------------===//
Douglas Gregor5101c242008-12-05 18:15:24 +000011
Douglas Gregor15acfb92009-08-06 16:20:37 +000012#include "TreeTransform.h"
Larisse Voufo39a1e502013-08-06 01:03:05 +000013#include "clang/AST/ASTConsumer.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000014#include "clang/AST/ASTContext.h"
John McCallbbbbe4e2010-03-11 07:50:04 +000015#include "clang/AST/DeclFriend.h"
Douglas Gregorded2d7b2009-02-04 19:02:06 +000016#include "clang/AST/DeclTemplate.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000017#include "clang/AST/Expr.h"
18#include "clang/AST/ExprCXX.h"
John McCalla020a012010-10-20 05:44:58 +000019#include "clang/AST/RecursiveASTVisitor.h"
Douglas Gregor7731d3f2010-10-13 00:27:52 +000020#include "clang/AST/TypeVisitor.h"
David Majnemerd9b1a4f2015-11-04 03:40:30 +000021#include "clang/Basic/Builtins.h"
Douglas Gregor5101c242008-12-05 18:15:24 +000022#include "clang/Basic/LangOptions.h"
Douglas Gregor450f00842009-09-25 18:43:00 +000023#include "clang/Basic/PartialDiagnostic.h"
David Majnemer763584d2014-02-06 10:59:19 +000024#include "clang/Basic/TargetInfo.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000025#include "clang/Sema/DeclSpec.h"
26#include "clang/Sema/Lookup.h"
27#include "clang/Sema/ParsedTemplate.h"
28#include "clang/Sema/Scope.h"
29#include "clang/Sema/SemaInternal.h"
30#include "clang/Sema/Template.h"
31#include "clang/Sema/TemplateDeduction.h"
Benjamin Kramere0513cb2012-01-30 16:17:39 +000032#include "llvm/ADT/SmallBitVector.h"
Benjamin Kramer49038022012-02-04 13:45:25 +000033#include "llvm/ADT/SmallString.h"
Douglas Gregorbe999392009-09-15 16:23:51 +000034#include "llvm/ADT/StringExtras.h"
Eugene Zelenko1ced5092016-02-12 22:53:10 +000035
Eric Fiselier6ad68552016-07-01 01:24:09 +000036#include <iterator>
Douglas Gregor5101c242008-12-05 18:15:24 +000037using namespace clang;
John McCall19c1bfd2010-08-25 05:32:35 +000038using namespace sema;
Douglas Gregor5101c242008-12-05 18:15:24 +000039
John McCall9b72f892010-11-10 02:40:36 +000040// Exported for use by Parser.
41SourceRange
42clang::getTemplateParamsRange(TemplateParameterList const * const *Ps,
43 unsigned N) {
44 if (!N) return SourceRange();
45 return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
46}
47
Hubert Tong5a8ec4e2017-02-10 02:46:19 +000048namespace clang {
Adrian Prantl9fc8faf2018-05-09 01:00:01 +000049/// [temp.constr.decl]p2: A template's associated constraints are
Hubert Tong5a8ec4e2017-02-10 02:46:19 +000050/// defined as a single constraint-expression derived from the introduced
51/// constraint-expressions [ ... ].
52///
53/// \param Params The template parameter list and optional requires-clause.
54///
55/// \param FD The underlying templated function declaration for a function
56/// template.
57static Expr *formAssociatedConstraints(TemplateParameterList *Params,
58 FunctionDecl *FD);
59}
60
61static Expr *clang::formAssociatedConstraints(TemplateParameterList *Params,
62 FunctionDecl *FD) {
63 // FIXME: Concepts: collect additional introduced constraint-expressions
64 assert(!FD && "Cannot collect constraints from function declaration yet.");
65 return Params->getRequiresClause();
66}
67
Adrian Prantl9fc8faf2018-05-09 01:00:01 +000068/// Determine whether the declaration found is acceptable as the name
Douglas Gregorb7bfe792009-09-02 22:59:36 +000069/// of a template and, if so, return that template declaration. Otherwise,
70/// returns NULL.
John McCalle9cccd82010-06-16 08:42:20 +000071static NamedDecl *isAcceptableTemplateName(ASTContext &Context,
Douglas Gregor50a3cdd2012-03-10 23:52:41 +000072 NamedDecl *Orig,
73 bool AllowFunctionTemplates) {
John McCalle9cccd82010-06-16 08:42:20 +000074 NamedDecl *D = Orig->getUnderlyingDecl();
Mike Stump11289f42009-09-09 15:08:12 +000075
Douglas Gregor50a3cdd2012-03-10 23:52:41 +000076 if (isa<TemplateDecl>(D)) {
77 if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(D))
Craig Topperc3ec1492014-05-26 06:22:03 +000078 return nullptr;
79
John McCalle9cccd82010-06-16 08:42:20 +000080 return Orig;
Douglas Gregor50a3cdd2012-03-10 23:52:41 +000081 }
Mike Stump11289f42009-09-09 15:08:12 +000082
Douglas Gregorb7bfe792009-09-02 22:59:36 +000083 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
84 // C++ [temp.local]p1:
85 // Like normal (non-template) classes, class templates have an
86 // injected-class-name (Clause 9). The injected-class-name
87 // can be used with or without a template-argument-list. When
88 // it is used without a template-argument-list, it is
89 // equivalent to the injected-class-name followed by the
90 // template-parameters of the class template enclosed in
91 // <>. When it is used with a template-argument-list, it
92 // refers to the specified class template specialization,
93 // which could be the current specialization or another
94 // specialization.
95 if (Record->isInjectedClassName()) {
Douglas Gregor568a0712009-10-14 17:30:58 +000096 Record = cast<CXXRecordDecl>(Record->getDeclContext());
Douglas Gregorb7bfe792009-09-02 22:59:36 +000097 if (Record->getDescribedClassTemplate())
98 return Record->getDescribedClassTemplate();
99
100 if (ClassTemplateSpecializationDecl *Spec
101 = dyn_cast<ClassTemplateSpecializationDecl>(Record))
102 return Spec->getSpecializedTemplate();
103 }
Mike Stump11289f42009-09-09 15:08:12 +0000104
Craig Topperc3ec1492014-05-26 06:22:03 +0000105 return nullptr;
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000106 }
Mike Stump11289f42009-09-09 15:08:12 +0000107
Richard Smithcbebd622018-05-14 20:52:48 +0000108 // 'using Dependent::foo;' can resolve to a template name.
109 // 'using typename Dependent::foo;' cannot (not even if 'foo' is an
110 // injected-class-name).
111 if (isa<UnresolvedUsingValueDecl>(D))
112 return D;
113
Craig Topperc3ec1492014-05-26 06:22:03 +0000114 return nullptr;
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000115}
116
Simon Pilgrim6905d222016-12-30 22:55:33 +0000117void Sema::FilterAcceptableTemplateNames(LookupResult &R,
Douglas Gregor50a3cdd2012-03-10 23:52:41 +0000118 bool AllowFunctionTemplates) {
Douglas Gregor41f90302010-04-12 20:54:26 +0000119 // The set of class templates we've already seen.
120 llvm::SmallPtrSet<ClassTemplateDecl *, 8> ClassTemplates;
John McCalle66edc12009-11-24 19:00:30 +0000121 LookupResult::Filter filter = R.makeFilter();
122 while (filter.hasNext()) {
123 NamedDecl *Orig = filter.next();
Simon Pilgrim6905d222016-12-30 22:55:33 +0000124 NamedDecl *Repl = isAcceptableTemplateName(Context, Orig,
Douglas Gregor50a3cdd2012-03-10 23:52:41 +0000125 AllowFunctionTemplates);
John McCalle66edc12009-11-24 19:00:30 +0000126 if (!Repl)
127 filter.erase();
Douglas Gregor41f90302010-04-12 20:54:26 +0000128 else if (Repl != Orig) {
129
130 // C++ [temp.local]p3:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000131 // A lookup that finds an injected-class-name (10.2) can result in an
Douglas Gregor41f90302010-04-12 20:54:26 +0000132 // ambiguity in certain cases (for example, if it is found in more than
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000133 // one base class). If all of the injected-class-names that are found
134 // refer to specializations of the same class template, and if the name
Richard Smith3f1b5d02011-05-05 21:57:07 +0000135 // is used as a template-name, the reference refers to the class
136 // template itself and not a specialization thereof, and is not
Douglas Gregor41f90302010-04-12 20:54:26 +0000137 // ambiguous.
Douglas Gregor41f90302010-04-12 20:54:26 +0000138 if (ClassTemplateDecl *ClassTmpl = dyn_cast<ClassTemplateDecl>(Repl))
David Blaikie82e95a32014-11-19 07:49:47 +0000139 if (!ClassTemplates.insert(ClassTmpl).second) {
Douglas Gregor41f90302010-04-12 20:54:26 +0000140 filter.erase();
141 continue;
142 }
John McCallbd8062d2010-08-13 07:02:08 +0000143
144 // FIXME: we promote access to public here as a workaround to
145 // the fact that LookupResult doesn't let us remember that we
146 // found this template through a particular injected class name,
147 // which means we end up doing nasty things to the invariants.
148 // Pretending that access is public is *much* safer.
149 filter.replace(Repl, AS_public);
Douglas Gregor41f90302010-04-12 20:54:26 +0000150 }
John McCalle66edc12009-11-24 19:00:30 +0000151 }
152 filter.done();
153}
154
Douglas Gregor50a3cdd2012-03-10 23:52:41 +0000155bool Sema::hasAnyAcceptableTemplateNames(LookupResult &R,
156 bool AllowFunctionTemplates) {
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000157 for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I)
Douglas Gregor50a3cdd2012-03-10 23:52:41 +0000158 if (isAcceptableTemplateName(Context, *I, AllowFunctionTemplates))
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000159 return true;
Simon Pilgrim6905d222016-12-30 22:55:33 +0000160
Douglas Gregor8b02cd02011-04-27 04:48:22 +0000161 return false;
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000162}
163
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000164TemplateNameKind Sema::isTemplateName(Scope *S,
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +0000165 CXXScopeSpec &SS,
Abramo Bagnara7c5dee42010-08-06 12:11:11 +0000166 bool hasTemplateKeyword,
Richard Smithc08b6932018-04-27 02:00:13 +0000167 const UnqualifiedId &Name,
John McCallba7bf592010-08-24 05:47:05 +0000168 ParsedType ObjectTypePtr,
Douglas Gregore861bac2009-08-25 22:51:20 +0000169 bool EnteringContext,
Douglas Gregor786123d2010-05-21 23:18:07 +0000170 TemplateTy &TemplateResult,
171 bool &MemberOfUnknownSpecialization) {
David Blaikiebbafb8a2012-03-11 07:00:24 +0000172 assert(getLangOpts().CPlusPlus && "No template names in C!");
Douglas Gregor411e5ac2010-01-11 23:29:10 +0000173
Douglas Gregor3cf81312009-11-03 23:16:33 +0000174 DeclarationName TName;
Douglas Gregor786123d2010-05-21 23:18:07 +0000175 MemberOfUnknownSpecialization = false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000176
Douglas Gregor3cf81312009-11-03 23:16:33 +0000177 switch (Name.getKind()) {
Faisal Vali2ab8c152017-12-30 04:15:27 +0000178 case UnqualifiedIdKind::IK_Identifier:
Douglas Gregor3cf81312009-11-03 23:16:33 +0000179 TName = DeclarationName(Name.Identifier);
180 break;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000181
Faisal Vali2ab8c152017-12-30 04:15:27 +0000182 case UnqualifiedIdKind::IK_OperatorFunctionId:
Douglas Gregor3cf81312009-11-03 23:16:33 +0000183 TName = Context.DeclarationNames.getCXXOperatorName(
184 Name.OperatorFunctionId.Operator);
185 break;
186
Faisal Vali2ab8c152017-12-30 04:15:27 +0000187 case UnqualifiedIdKind::IK_LiteralOperatorId:
Alexis Hunt3d221f22009-11-29 07:34:05 +0000188 TName = Context.DeclarationNames.getCXXLiteralOperatorName(Name.Identifier);
189 break;
Alexis Hunted0530f2009-11-28 08:58:14 +0000190
Douglas Gregor3cf81312009-11-03 23:16:33 +0000191 default:
192 return TNK_Non_template;
193 }
Mike Stump11289f42009-09-09 15:08:12 +0000194
John McCallba7bf592010-08-24 05:47:05 +0000195 QualType ObjectType = ObjectTypePtr.get();
Mike Stump11289f42009-09-09 15:08:12 +0000196
Daniel Dunbar62ee6412012-03-09 18:35:03 +0000197 LookupResult R(*this, TName, Name.getLocStart(), LookupOrdinaryName);
Richard Smith79810042018-05-11 02:43:08 +0000198 if (LookupTemplateName(R, S, SS, ObjectType, EnteringContext,
199 MemberOfUnknownSpecialization))
200 return TNK_Non_template;
John McCallfb3f9ba2010-08-28 20:17:00 +0000201 if (R.empty()) return TNK_Non_template;
202 if (R.isAmbiguous()) {
203 // Suppress diagnostics; we'll redo this lookup later.
John McCalldcc71402010-08-13 02:23:42 +0000204 R.suppressDiagnostics();
John McCallfb3f9ba2010-08-28 20:17:00 +0000205
206 // FIXME: we might have ambiguous templates, in which case we
207 // should at least parse them properly!
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000208 return TNK_Non_template;
John McCalldcc71402010-08-13 02:23:42 +0000209 }
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000210
John McCalld28ae272009-12-02 08:04:21 +0000211 TemplateName Template;
212 TemplateNameKind TemplateKind;
Mike Stump11289f42009-09-09 15:08:12 +0000213
John McCalld28ae272009-12-02 08:04:21 +0000214 unsigned ResultCount = R.end() - R.begin();
215 if (ResultCount > 1) {
216 // We assume that we'll preserve the qualifier from a function
217 // template name in other ways.
218 Template = Context.getOverloadedTemplateName(R.begin(), R.end());
219 TemplateKind = TNK_Function_template;
John McCalldcc71402010-08-13 02:23:42 +0000220
221 // We'll do this lookup again later.
222 R.suppressDiagnostics();
Richard Smithcbebd622018-05-14 20:52:48 +0000223 } else if (isa<UnresolvedUsingValueDecl>((*R.begin())->getUnderlyingDecl())) {
224 // We don't yet know whether this is a template-name or not.
225 MemberOfUnknownSpecialization = true;
226 return TNK_Non_template;
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000227 } else {
John McCalld28ae272009-12-02 08:04:21 +0000228 TemplateDecl *TD = cast<TemplateDecl>((*R.begin())->getUnderlyingDecl());
229
230 if (SS.isSet() && !SS.isInvalid()) {
Aaron Ballman4a979672014-01-03 13:56:08 +0000231 NestedNameSpecifier *Qualifier = SS.getScopeRep();
Abramo Bagnara7c5dee42010-08-06 12:11:11 +0000232 Template = Context.getQualifiedTemplateName(Qualifier,
233 hasTemplateKeyword, TD);
John McCalld28ae272009-12-02 08:04:21 +0000234 } else {
235 Template = TemplateName(TD);
236 }
237
John McCalldcc71402010-08-13 02:23:42 +0000238 if (isa<FunctionTemplateDecl>(TD)) {
John McCalld28ae272009-12-02 08:04:21 +0000239 TemplateKind = TNK_Function_template;
John McCalldcc71402010-08-13 02:23:42 +0000240
241 // We'll do this lookup again later.
242 R.suppressDiagnostics();
243 } else {
Richard Smith3f1b5d02011-05-05 21:57:07 +0000244 assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
David Majnemerd9b1a4f2015-11-04 03:40:30 +0000245 isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||
Faisal Valia534f072018-04-26 00:42:40 +0000246 isa<BuiltinTemplateDecl>(TD));
Larisse Voufo39a1e502013-08-06 01:03:05 +0000247 TemplateKind =
Faisal Valia534f072018-04-26 00:42:40 +0000248 isa<VarTemplateDecl>(TD) ? TNK_Var_template : TNK_Type_template;
John McCalld28ae272009-12-02 08:04:21 +0000249 }
Douglas Gregorb7bfe792009-09-02 22:59:36 +0000250 }
Mike Stump11289f42009-09-09 15:08:12 +0000251
John McCalld28ae272009-12-02 08:04:21 +0000252 TemplateResult = TemplateTy::make(Template);
253 return TemplateKind;
John McCalle66edc12009-11-24 19:00:30 +0000254}
255
Richard Smith278890f2017-02-10 20:39:58 +0000256bool Sema::isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
257 SourceLocation NameLoc,
258 ParsedTemplateTy *Template) {
259 CXXScopeSpec SS;
260 bool MemberOfUnknownSpecialization = false;
261
262 // We could use redeclaration lookup here, but we don't need to: the
263 // syntactic form of a deduction guide is enough to identify it even
264 // if we can't look up the template name at all.
265 LookupResult R(*this, DeclarationName(&Name), NameLoc, LookupOrdinaryName);
Richard Smith79810042018-05-11 02:43:08 +0000266 if (LookupTemplateName(R, S, SS, /*ObjectType*/ QualType(),
267 /*EnteringContext*/ false,
268 MemberOfUnknownSpecialization))
269 return false;
Richard Smith278890f2017-02-10 20:39:58 +0000270
271 if (R.empty()) return false;
272 if (R.isAmbiguous()) {
273 // FIXME: Diagnose an ambiguity if we find at least one template.
274 R.suppressDiagnostics();
275 return false;
276 }
277
278 // We only treat template-names that name type templates as valid deduction
279 // guide names.
280 TemplateDecl *TD = R.getAsSingle<TemplateDecl>();
281 if (!TD || !getAsTypeTemplateDecl(TD))
282 return false;
283
284 if (Template)
285 *Template = TemplateTy::make(TemplateName(TD));
286 return true;
287}
288
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000289bool Sema::DiagnoseUnknownTemplateName(const IdentifierInfo &II,
Douglas Gregor18473f32010-01-12 21:28:44 +0000290 SourceLocation IILoc,
291 Scope *S,
292 const CXXScopeSpec *SS,
293 TemplateTy &SuggestedTemplate,
294 TemplateNameKind &SuggestedKind) {
295 // We can't recover unless there's a dependent scope specifier preceding the
296 // template name.
Douglas Gregor20c38a72010-05-21 23:43:39 +0000297 // FIXME: Typo correction?
Douglas Gregor18473f32010-01-12 21:28:44 +0000298 if (!SS || !SS->isSet() || !isDependentScopeSpecifier(*SS) ||
299 computeDeclContext(*SS))
300 return false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000301
Douglas Gregor18473f32010-01-12 21:28:44 +0000302 // The code is missing a 'template' keyword prior to the dependent template
303 // name.
304 NestedNameSpecifier *Qualifier = (NestedNameSpecifier*)SS->getScopeRep();
305 Diag(IILoc, diag::err_template_kw_missing)
306 << Qualifier << II.getName()
Douglas Gregora771f462010-03-31 17:46:05 +0000307 << FixItHint::CreateInsertion(IILoc, "template ");
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000308 SuggestedTemplate
Douglas Gregor18473f32010-01-12 21:28:44 +0000309 = TemplateTy::make(Context.getDependentTemplateName(Qualifier, &II));
310 SuggestedKind = TNK_Dependent_template_name;
311 return true;
312}
313
Richard Smith79810042018-05-11 02:43:08 +0000314bool Sema::LookupTemplateName(LookupResult &Found,
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +0000315 Scope *S, CXXScopeSpec &SS,
John McCalle66edc12009-11-24 19:00:30 +0000316 QualType ObjectType,
Douglas Gregor786123d2010-05-21 23:18:07 +0000317 bool EnteringContext,
Richard Smith79810042018-05-11 02:43:08 +0000318 bool &MemberOfUnknownSpecialization,
319 SourceLocation TemplateKWLoc) {
John McCalle66edc12009-11-24 19:00:30 +0000320 // Determine where to perform name lookup
Douglas Gregor786123d2010-05-21 23:18:07 +0000321 MemberOfUnknownSpecialization = false;
Craig Topperc3ec1492014-05-26 06:22:03 +0000322 DeclContext *LookupCtx = nullptr;
Richard Smith79810042018-05-11 02:43:08 +0000323 bool IsDependent = false;
John McCalle66edc12009-11-24 19:00:30 +0000324 if (!ObjectType.isNull()) {
325 // This nested-name-specifier occurs in a member access expression, e.g.,
326 // x->B::f, and we are looking into the type of the object.
327 assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
328 LookupCtx = computeDeclContext(ObjectType);
Richard Smith79810042018-05-11 02:43:08 +0000329 IsDependent = !LookupCtx;
330 assert((IsDependent || !ObjectType->isIncompleteType() ||
Richard Smith5ed79562013-06-07 20:03:01 +0000331 ObjectType->castAs<TagType>()->isBeingDefined()) &&
John McCalle66edc12009-11-24 19:00:30 +0000332 "Caller should have completed object type");
Simon Pilgrim6905d222016-12-30 22:55:33 +0000333
Douglas Gregorbf3a8262012-01-12 16:11:24 +0000334 // Template names cannot appear inside an Objective-C class or object type.
335 if (ObjectType->isObjCObjectOrInterfaceType()) {
336 Found.clear();
Richard Smith79810042018-05-11 02:43:08 +0000337 return false;
Douglas Gregorbf3a8262012-01-12 16:11:24 +0000338 }
John McCalle66edc12009-11-24 19:00:30 +0000339 } else if (SS.isSet()) {
340 // This nested-name-specifier occurs after another nested-name-specifier,
341 // so long into the context associated with the prior nested-name-specifier.
342 LookupCtx = computeDeclContext(SS, EnteringContext);
Richard Smith79810042018-05-11 02:43:08 +0000343 IsDependent = !LookupCtx;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000344
John McCalle66edc12009-11-24 19:00:30 +0000345 // The declaration context must be complete.
John McCall0b66eb32010-05-01 00:40:08 +0000346 if (LookupCtx && RequireCompleteDeclContext(SS, LookupCtx))
Richard Smith79810042018-05-11 02:43:08 +0000347 return true;
John McCalle66edc12009-11-24 19:00:30 +0000348 }
349
350 bool ObjectTypeSearchedInScope = false;
Douglas Gregor50a3cdd2012-03-10 23:52:41 +0000351 bool AllowFunctionTemplatesInLookup = true;
John McCalle66edc12009-11-24 19:00:30 +0000352 if (LookupCtx) {
353 // Perform "qualified" name lookup into the declaration context we
354 // computed, which is either the type of the base of a member access
355 // expression or the declaration context associated with a prior
356 // nested-name-specifier.
357 LookupQualifiedName(Found, LookupCtx);
Simon Pilgrim6905d222016-12-30 22:55:33 +0000358
Richard Smith79810042018-05-11 02:43:08 +0000359 // FIXME: The C++ standard does not clearly specify what happens in the
360 // case where the object type is dependent, and implementations vary. In
361 // Clang, we treat a name after a . or -> as a template-name if lookup
362 // finds a non-dependent member or member of the current instantiation that
363 // is a type template, or finds no such members and lookup in the context
364 // of the postfix-expression finds a type template. In the latter case, the
365 // name is nonetheless dependent, and we may resolve it to a member of an
366 // unknown specialization when we come to instantiate the template.
367 IsDependent |= Found.wasNotFoundInCurrentInstantiation();
John McCalle66edc12009-11-24 19:00:30 +0000368 }
369
Richard Smith79810042018-05-11 02:43:08 +0000370 if (!SS.isSet() && (ObjectType.isNull() || Found.empty())) {
371 // C++ [basic.lookup.classref]p1:
372 // In a class member access expression (5.2.5), if the . or -> token is
373 // immediately followed by an identifier followed by a <, the
374 // identifier must be looked up to determine whether the < is the
375 // beginning of a template argument list (14.2) or a less-than operator.
376 // The identifier is first looked up in the class of the object
377 // expression. If the identifier is not found, it is then looked up in
378 // the context of the entire postfix-expression and shall name a class
379 // template.
380 if (S)
381 LookupName(Found, S);
382
383 if (!ObjectType.isNull()) {
384 // FIXME: We should filter out all non-type templates here, particularly
385 // variable templates and concepts. But the exclusion of alias templates
386 // and template template parameters is a wording defect.
387 AllowFunctionTemplatesInLookup = false;
388 ObjectTypeSearchedInScope = true;
389 }
390
391 IsDependent |= Found.wasNotFoundInCurrentInstantiation();
392 }
393
394 if (Found.empty() && !IsDependent) {
Douglas Gregorff18cc12009-12-31 08:11:17 +0000395 // If we did not find any names, attempt to correct any typos.
396 DeclarationName Name = Found.getLookupName();
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000397 Found.clear();
Kaelyn Uhrain637b5b32012-01-13 23:10:36 +0000398 // Simple filter callback that, for keywords, only accepts the C++ *_cast
Kaelyn Takata89c881b2014-10-27 18:07:29 +0000399 auto FilterCCC = llvm::make_unique<CorrectionCandidateCallback>();
400 FilterCCC->WantTypeSpecifiers = false;
401 FilterCCC->WantExpressionKeywords = false;
402 FilterCCC->WantRemainingKeywords = false;
403 FilterCCC->WantCXXNamedCasts = true;
404 if (TypoCorrection Corrected = CorrectTypo(
405 Found.getLookupNameInfo(), Found.getLookupKind(), S, &SS,
406 std::move(FilterCCC), CTK_ErrorRecovery, LookupCtx)) {
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000407 Found.setLookupName(Corrected.getCorrection());
Richard Smithde6d6c42015-12-29 19:43:10 +0000408 if (auto *ND = Corrected.getFoundDecl())
409 Found.addDecl(ND);
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000410 FilterAcceptableTemplateNames(Found);
John McCalle9cccd82010-06-16 08:42:20 +0000411 if (!Found.empty()) {
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000412 if (LookupCtx) {
Richard Smithf9b15102013-08-17 00:46:16 +0000413 std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
414 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000415 Name.getAsString() == CorrectedStr;
Richard Smithf9b15102013-08-17 00:46:16 +0000416 diagnoseTypo(Corrected, PDiag(diag::err_no_member_template_suggest)
417 << Name << LookupCtx << DroppedSpecifier
418 << SS.getRange());
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000419 } else {
Richard Smithf9b15102013-08-17 00:46:16 +0000420 diagnoseTypo(Corrected, PDiag(diag::err_no_template_suggest) << Name);
Kaelyn Uhrain10413a42013-07-02 23:47:44 +0000421 }
John McCalle9cccd82010-06-16 08:42:20 +0000422 }
Douglas Gregorff18cc12009-12-31 08:11:17 +0000423 } else {
Douglas Gregorc048c522010-06-29 19:27:42 +0000424 Found.setLookupName(Name);
Douglas Gregorff18cc12009-12-31 08:11:17 +0000425 }
426 }
427
Richard Smith79810042018-05-11 02:43:08 +0000428 NamedDecl *ExampleLookupResult =
429 Found.empty() ? nullptr : Found.getRepresentativeDecl();
Douglas Gregor50a3cdd2012-03-10 23:52:41 +0000430 FilterAcceptableTemplateNames(Found, AllowFunctionTemplatesInLookup);
Douglas Gregorfc6c3e72010-07-16 16:54:17 +0000431 if (Found.empty()) {
Richard Smith79810042018-05-11 02:43:08 +0000432 if (IsDependent) {
Douglas Gregorfc6c3e72010-07-16 16:54:17 +0000433 MemberOfUnknownSpecialization = true;
Richard Smith79810042018-05-11 02:43:08 +0000434 return false;
435 }
436
437 // If a 'template' keyword was used, a lookup that finds only non-template
438 // names is an error.
439 if (ExampleLookupResult && TemplateKWLoc.isValid()) {
440 Diag(Found.getNameLoc(), diag::err_template_kw_refers_to_non_template)
441 << Found.getLookupName() << SS.getRange();
Richard Smithcbebd622018-05-14 20:52:48 +0000442 Diag(ExampleLookupResult->getUnderlyingDecl()->getLocation(),
Richard Smith79810042018-05-11 02:43:08 +0000443 diag::note_template_kw_refers_to_non_template)
444 << Found.getLookupName();
445 return true;
446 }
447
448 return false;
Douglas Gregorfc6c3e72010-07-16 16:54:17 +0000449 }
John McCalle66edc12009-11-24 19:00:30 +0000450
Douglas Gregor1b02e4a2012-05-01 20:23:02 +0000451 if (S && !ObjectType.isNull() && !ObjectTypeSearchedInScope &&
Richard Smithe7d67f22013-09-03 21:22:41 +0000452 !getLangOpts().CPlusPlus11) {
Douglas Gregor1b02e4a2012-05-01 20:23:02 +0000453 // C++03 [basic.lookup.classref]p1:
John McCalle66edc12009-11-24 19:00:30 +0000454 // [...] If the lookup in the class of the object expression finds a
455 // template, the name is also looked up in the context of the entire
456 // postfix-expression and [...]
457 //
Douglas Gregor1b02e4a2012-05-01 20:23:02 +0000458 // Note: C++11 does not perform this second lookup.
John McCalle66edc12009-11-24 19:00:30 +0000459 LookupResult FoundOuter(*this, Found.getLookupName(), Found.getNameLoc(),
460 LookupOrdinaryName);
461 LookupName(FoundOuter, S);
Douglas Gregor50a3cdd2012-03-10 23:52:41 +0000462 FilterAcceptableTemplateNames(FoundOuter, /*AllowFunctionTemplates=*/false);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000463
John McCalle66edc12009-11-24 19:00:30 +0000464 if (FoundOuter.empty()) {
465 // - if the name is not found, the name found in the class of the
466 // object expression is used, otherwise
Douglas Gregorde0a43f2011-08-10 21:59:45 +0000467 } else if (!FoundOuter.getAsSingle<ClassTemplateDecl>() ||
468 FoundOuter.isAmbiguous()) {
John McCalle66edc12009-11-24 19:00:30 +0000469 // - if the name is found in the context of the entire
470 // postfix-expression and does not name a class template, the name
471 // found in the class of the object expression is used, otherwise
Douglas Gregorde0a43f2011-08-10 21:59:45 +0000472 FoundOuter.clear();
John McCalle9cccd82010-06-16 08:42:20 +0000473 } else if (!Found.isSuppressingDiagnostics()) {
John McCalle66edc12009-11-24 19:00:30 +0000474 // - if the name found is a class template, it must refer to the same
475 // entity as the one found in the class of the object expression,
476 // otherwise the program is ill-formed.
477 if (!Found.isSingleResult() ||
478 Found.getFoundDecl()->getCanonicalDecl()
479 != FoundOuter.getFoundDecl()->getCanonicalDecl()) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000480 Diag(Found.getNameLoc(),
Jeffrey Yasskin2f96e9f2010-06-05 01:39:57 +0000481 diag::ext_nested_name_member_ref_lookup_ambiguous)
482 << Found.getLookupName()
483 << ObjectType;
John McCalle66edc12009-11-24 19:00:30 +0000484 Diag(Found.getRepresentativeDecl()->getLocation(),
485 diag::note_ambig_member_ref_object_type)
486 << ObjectType;
487 Diag(FoundOuter.getFoundDecl()->getLocation(),
488 diag::note_ambig_member_ref_scope);
489
490 // Recover by taking the template that we found in the object
491 // expression's type.
492 }
493 }
494 }
Richard Smith79810042018-05-11 02:43:08 +0000495
496 return false;
John McCalle66edc12009-11-24 19:00:30 +0000497}
498
Richard Smith42bc73a2017-05-10 02:30:28 +0000499void Sema::diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
500 SourceLocation Less,
501 SourceLocation Greater) {
502 if (TemplateName.isInvalid())
503 return;
504
505 DeclarationNameInfo NameInfo;
506 CXXScopeSpec SS;
507 LookupNameKind LookupKind;
508
509 DeclContext *LookupCtx = nullptr;
510 NamedDecl *Found = nullptr;
Richard Smithbf5bcf22018-06-26 23:20:26 +0000511 bool MissingTemplateKeyword = false;
Richard Smith42bc73a2017-05-10 02:30:28 +0000512
513 // Figure out what name we looked up.
Richard Smithbf5bcf22018-06-26 23:20:26 +0000514 if (auto *DRE = dyn_cast<DeclRefExpr>(TemplateName.get())) {
515 NameInfo = DRE->getNameInfo();
516 SS.Adopt(DRE->getQualifierLoc());
517 LookupKind = LookupOrdinaryName;
518 Found = DRE->getFoundDecl();
519 } else if (auto *ME = dyn_cast<MemberExpr>(TemplateName.get())) {
Richard Smith42bc73a2017-05-10 02:30:28 +0000520 NameInfo = ME->getMemberNameInfo();
521 SS.Adopt(ME->getQualifierLoc());
522 LookupKind = LookupMemberName;
523 LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();
524 Found = ME->getMemberDecl();
Richard Smithbf5bcf22018-06-26 23:20:26 +0000525 } else if (auto *DSDRE =
526 dyn_cast<DependentScopeDeclRefExpr>(TemplateName.get())) {
527 NameInfo = DSDRE->getNameInfo();
528 SS.Adopt(DSDRE->getQualifierLoc());
529 MissingTemplateKeyword = true;
530 } else if (auto *DSME =
531 dyn_cast<CXXDependentScopeMemberExpr>(TemplateName.get())) {
532 NameInfo = DSME->getMemberNameInfo();
533 SS.Adopt(DSME->getQualifierLoc());
534 MissingTemplateKeyword = true;
Richard Smith42bc73a2017-05-10 02:30:28 +0000535 } else {
Richard Smithbf5bcf22018-06-26 23:20:26 +0000536 llvm_unreachable("unexpected kind of potential template name");
537 }
538
539 // If this is a dependent-scope lookup, diagnose that the 'template' keyword
540 // was missing.
541 if (MissingTemplateKeyword) {
542 Diag(NameInfo.getLocStart(), diag::err_template_kw_missing)
543 << "" << NameInfo.getName().getAsString()
544 << SourceRange(Less, Greater);
545 return;
Richard Smith42bc73a2017-05-10 02:30:28 +0000546 }
547
548 // Try to correct the name by looking for templates and C++ named casts.
549 struct TemplateCandidateFilter : CorrectionCandidateCallback {
550 TemplateCandidateFilter() {
551 WantTypeSpecifiers = false;
552 WantExpressionKeywords = false;
553 WantRemainingKeywords = false;
554 WantCXXNamedCasts = true;
555 };
556 bool ValidateCandidate(const TypoCorrection &Candidate) override {
557 if (auto *ND = Candidate.getCorrectionDecl())
558 return isAcceptableTemplateName(ND->getASTContext(), ND, true);
559 return Candidate.isKeyword();
560 }
561 };
562
563 DeclarationName Name = NameInfo.getName();
564 if (TypoCorrection Corrected =
565 CorrectTypo(NameInfo, LookupKind, S, &SS,
566 llvm::make_unique<TemplateCandidateFilter>(),
567 CTK_ErrorRecovery, LookupCtx)) {
568 auto *ND = Corrected.getFoundDecl();
569 if (ND)
570 ND = isAcceptableTemplateName(Context, ND,
571 /*AllowFunctionTemplates*/ true);
572 if (ND || Corrected.isKeyword()) {
573 if (LookupCtx) {
574 std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
575 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
576 Name.getAsString() == CorrectedStr;
577 diagnoseTypo(Corrected,
578 PDiag(diag::err_non_template_in_member_template_id_suggest)
579 << Name << LookupCtx << DroppedSpecifier
Richard Smith52f8d192017-05-10 21:32:16 +0000580 << SS.getRange(), false);
Richard Smith42bc73a2017-05-10 02:30:28 +0000581 } else {
582 diagnoseTypo(Corrected,
583 PDiag(diag::err_non_template_in_template_id_suggest)
Richard Smith52f8d192017-05-10 21:32:16 +0000584 << Name, false);
Richard Smith42bc73a2017-05-10 02:30:28 +0000585 }
586 if (Found)
587 Diag(Found->getLocation(),
588 diag::note_non_template_in_template_id_found);
589 return;
590 }
591 }
592
593 Diag(NameInfo.getLoc(), diag::err_non_template_in_template_id)
594 << Name << SourceRange(Less, Greater);
595 if (Found)
596 Diag(Found->getLocation(), diag::note_non_template_in_template_id_found);
597}
598
John McCallcd4b4772009-12-02 03:53:29 +0000599/// ActOnDependentIdExpression - Handle a dependent id-expression that
600/// was just parsed. This is only possible with an explicit scope
601/// specifier naming a dependent type.
John McCalldadc5752010-08-24 06:29:42 +0000602ExprResult
John McCalle66edc12009-11-24 19:00:30 +0000603Sema::ActOnDependentIdExpression(const CXXScopeSpec &SS,
Abramo Bagnara7945c982012-01-27 09:46:47 +0000604 SourceLocation TemplateKWLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000605 const DeclarationNameInfo &NameInfo,
John McCallcd4b4772009-12-02 03:53:29 +0000606 bool isAddressOfOperand,
John McCalle66edc12009-11-24 19:00:30 +0000607 const TemplateArgumentListInfo *TemplateArgs) {
John McCall87fe5d52010-05-20 01:18:31 +0000608 DeclContext *DC = getFunctionLevelDeclContext();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000609
Reid Kleckner1af391df2016-03-11 18:59:12 +0000610 // C++11 [expr.prim.general]p12:
611 // An id-expression that denotes a non-static data member or non-static
612 // member function of a class can only be used:
613 // (...)
614 // - if that id-expression denotes a non-static data member and it
615 // appears in an unevaluated operand.
616 //
617 // If this might be the case, form a DependentScopeDeclRefExpr instead of a
618 // CXXDependentScopeMemberExpr. The former can instantiate to either
619 // DeclRefExpr or MemberExpr depending on lookup results, while the latter is
620 // always a MemberExpr.
621 bool MightBeCxx11UnevalField =
622 getLangOpts().CPlusPlus11 && isUnevaluatedContext();
623
Akira Hatanakad644e022016-12-16 03:19:41 +0000624 // Check if the nested name specifier is an enum type.
625 bool IsEnum = false;
626 if (NestedNameSpecifier *NNS = SS.getScopeRep())
627 IsEnum = dyn_cast_or_null<EnumType>(NNS->getAsType());
628
629 if (!MightBeCxx11UnevalField && !isAddressOfOperand && !IsEnum &&
Reid Kleckner1af391df2016-03-11 18:59:12 +0000630 isa<CXXMethodDecl>(DC) && cast<CXXMethodDecl>(DC)->isInstance()) {
John McCall87fe5d52010-05-20 01:18:31 +0000631 QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType(Context);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000632
John McCalle66edc12009-11-24 19:00:30 +0000633 // Since the 'this' expression is synthesized, we don't need to
634 // perform the double-lookup check.
Craig Topperc3ec1492014-05-26 06:22:03 +0000635 NamedDecl *FirstQualifierInScope = nullptr;
John McCalle66edc12009-11-24 19:00:30 +0000636
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000637 return CXXDependentScopeMemberExpr::Create(
638 Context, /*This*/ nullptr, ThisType, /*IsArrow*/ true,
639 /*Op*/ SourceLocation(), SS.getWithLocInContext(Context), TemplateKWLoc,
640 FirstQualifierInScope, NameInfo, TemplateArgs);
John McCalle66edc12009-11-24 19:00:30 +0000641 }
642
Abramo Bagnara7945c982012-01-27 09:46:47 +0000643 return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
John McCalle66edc12009-11-24 19:00:30 +0000644}
645
John McCalldadc5752010-08-24 06:29:42 +0000646ExprResult
John McCalle66edc12009-11-24 19:00:30 +0000647Sema::BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
Abramo Bagnara7945c982012-01-27 09:46:47 +0000648 SourceLocation TemplateKWLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000649 const DeclarationNameInfo &NameInfo,
John McCalle66edc12009-11-24 19:00:30 +0000650 const TemplateArgumentListInfo *TemplateArgs) {
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000651 return DependentScopeDeclRefExpr::Create(
652 Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
653 TemplateArgs);
Douglas Gregor55ad91f2008-12-18 19:37:40 +0000654}
655
Vassil Vassilevb21ee082016-08-18 22:01:25 +0000656
657/// Determine whether we would be unable to instantiate this template (because
658/// it either has no definition, or is in the process of being instantiated).
659bool Sema::DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,
660 NamedDecl *Instantiation,
661 bool InstantiatedFromMember,
662 const NamedDecl *Pattern,
663 const NamedDecl *PatternDef,
664 TemplateSpecializationKind TSK,
665 bool Complain /*= true*/) {
Richard Smithedbc6e92016-10-14 21:41:24 +0000666 assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||
667 isa<VarDecl>(Instantiation));
Vassil Vassilevb21ee082016-08-18 22:01:25 +0000668
Richard Smithedbc6e92016-10-14 21:41:24 +0000669 bool IsEntityBeingDefined = false;
670 if (const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
671 IsEntityBeingDefined = TD->isBeingDefined();
672
673 if (PatternDef && !IsEntityBeingDefined) {
Vassil Vassilevb21ee082016-08-18 22:01:25 +0000674 NamedDecl *SuggestedDef = nullptr;
675 if (!hasVisibleDefinition(const_cast<NamedDecl*>(PatternDef), &SuggestedDef,
676 /*OnlyNeedComplete*/false)) {
677 // If we're allowed to diagnose this and recover, do so.
678 bool Recover = Complain && !isSFINAEContext();
679 if (Complain)
680 diagnoseMissingImport(PointOfInstantiation, SuggestedDef,
681 Sema::MissingImportKind::Definition, Recover);
682 return !Recover;
683 }
684 return false;
685 }
686
Richard Smith6f4e2e02016-08-23 19:41:39 +0000687 if (!Complain || (PatternDef && PatternDef->isInvalidDecl()))
688 return true;
Vassil Vassilevb21ee082016-08-18 22:01:25 +0000689
Richard Smithedbc6e92016-10-14 21:41:24 +0000690 llvm::Optional<unsigned> Note;
Vassil Vassilevb21ee082016-08-18 22:01:25 +0000691 QualType InstantiationTy;
692 if (TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
693 InstantiationTy = Context.getTypeDeclType(TD);
Richard Smith6f4e2e02016-08-23 19:41:39 +0000694 if (PatternDef) {
Vassil Vassilevb21ee082016-08-18 22:01:25 +0000695 Diag(PointOfInstantiation,
696 diag::err_template_instantiate_within_definition)
Richard Smithedbc6e92016-10-14 21:41:24 +0000697 << /*implicit|explicit*/(TSK != TSK_ImplicitInstantiation)
Vassil Vassilevb21ee082016-08-18 22:01:25 +0000698 << InstantiationTy;
699 // Not much point in noting the template declaration here, since
700 // we're lexically inside it.
701 Instantiation->setInvalidDecl();
702 } else if (InstantiatedFromMember) {
Richard Smith6f4e2e02016-08-23 19:41:39 +0000703 if (isa<FunctionDecl>(Instantiation)) {
704 Diag(PointOfInstantiation,
705 diag::err_explicit_instantiation_undefined_member)
Richard Smithedbc6e92016-10-14 21:41:24 +0000706 << /*member function*/ 1 << Instantiation->getDeclName()
707 << Instantiation->getDeclContext();
708 Note = diag::note_explicit_instantiation_here;
Richard Smith6f4e2e02016-08-23 19:41:39 +0000709 } else {
Richard Smithedbc6e92016-10-14 21:41:24 +0000710 assert(isa<TagDecl>(Instantiation) && "Must be a TagDecl!");
Richard Smith6f4e2e02016-08-23 19:41:39 +0000711 Diag(PointOfInstantiation,
712 diag::err_implicit_instantiate_member_undefined)
713 << InstantiationTy;
Richard Smithedbc6e92016-10-14 21:41:24 +0000714 Note = diag::note_member_declared_at;
Richard Smith6f4e2e02016-08-23 19:41:39 +0000715 }
Vassil Vassilevb21ee082016-08-18 22:01:25 +0000716 } else {
Richard Smithedbc6e92016-10-14 21:41:24 +0000717 if (isa<FunctionDecl>(Instantiation)) {
Richard Smith6f4e2e02016-08-23 19:41:39 +0000718 Diag(PointOfInstantiation,
719 diag::err_explicit_instantiation_undefined_func_template)
720 << Pattern;
Richard Smithedbc6e92016-10-14 21:41:24 +0000721 Note = diag::note_explicit_instantiation_here;
722 } else if (isa<TagDecl>(Instantiation)) {
Richard Smith6f4e2e02016-08-23 19:41:39 +0000723 Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
724 << (TSK != TSK_ImplicitInstantiation)
725 << InstantiationTy;
Richard Smithedbc6e92016-10-14 21:41:24 +0000726 Note = diag::note_template_decl_here;
727 } else {
728 assert(isa<VarDecl>(Instantiation) && "Must be a VarDecl!");
729 if (isa<VarTemplateSpecializationDecl>(Instantiation)) {
730 Diag(PointOfInstantiation,
731 diag::err_explicit_instantiation_undefined_var_template)
732 << Instantiation;
733 Instantiation->setInvalidDecl();
734 } else
735 Diag(PointOfInstantiation,
736 diag::err_explicit_instantiation_undefined_member)
737 << /*static data member*/ 2 << Instantiation->getDeclName()
738 << Instantiation->getDeclContext();
739 Note = diag::note_explicit_instantiation_here;
740 }
Vassil Vassilevb21ee082016-08-18 22:01:25 +0000741 }
Richard Smithedbc6e92016-10-14 21:41:24 +0000742 if (Note) // Diagnostics were emitted.
743 Diag(Pattern->getLocation(), Note.getValue());
Vassil Vassilevb21ee082016-08-18 22:01:25 +0000744
745 // In general, Instantiation isn't marked invalid to get more than one
746 // error for multiple undefined instantiations. But the code that does
747 // explicit declaration -> explicit definition conversion can't handle
748 // invalid declarations, so mark as invalid in that case.
749 if (TSK == TSK_ExplicitInstantiationDeclaration)
750 Instantiation->setInvalidDecl();
751 return true;
752}
753
Douglas Gregor5101c242008-12-05 18:15:24 +0000754/// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining
755/// that the template parameter 'PrevDecl' is being shadowed by a new
756/// declaration at location Loc. Returns true to indicate that this is
757/// an error, and false otherwise.
Douglas Gregorf4ef4d22011-10-20 17:58:49 +0000758void Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl) {
Douglas Gregor5daeee22008-12-08 18:40:42 +0000759 assert(PrevDecl->isTemplateParameter() && "Not a template parameter");
Douglas Gregor5101c242008-12-05 18:15:24 +0000760
761 // Microsoft Visual C++ permits template parameters to be shadowed.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000762 if (getLangOpts().MicrosoftExt)
Douglas Gregorf4ef4d22011-10-20 17:58:49 +0000763 return;
Douglas Gregor5101c242008-12-05 18:15:24 +0000764
765 // C++ [temp.local]p4:
766 // A template-parameter shall not be redeclared within its
767 // scope (including nested scopes).
Mike Stump11289f42009-09-09 15:08:12 +0000768 Diag(Loc, diag::err_template_param_shadow)
Douglas Gregor5101c242008-12-05 18:15:24 +0000769 << cast<NamedDecl>(PrevDecl)->getDeclName();
770 Diag(PrevDecl->getLocation(), diag::note_template_param_here);
Douglas Gregor5101c242008-12-05 18:15:24 +0000771}
772
Douglas Gregor463421d2009-03-03 04:44:36 +0000773/// AdjustDeclIfTemplate - If the given decl happens to be a template, reset
Douglas Gregorded2d7b2009-02-04 19:02:06 +0000774/// the parameter D to reference the templated declaration and return a pointer
775/// to the template declaration. Otherwise, do nothing to D and return null.
John McCall48871652010-08-21 09:40:31 +0000776TemplateDecl *Sema::AdjustDeclIfTemplate(Decl *&D) {
777 if (TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
778 D = Temp->getTemplatedDecl();
Douglas Gregorded2d7b2009-02-04 19:02:06 +0000779 return Temp;
780 }
Craig Topperc3ec1492014-05-26 06:22:03 +0000781 return nullptr;
Douglas Gregorded2d7b2009-02-04 19:02:06 +0000782}
783
Douglas Gregoreb29d182011-01-05 17:40:24 +0000784ParsedTemplateArgument ParsedTemplateArgument::getTemplatePackExpansion(
785 SourceLocation EllipsisLoc) const {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000786 assert(Kind == Template &&
Douglas Gregoreb29d182011-01-05 17:40:24 +0000787 "Only template template arguments can be pack expansions here");
788 assert(getAsTemplate().get().containsUnexpandedParameterPack() &&
789 "Template template argument pack expansion without packs");
790 ParsedTemplateArgument Result(*this);
791 Result.EllipsisLoc = EllipsisLoc;
792 return Result;
793}
794
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000795static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef,
796 const ParsedTemplateArgument &Arg) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000797
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000798 switch (Arg.getKind()) {
799 case ParsedTemplateArgument::Type: {
John McCallbcd03502009-12-07 02:54:59 +0000800 TypeSourceInfo *DI;
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000801 QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &DI);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000802 if (!DI)
John McCallbcd03502009-12-07 02:54:59 +0000803 DI = SemaRef.Context.getTrivialTypeSourceInfo(T, Arg.getLocation());
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000804 return TemplateArgumentLoc(TemplateArgument(T), DI);
805 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000806
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000807 case ParsedTemplateArgument::NonType: {
808 Expr *E = static_cast<Expr *>(Arg.getAsExpr());
809 return TemplateArgumentLoc(TemplateArgument(E), E);
810 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000811
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000812 case ParsedTemplateArgument::Template: {
John McCall3e56fd42010-08-23 07:28:44 +0000813 TemplateName Template = Arg.getAsTemplate().get();
Douglas Gregore1d60df2011-01-14 23:41:42 +0000814 TemplateArgument TArg;
815 if (Arg.getEllipsisLoc().isValid())
David Blaikie05785d12013-02-20 22:23:23 +0000816 TArg = TemplateArgument(Template, Optional<unsigned int>());
Douglas Gregore1d60df2011-01-14 23:41:42 +0000817 else
818 TArg = Template;
819 return TemplateArgumentLoc(TArg,
Douglas Gregor9d802122011-03-02 17:09:35 +0000820 Arg.getScopeSpec().getWithLocInContext(
821 SemaRef.Context),
Douglas Gregoreb29d182011-01-05 17:40:24 +0000822 Arg.getLocation(),
823 Arg.getEllipsisLoc());
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000824 }
825 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000826
Jeffrey Yasskin1615d452009-12-12 05:05:38 +0000827 llvm_unreachable("Unhandled parsed template argument");
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000828}
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000829
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000830/// Translates template arguments as provided by the parser
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000831/// into template arguments used by semantic analysis.
John McCall6b51f282009-11-23 01:53:49 +0000832void Sema::translateTemplateArguments(const ASTTemplateArgsPtr &TemplateArgsIn,
833 TemplateArgumentListInfo &TemplateArgs) {
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000834 for (unsigned I = 0, Last = TemplateArgsIn.size(); I != Last; ++I)
John McCall6b51f282009-11-23 01:53:49 +0000835 TemplateArgs.addArgument(translateTemplateArgument(*this,
836 TemplateArgsIn[I]));
Douglas Gregor9167f8b2009-11-11 01:00:40 +0000837}
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000838
Richard Smithb80d5402013-06-25 22:21:36 +0000839static void maybeDiagnoseTemplateParameterShadow(Sema &SemaRef, Scope *S,
840 SourceLocation Loc,
841 IdentifierInfo *Name) {
842 NamedDecl *PrevDecl = SemaRef.LookupSingleName(
Richard Smithbecb92d2017-10-10 22:33:17 +0000843 S, Name, Loc, Sema::LookupOrdinaryName, Sema::ForVisibleRedeclaration);
Richard Smithb80d5402013-06-25 22:21:36 +0000844 if (PrevDecl && PrevDecl->isTemplateParameter())
845 SemaRef.DiagnoseTemplateParameterShadow(Loc, PrevDecl);
846}
847
Richard Smith77a9c602018-02-28 03:02:23 +0000848/// Convert a parsed type into a parsed template argument. This is mostly
849/// trivial, except that we may have parsed a C++17 deduced class template
850/// specialization type, in which case we should form a template template
851/// argument instead of a type template argument.
852ParsedTemplateArgument Sema::ActOnTemplateTypeArgument(TypeResult ParsedType) {
853 TypeSourceInfo *TInfo;
854 QualType T = GetTypeFromParser(ParsedType.get(), &TInfo);
855 if (T.isNull())
856 return ParsedTemplateArgument();
857 assert(TInfo && "template argument with no location");
858
859 // If we might have formed a deduced template specialization type, convert
860 // it to a template template argument.
861 if (getLangOpts().CPlusPlus17) {
862 TypeLoc TL = TInfo->getTypeLoc();
863 SourceLocation EllipsisLoc;
864 if (auto PET = TL.getAs<PackExpansionTypeLoc>()) {
865 EllipsisLoc = PET.getEllipsisLoc();
866 TL = PET.getPatternLoc();
867 }
868
869 CXXScopeSpec SS;
870 if (auto ET = TL.getAs<ElaboratedTypeLoc>()) {
871 SS.Adopt(ET.getQualifierLoc());
872 TL = ET.getNamedTypeLoc();
873 }
874
875 if (auto DTST = TL.getAs<DeducedTemplateSpecializationTypeLoc>()) {
876 TemplateName Name = DTST.getTypePtr()->getTemplateName();
877 if (SS.isSet())
878 Name = Context.getQualifiedTemplateName(SS.getScopeRep(),
879 /*HasTemplateKeyword*/ false,
880 Name.getAsTemplateDecl());
881 ParsedTemplateArgument Result(SS, TemplateTy::make(Name),
882 DTST.getTemplateNameLoc());
883 if (EllipsisLoc.isValid())
884 Result = Result.getTemplatePackExpansion(EllipsisLoc);
885 return Result;
886 }
887 }
888
889 // This is a normal type template argument. Note, if the type template
890 // argument is an injected-class-name for a template, it has a dual nature
891 // and can be used as either a type or a template. We handle that in
892 // convertTypeTemplateArgumentToTemplate.
893 return ParsedTemplateArgument(ParsedTemplateArgument::Type,
894 ParsedType.get().getAsOpaquePtr(),
895 TInfo->getTypeLoc().getLocStart());
896}
897
Douglas Gregor5101c242008-12-05 18:15:24 +0000898/// ActOnTypeParameter - Called when a C++ template type parameter
899/// (e.g., "typename T") has been parsed. Typename specifies whether
900/// the keyword "typename" was used to declare the type parameter
901/// (otherwise, "class" was used), and KeyLoc is the location of the
902/// "class" or "typename" keyword. ParamName is the name of the
903/// parameter (NULL indicates an unnamed template parameter) and
Chandler Carruth08836322011-05-01 00:51:33 +0000904/// ParamNameLoc is the location of the parameter name (if any).
Douglas Gregor5101c242008-12-05 18:15:24 +0000905/// If the type parameter has a default argument, it will be added
906/// later via ActOnTypeParameterDefault.
Faisal Valibe294032017-12-23 18:56:34 +0000907NamedDecl *Sema::ActOnTypeParameter(Scope *S, bool Typename,
John McCall48871652010-08-21 09:40:31 +0000908 SourceLocation EllipsisLoc,
909 SourceLocation KeyLoc,
910 IdentifierInfo *ParamName,
911 SourceLocation ParamNameLoc,
912 unsigned Depth, unsigned Position,
913 SourceLocation EqualLoc,
John McCallba7bf592010-08-24 05:47:05 +0000914 ParsedType DefaultArg) {
Mike Stump11289f42009-09-09 15:08:12 +0000915 assert(S->isTemplateParamScope() &&
916 "Template type parameter not in template parameter scope!");
Douglas Gregor5101c242008-12-05 18:15:24 +0000917
Douglas Gregorcd72ba92009-02-06 22:42:48 +0000918 SourceLocation Loc = ParamNameLoc;
919 if (!ParamName)
920 Loc = KeyLoc;
921
Nikola Smiljanic69fdc9f2014-06-06 02:58:59 +0000922 bool IsParameterPack = EllipsisLoc.isValid();
Douglas Gregor5101c242008-12-05 18:15:24 +0000923 TemplateTypeParmDecl *Param
John McCallf7b2fb52010-01-22 00:28:27 +0000924 = TemplateTypeParmDecl::Create(Context, Context.getTranslationUnitDecl(),
Abramo Bagnarab3185b02011-03-06 15:48:19 +0000925 KeyLoc, Loc, Depth, Position, ParamName,
Nikola Smiljanic69fdc9f2014-06-06 02:58:59 +0000926 Typename, IsParameterPack);
Douglas Gregorfd7c2252011-03-04 17:52:15 +0000927 Param->setAccess(AS_public);
Douglas Gregor5101c242008-12-05 18:15:24 +0000928
929 if (ParamName) {
Richard Smithb80d5402013-06-25 22:21:36 +0000930 maybeDiagnoseTemplateParameterShadow(*this, S, ParamNameLoc, ParamName);
931
Douglas Gregor5101c242008-12-05 18:15:24 +0000932 // Add the template parameter into the current scope.
John McCall48871652010-08-21 09:40:31 +0000933 S->AddDecl(Param);
Douglas Gregor5101c242008-12-05 18:15:24 +0000934 IdResolver.AddDecl(Param);
935 }
936
Douglas Gregorf5500772011-01-05 15:48:55 +0000937 // C++0x [temp.param]p9:
938 // A default template-argument may be specified for any kind of
939 // template-parameter that is not a template parameter pack.
Nikola Smiljanic69fdc9f2014-06-06 02:58:59 +0000940 if (DefaultArg && IsParameterPack) {
Douglas Gregorf5500772011-01-05 15:48:55 +0000941 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
David Blaikieefdccaa2016-01-15 23:43:34 +0000942 DefaultArg = nullptr;
Douglas Gregorf5500772011-01-05 15:48:55 +0000943 }
944
Douglas Gregordc13ded2010-07-01 00:00:45 +0000945 // Handle the default argument, if provided.
946 if (DefaultArg) {
947 TypeSourceInfo *DefaultTInfo;
948 GetTypeFromParser(DefaultArg, &DefaultTInfo);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000949
Douglas Gregordc13ded2010-07-01 00:00:45 +0000950 assert(DefaultTInfo && "expected source information for type");
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000951
Douglas Gregor6ff1fbf2010-12-16 08:48:57 +0000952 // Check for unexpanded parameter packs.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000953 if (DiagnoseUnexpandedParameterPack(Loc, DefaultTInfo,
Douglas Gregor6ff1fbf2010-12-16 08:48:57 +0000954 UPPC_DefaultArgument))
955 return Param;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000956
Douglas Gregordc13ded2010-07-01 00:00:45 +0000957 // Check the template argument itself.
958 if (CheckTemplateArgument(Param, DefaultTInfo)) {
959 Param->setInvalidDecl();
John McCall48871652010-08-21 09:40:31 +0000960 return Param;
Douglas Gregordc13ded2010-07-01 00:00:45 +0000961 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000962
Richard Smith1469b912015-06-10 00:29:03 +0000963 Param->setDefaultArgument(DefaultTInfo);
Douglas Gregordc13ded2010-07-01 00:00:45 +0000964 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +0000965
John McCall48871652010-08-21 09:40:31 +0000966 return Param;
Douglas Gregor5101c242008-12-05 18:15:24 +0000967}
968
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000969/// Check that the type of a non-type template parameter is
Douglas Gregor463421d2009-03-03 04:44:36 +0000970/// well-formed.
971///
972/// \returns the (possibly-promoted) parameter type if valid;
973/// otherwise, produces a diagnostic and returns a NULL type.
Richard Smith15361a22016-12-28 06:27:18 +0000974QualType Sema::CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
975 SourceLocation Loc) {
976 if (TSI->getType()->isUndeducedType()) {
977 // C++1z [temp.dep.expr]p3:
978 // An id-expression is type-dependent if it contains
979 // - an identifier associated by name lookup with a non-type
980 // template-parameter declared with a type that contains a
981 // placeholder type (7.1.7.4),
982 TSI = SubstAutoTypeSourceInfo(TSI, Context.DependentTy);
983 }
984
985 return CheckNonTypeTemplateParameterType(TSI->getType(), Loc);
986}
987
988QualType Sema::CheckNonTypeTemplateParameterType(QualType T,
989 SourceLocation Loc) {
Douglas Gregora09387d2010-05-23 19:57:01 +0000990 // We don't allow variably-modified types as the type of non-type template
991 // parameters.
992 if (T->isVariablyModifiedType()) {
993 Diag(Loc, diag::err_variably_modified_nontype_template_param)
994 << T;
995 return QualType();
996 }
997
Douglas Gregor463421d2009-03-03 04:44:36 +0000998 // C++ [temp.param]p4:
999 //
1000 // A non-type template-parameter shall have one of the following
1001 // (optionally cv-qualified) types:
1002 //
1003 // -- integral or enumeration type,
Douglas Gregorb90df602010-06-16 00:17:44 +00001004 if (T->isIntegralOrEnumerationType() ||
Mike Stump11289f42009-09-09 15:08:12 +00001005 // -- pointer to object or pointer to function,
Eli Friedmana170cd62010-08-05 02:49:48 +00001006 T->isPointerType() ||
Mike Stump11289f42009-09-09 15:08:12 +00001007 // -- reference to object or reference to function,
Douglas Gregor463421d2009-03-03 04:44:36 +00001008 T->isReferenceType() ||
Douglas Gregor80af3132011-05-21 23:15:46 +00001009 // -- pointer to member,
Douglas Gregor463421d2009-03-03 04:44:36 +00001010 T->isMemberPointerType() ||
Douglas Gregor80af3132011-05-21 23:15:46 +00001011 // -- std::nullptr_t.
1012 T->isNullPtrType() ||
Douglas Gregor463421d2009-03-03 04:44:36 +00001013 // If T is a dependent type, we can't do the check now, so we
1014 // assume that it is well-formed.
Richard Smith5f274382016-09-28 23:55:27 +00001015 T->isDependentType() ||
1016 // Allow use of auto in template parameter declarations.
1017 T->isUndeducedType()) {
Richard Smithd0e1c952012-03-13 07:21:50 +00001018 // C++ [temp.param]p5: The top-level cv-qualifiers on the template-parameter
1019 // are ignored when determining its type.
1020 return T.getUnqualifiedType();
1021 }
1022
Douglas Gregor463421d2009-03-03 04:44:36 +00001023 // C++ [temp.param]p8:
1024 //
1025 // A non-type template-parameter of type "array of T" or
1026 // "function returning T" is adjusted to be of type "pointer to
1027 // T" or "pointer to function returning T", respectively.
Richard Smithd663fdd2014-12-17 20:42:37 +00001028 else if (T->isArrayType() || T->isFunctionType())
1029 return Context.getDecayedType(T);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001030
Douglas Gregor463421d2009-03-03 04:44:36 +00001031 Diag(Loc, diag::err_template_nontype_parm_bad_type)
1032 << T;
1033
1034 return QualType();
1035}
1036
Faisal Valibe294032017-12-23 18:56:34 +00001037NamedDecl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
John McCall48871652010-08-21 09:40:31 +00001038 unsigned Depth,
1039 unsigned Position,
1040 SourceLocation EqualLoc,
John McCallb268a282010-08-23 23:25:46 +00001041 Expr *Default) {
John McCall8cb7bdf2010-06-04 23:28:52 +00001042 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
Richard Smith15361a22016-12-28 06:27:18 +00001043
Faisal Valia223d1c2017-12-22 03:50:55 +00001044 // Check that we have valid decl-specifiers specified.
1045 auto CheckValidDeclSpecifiers = [this, &D] {
1046 // C++ [temp.param]
1047 // p1
Malcolm Parsonsfab36802018-04-16 08:31:08 +00001048 // template-parameter:
1049 // ...
1050 // parameter-declaration
Faisal Valia223d1c2017-12-22 03:50:55 +00001051 // p2
1052 // ... A storage class shall not be specified in a template-parameter
1053 // declaration.
1054 // [dcl.typedef]p1:
1055 // The typedef specifier [...] shall not be used in the decl-specifier-seq
1056 // of a parameter-declaration
1057 const DeclSpec &DS = D.getDeclSpec();
1058 auto EmitDiag = [this](SourceLocation Loc) {
1059 Diag(Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
1060 << FixItHint::CreateRemoval(Loc);
1061 };
1062 if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified)
1063 EmitDiag(DS.getStorageClassSpecLoc());
1064
Sam McCall1371cba2017-12-22 07:09:51 +00001065 if (DS.getThreadStorageClassSpec() != TSCS_unspecified)
Faisal Valia223d1c2017-12-22 03:50:55 +00001066 EmitDiag(DS.getThreadStorageClassSpecLoc());
1067
1068 // [dcl.inline]p1:
1069 // The inline specifier can be applied only to the declaration or
1070 // definition of a variable or function.
1071
1072 if (DS.isInlineSpecified())
1073 EmitDiag(DS.getInlineSpecLoc());
1074
1075 // [dcl.constexpr]p1:
1076 // The constexpr specifier shall be applied only to the definition of a
1077 // variable or variable template or the declaration of a function or
1078 // function template.
1079
1080 if (DS.isConstexprSpecified())
1081 EmitDiag(DS.getConstexprSpecLoc());
1082
1083 // [dcl.fct.spec]p1:
1084 // Function-specifiers can be used only in function declarations.
1085
1086 if (DS.isVirtualSpecified())
1087 EmitDiag(DS.getVirtualSpecLoc());
1088
1089 if (DS.isExplicitSpecified())
1090 EmitDiag(DS.getExplicitSpecLoc());
1091
1092 if (DS.isNoreturnSpecified())
1093 EmitDiag(DS.getNoreturnSpecLoc());
1094 };
1095
1096 CheckValidDeclSpecifiers();
1097
Richard Smith15361a22016-12-28 06:27:18 +00001098 if (TInfo->getType()->isUndeducedType()) {
1099 Diag(D.getIdentifierLoc(),
1100 diag::warn_cxx14_compat_template_nontype_parm_auto_type)
1101 << QualType(TInfo->getType()->getContainedAutoType(), 0);
1102 }
Douglas Gregor5101c242008-12-05 18:15:24 +00001103
Douglas Gregorded2d7b2009-02-04 19:02:06 +00001104 assert(S->isTemplateParamScope() &&
1105 "Non-type template parameter not in template parameter scope!");
Douglas Gregor5101c242008-12-05 18:15:24 +00001106 bool Invalid = false;
1107
Richard Smith15361a22016-12-28 06:27:18 +00001108 QualType T = CheckNonTypeTemplateParameterType(TInfo, D.getIdentifierLoc());
Douglas Gregor38ee75e2010-12-16 15:36:43 +00001109 if (T.isNull()) {
Douglas Gregor463421d2009-03-03 04:44:36 +00001110 T = Context.IntTy; // Recover with an 'int' type.
Douglas Gregorce0fc86f2009-03-09 16:46:39 +00001111 Invalid = true;
1112 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001113
Richard Smithb80d5402013-06-25 22:21:36 +00001114 IdentifierInfo *ParamName = D.getIdentifier();
Douglas Gregorda3cc0d2010-12-23 23:51:58 +00001115 bool IsParameterPack = D.hasEllipsis();
Douglas Gregor5101c242008-12-05 18:15:24 +00001116 NonTypeTemplateParmDecl *Param
John McCallf7b2fb52010-01-22 00:28:27 +00001117 = NonTypeTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(),
Daniel Dunbar62ee6412012-03-09 18:35:03 +00001118 D.getLocStart(),
John McCallf7b2fb52010-01-22 00:28:27 +00001119 D.getIdentifierLoc(),
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001120 Depth, Position, ParamName, T,
Douglas Gregorda3cc0d2010-12-23 23:51:58 +00001121 IsParameterPack, TInfo);
Douglas Gregorfd7c2252011-03-04 17:52:15 +00001122 Param->setAccess(AS_public);
Richard Smithb80d5402013-06-25 22:21:36 +00001123
Douglas Gregor5101c242008-12-05 18:15:24 +00001124 if (Invalid)
1125 Param->setInvalidDecl();
1126
Richard Smithb80d5402013-06-25 22:21:36 +00001127 if (ParamName) {
1128 maybeDiagnoseTemplateParameterShadow(*this, S, D.getIdentifierLoc(),
1129 ParamName);
1130
Douglas Gregor5101c242008-12-05 18:15:24 +00001131 // Add the template parameter into the current scope.
John McCall48871652010-08-21 09:40:31 +00001132 S->AddDecl(Param);
Douglas Gregor5101c242008-12-05 18:15:24 +00001133 IdResolver.AddDecl(Param);
1134 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001135
Douglas Gregorf5500772011-01-05 15:48:55 +00001136 // C++0x [temp.param]p9:
1137 // A default template-argument may be specified for any kind of
1138 // template-parameter that is not a template parameter pack.
1139 if (Default && IsParameterPack) {
1140 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
Craig Topperc3ec1492014-05-26 06:22:03 +00001141 Default = nullptr;
Douglas Gregorf5500772011-01-05 15:48:55 +00001142 }
1143
Douglas Gregordc13ded2010-07-01 00:00:45 +00001144 // Check the well-formedness of the default template argument, if provided.
Douglas Gregorda3cc0d2010-12-23 23:51:58 +00001145 if (Default) {
Douglas Gregor6ff1fbf2010-12-16 08:48:57 +00001146 // Check for unexpanded parameter packs.
1147 if (DiagnoseUnexpandedParameterPack(Default, UPPC_DefaultArgument))
1148 return Param;
1149
Douglas Gregordc13ded2010-07-01 00:00:45 +00001150 TemplateArgument Converted;
Richard Smithd663fdd2014-12-17 20:42:37 +00001151 ExprResult DefaultRes =
1152 CheckTemplateArgument(Param, Param->getType(), Default, Converted);
John Wiegley01296292011-04-08 18:41:53 +00001153 if (DefaultRes.isInvalid()) {
Douglas Gregordc13ded2010-07-01 00:00:45 +00001154 Param->setInvalidDecl();
John McCall48871652010-08-21 09:40:31 +00001155 return Param;
Douglas Gregordc13ded2010-07-01 00:00:45 +00001156 }
Nikola Smiljanic01a75982014-05-29 10:55:11 +00001157 Default = DefaultRes.get();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001158
Richard Smith1469b912015-06-10 00:29:03 +00001159 Param->setDefaultArgument(Default);
Douglas Gregordc13ded2010-07-01 00:00:45 +00001160 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001161
John McCall48871652010-08-21 09:40:31 +00001162 return Param;
Douglas Gregor5101c242008-12-05 18:15:24 +00001163}
Douglas Gregorb9bd8a92008-12-24 02:52:09 +00001164
Douglas Gregorded2d7b2009-02-04 19:02:06 +00001165/// ActOnTemplateTemplateParameter - Called when a C++ template template
James Dennett2a4d13c2012-06-15 07:13:21 +00001166/// parameter (e.g. T in template <template \<typename> class T> class array)
Douglas Gregorded2d7b2009-02-04 19:02:06 +00001167/// has been parsed. S is the current scope.
Faisal Valibe294032017-12-23 18:56:34 +00001168NamedDecl *Sema::ActOnTemplateTemplateParameter(Scope* S,
John McCall48871652010-08-21 09:40:31 +00001169 SourceLocation TmpLoc,
Richard Trieu9becef62011-09-09 03:18:59 +00001170 TemplateParameterList *Params,
Douglas Gregorf5500772011-01-05 15:48:55 +00001171 SourceLocation EllipsisLoc,
John McCall48871652010-08-21 09:40:31 +00001172 IdentifierInfo *Name,
1173 SourceLocation NameLoc,
1174 unsigned Depth,
1175 unsigned Position,
1176 SourceLocation EqualLoc,
Douglas Gregorf5500772011-01-05 15:48:55 +00001177 ParsedTemplateArgument Default) {
Douglas Gregorded2d7b2009-02-04 19:02:06 +00001178 assert(S->isTemplateParamScope() &&
1179 "Template template parameter not in template parameter scope!");
1180
1181 // Construct the parameter object.
Douglas Gregorf5500772011-01-05 15:48:55 +00001182 bool IsParameterPack = EllipsisLoc.isValid();
Douglas Gregorded2d7b2009-02-04 19:02:06 +00001183 TemplateTemplateParmDecl *Param =
John McCallf7b2fb52010-01-22 00:28:27 +00001184 TemplateTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(),
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001185 NameLoc.isInvalid()? TmpLoc : NameLoc,
1186 Depth, Position, IsParameterPack,
Douglas Gregorf5500772011-01-05 15:48:55 +00001187 Name, Params);
Douglas Gregorfd7c2252011-03-04 17:52:15 +00001188 Param->setAccess(AS_public);
Simon Pilgrim6905d222016-12-30 22:55:33 +00001189
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001190 // If the template template parameter has a name, then link the identifier
Douglas Gregordc13ded2010-07-01 00:00:45 +00001191 // into the scope and lookup mechanisms.
Douglas Gregorded2d7b2009-02-04 19:02:06 +00001192 if (Name) {
Richard Smithb80d5402013-06-25 22:21:36 +00001193 maybeDiagnoseTemplateParameterShadow(*this, S, NameLoc, Name);
1194
John McCall48871652010-08-21 09:40:31 +00001195 S->AddDecl(Param);
Douglas Gregorded2d7b2009-02-04 19:02:06 +00001196 IdResolver.AddDecl(Param);
1197 }
1198
Douglas Gregor6ff1fbf2010-12-16 08:48:57 +00001199 if (Params->size() == 0) {
1200 Diag(Param->getLocation(), diag::err_template_template_parm_no_parms)
1201 << SourceRange(Params->getLAngleLoc(), Params->getRAngleLoc());
1202 Param->setInvalidDecl();
1203 }
1204
Douglas Gregorf5500772011-01-05 15:48:55 +00001205 // C++0x [temp.param]p9:
1206 // A default template-argument may be specified for any kind of
1207 // template-parameter that is not a template parameter pack.
1208 if (IsParameterPack && !Default.isInvalid()) {
1209 Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1210 Default = ParsedTemplateArgument();
1211 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001212
Douglas Gregordc13ded2010-07-01 00:00:45 +00001213 if (!Default.isInvalid()) {
1214 // Check only that we have a template template argument. We don't want to
1215 // try to check well-formedness now, because our template template parameter
1216 // might have dependent types in its template parameters, which we wouldn't
1217 // be able to match now.
1218 //
1219 // If none of the template template parameter's template arguments mention
1220 // other template parameters, we could actually perform more checking here.
1221 // However, it isn't worth doing.
1222 TemplateArgumentLoc DefaultArg = translateTemplateArgument(*this, Default);
1223 if (DefaultArg.getArgument().getAsTemplate().isNull()) {
Faisal Valib8b04f82016-03-26 20:46:45 +00001224 Diag(DefaultArg.getLocation(), diag::err_template_arg_not_valid_template)
Douglas Gregordc13ded2010-07-01 00:00:45 +00001225 << DefaultArg.getSourceRange();
John McCall48871652010-08-21 09:40:31 +00001226 return Param;
Douglas Gregordc13ded2010-07-01 00:00:45 +00001227 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001228
Douglas Gregor6ff1fbf2010-12-16 08:48:57 +00001229 // Check for unexpanded parameter packs.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001230 if (DiagnoseUnexpandedParameterPack(DefaultArg.getLocation(),
Douglas Gregor6ff1fbf2010-12-16 08:48:57 +00001231 DefaultArg.getArgument().getAsTemplate(),
1232 UPPC_DefaultArgument))
1233 return Param;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001234
Richard Smith1469b912015-06-10 00:29:03 +00001235 Param->setDefaultArgument(Context, DefaultArg);
Douglas Gregordba32632009-02-10 19:49:53 +00001236 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001237
John McCall48871652010-08-21 09:40:31 +00001238 return Param;
Douglas Gregordba32632009-02-10 19:49:53 +00001239}
1240
Hubert Tongf608c052016-04-29 18:05:37 +00001241/// ActOnTemplateParameterList - Builds a TemplateParameterList, optionally
1242/// constrained by RequiresClause, that contains the template parameters in
1243/// Params.
Richard Trieu9becef62011-09-09 03:18:59 +00001244TemplateParameterList *
Douglas Gregorb9bd8a92008-12-24 02:52:09 +00001245Sema::ActOnTemplateParameterList(unsigned Depth,
1246 SourceLocation ExportLoc,
Mike Stump11289f42009-09-09 15:08:12 +00001247 SourceLocation TemplateLoc,
Douglas Gregorb9bd8a92008-12-24 02:52:09 +00001248 SourceLocation LAngleLoc,
Faisal Valif241b0d2017-08-25 18:24:20 +00001249 ArrayRef<NamedDecl *> Params,
Hubert Tongf608c052016-04-29 18:05:37 +00001250 SourceLocation RAngleLoc,
1251 Expr *RequiresClause) {
Douglas Gregorb9bd8a92008-12-24 02:52:09 +00001252 if (ExportLoc.isValid())
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00001253 Diag(ExportLoc, diag::warn_template_export_unsupported);
Douglas Gregorb9bd8a92008-12-24 02:52:09 +00001254
David Majnemer902f8c62015-12-27 07:16:27 +00001255 return TemplateParameterList::Create(
1256 Context, TemplateLoc, LAngleLoc,
Faisal Valif241b0d2017-08-25 18:24:20 +00001257 llvm::makeArrayRef(Params.data(), Params.size()),
Hubert Tonge4a0c0e2016-07-30 22:33:34 +00001258 RAngleLoc, RequiresClause);
Douglas Gregorb9bd8a92008-12-24 02:52:09 +00001259}
Douglas Gregorded2d7b2009-02-04 19:02:06 +00001260
John McCall3e11ebe2010-03-15 10:12:16 +00001261static void SetNestedNameSpecifier(TagDecl *T, const CXXScopeSpec &SS) {
1262 if (SS.isSet())
Douglas Gregor14454802011-02-25 02:25:35 +00001263 T->setQualifierInfo(SS.getWithLocInContext(T->getASTContext()));
John McCall3e11ebe2010-03-15 10:12:16 +00001264}
1265
Erich Keanec480f302018-07-12 21:09:05 +00001266DeclResult Sema::CheckClassTemplate(
1267 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
1268 CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
1269 const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,
1270 AccessSpecifier AS, SourceLocation ModulePrivateLoc,
1271 SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists,
1272 TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody) {
Mike Stump11289f42009-09-09 15:08:12 +00001273 assert(TemplateParams && TemplateParams->size() > 0 &&
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00001274 "No template parameters");
John McCall9bb74a52009-07-31 02:45:11 +00001275 assert(TUK != TUK_Reference && "Can only declare or define class templates");
Douglas Gregordba32632009-02-10 19:49:53 +00001276 bool Invalid = false;
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001277
1278 // Check that we can declare a template here.
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00001279 if (CheckTemplateDeclScope(S, TemplateParams))
Douglas Gregorc08f4892009-03-25 00:13:59 +00001280 return true;
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001281
Abramo Bagnara6150c882010-05-11 21:36:43 +00001282 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
1283 assert(Kind != TTK_Enum && "can't build template of enumerated type");
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001284
1285 // There is no such thing as an unnamed class template.
1286 if (!Name) {
1287 Diag(KWLoc, diag::err_template_unnamed_class);
Douglas Gregorc08f4892009-03-25 00:13:59 +00001288 return true;
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001289 }
1290
Richard Smith6483d222012-04-21 01:27:54 +00001291 // Find any previous declaration with this name. For a friend with no
1292 // scope explicitly specified, we only look for tag declarations (per
1293 // C++11 [basic.lookup.elab]p2).
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00001294 DeclContext *SemanticContext;
Richard Smith6483d222012-04-21 01:27:54 +00001295 LookupResult Previous(*this, Name, NameLoc,
1296 (SS.isEmpty() && TUK == TUK_Friend)
1297 ? LookupTagName : LookupOrdinaryName,
Richard Smithbecb92d2017-10-10 22:33:17 +00001298 forRedeclarationInCurContext());
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00001299 if (SS.isNotEmpty() && !SS.isInvalid()) {
1300 SemanticContext = computeDeclContext(SS, true);
1301 if (!SemanticContext) {
Douglas Gregor67daacb2012-03-30 16:20:47 +00001302 // FIXME: Horrible, horrible hack! We can't currently represent this
1303 // in the AST, and historically we have just ignored such friend
1304 // class templates, so don't complain here.
Richard Smithcd556eb2013-11-08 18:59:56 +00001305 Diag(NameLoc, TUK == TUK_Friend
1306 ? diag::warn_template_qualified_friend_ignored
1307 : diag::err_template_qualified_declarator_no_match)
Douglas Gregor67daacb2012-03-30 16:20:47 +00001308 << SS.getScopeRep() << SS.getRange();
Richard Smithcd556eb2013-11-08 18:59:56 +00001309 return TUK != TUK_Friend;
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00001310 }
Mike Stump11289f42009-09-09 15:08:12 +00001311
John McCall0b66eb32010-05-01 00:40:08 +00001312 if (RequireCompleteDeclContext(SS, SemanticContext))
1313 return true;
1314
Simon Pilgrim6905d222016-12-30 22:55:33 +00001315 // If we're adding a template to a dependent context, we may need to
1316 // rebuilding some of the types used within the template parameter list,
Douglas Gregor041b0842011-10-14 15:31:12 +00001317 // now that we know what the current instantiation is.
1318 if (SemanticContext->isDependentContext()) {
1319 ContextRAII SavedContext(*this, SemanticContext);
1320 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
1321 Invalid = true;
Douglas Gregorb7d17dd2012-03-28 16:01:27 +00001322 } else if (TUK != TUK_Friend && TUK != TUK_Reference)
Richard Smithc660c8f2018-03-16 13:36:56 +00001323 diagnoseQualifiedDeclaration(SS, SemanticContext, Name, NameLoc, false);
Richard Smith6483d222012-04-21 01:27:54 +00001324
John McCall27b18f82009-11-17 02:14:36 +00001325 LookupQualifiedName(Previous, SemanticContext);
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00001326 } else {
1327 SemanticContext = CurContext;
Richard Smith88fe69c2015-07-06 01:45:27 +00001328
1329 // C++14 [class.mem]p14:
1330 // If T is the name of a class, then each of the following shall have a
1331 // name different from T:
1332 // -- every member template of class T
1333 if (TUK != TUK_Friend &&
1334 DiagnoseClassNameShadow(SemanticContext,
1335 DeclarationNameInfo(Name, NameLoc)))
1336 return true;
1337
John McCall27b18f82009-11-17 02:14:36 +00001338 LookupName(Previous, S);
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00001339 }
Mike Stump11289f42009-09-09 15:08:12 +00001340
Douglas Gregorce40e2e2010-04-12 16:00:01 +00001341 if (Previous.isAmbiguous())
1342 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001343
Craig Topperc3ec1492014-05-26 06:22:03 +00001344 NamedDecl *PrevDecl = nullptr;
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001345 if (Previous.begin() != Previous.end())
Douglas Gregorce40e2e2010-04-12 16:00:01 +00001346 PrevDecl = (*Previous.begin())->getUnderlyingDecl();
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001347
Serge Pavlove50bf752016-06-10 04:39:07 +00001348 if (PrevDecl && PrevDecl->isTemplateParameter()) {
1349 // Maybe we will complain about the shadowed template parameter.
1350 DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
1351 // Just pretend that we didn't see the previous declaration.
1352 PrevDecl = nullptr;
1353 }
1354
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001355 // If there is a previous declaration with the same name, check
1356 // whether this is a valid redeclaration.
Richard Smithbecb92d2017-10-10 22:33:17 +00001357 ClassTemplateDecl *PrevClassTemplate =
1358 dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
Douglas Gregor7f34bae2009-10-09 21:11:42 +00001359
1360 // We may have found the injected-class-name of a class template,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001361 // class template partial specialization, or class template specialization.
Douglas Gregor7f34bae2009-10-09 21:11:42 +00001362 // In these cases, grab the template that is being defined or specialized.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001363 if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) &&
Douglas Gregor7f34bae2009-10-09 21:11:42 +00001364 cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
1365 PrevDecl = cast<CXXRecordDecl>(PrevDecl->getDeclContext());
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001366 PrevClassTemplate
Douglas Gregor7f34bae2009-10-09 21:11:42 +00001367 = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
1368 if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
1369 PrevClassTemplate
1370 = cast<ClassTemplateSpecializationDecl>(PrevDecl)
1371 ->getSpecializedTemplate();
1372 }
1373 }
1374
John McCalld43784f2009-12-18 11:25:59 +00001375 if (TUK == TUK_Friend) {
John McCall90d3bb92009-12-17 23:21:11 +00001376 // C++ [namespace.memdef]p3:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001377 // [...] When looking for a prior declaration of a class or a function
1378 // declared as a friend, and when the name of the friend class or
John McCall90d3bb92009-12-17 23:21:11 +00001379 // function is neither a qualified name nor a template-id, scopes outside
1380 // the innermost enclosing namespace scope are not considered.
Douglas Gregorb74b1032010-04-18 17:37:40 +00001381 if (!SS.isSet()) {
1382 DeclContext *OutermostContext = CurContext;
1383 while (!OutermostContext->isFileContext())
1384 OutermostContext = OutermostContext->getLookupParent();
John McCalld43784f2009-12-18 11:25:59 +00001385
Richard Smith61e582f2012-04-20 07:12:26 +00001386 if (PrevDecl &&
Douglas Gregorb74b1032010-04-18 17:37:40 +00001387 (OutermostContext->Equals(PrevDecl->getDeclContext()) ||
1388 OutermostContext->Encloses(PrevDecl->getDeclContext()))) {
1389 SemanticContext = PrevDecl->getDeclContext();
1390 } else {
1391 // Declarations in outer scopes don't matter. However, the outermost
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001392 // context we computed is the semantic context for our new
Douglas Gregorb74b1032010-04-18 17:37:40 +00001393 // declaration.
Craig Topperc3ec1492014-05-26 06:22:03 +00001394 PrevDecl = PrevClassTemplate = nullptr;
Douglas Gregorb74b1032010-04-18 17:37:40 +00001395 SemanticContext = OutermostContext;
Richard Smith6483d222012-04-21 01:27:54 +00001396
1397 // Check that the chosen semantic context doesn't already contain a
1398 // declaration of this name as a non-tag type.
Richard Smithfc805ca2015-07-06 04:43:58 +00001399 Previous.clear(LookupOrdinaryName);
Richard Smith6483d222012-04-21 01:27:54 +00001400 DeclContext *LookupContext = SemanticContext;
1401 while (LookupContext->isTransparentContext())
1402 LookupContext = LookupContext->getLookupParent();
1403 LookupQualifiedName(Previous, LookupContext);
1404
1405 if (Previous.isAmbiguous())
1406 return true;
1407
1408 if (Previous.begin() != Previous.end())
1409 PrevDecl = (*Previous.begin())->getUnderlyingDecl();
Douglas Gregorb74b1032010-04-18 17:37:40 +00001410 }
John McCall90d3bb92009-12-17 23:21:11 +00001411 }
Richard Smith72bcaec2013-12-05 04:30:04 +00001412 } else if (PrevDecl &&
Richard Smithfc805ca2015-07-06 04:43:58 +00001413 !isDeclInScope(Previous.getRepresentativeDecl(), SemanticContext,
1414 S, SS.isValid()))
Craig Topperc3ec1492014-05-26 06:22:03 +00001415 PrevDecl = PrevClassTemplate = nullptr;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001416
Richard Smithfc805ca2015-07-06 04:43:58 +00001417 if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
1418 PrevDecl ? Previous.getRepresentativeDecl() : nullptr)) {
1419 if (SS.isEmpty() &&
1420 !(PrevClassTemplate &&
1421 PrevClassTemplate->getDeclContext()->getRedeclContext()->Equals(
1422 SemanticContext->getRedeclContext()))) {
1423 Diag(KWLoc, diag::err_using_decl_conflict_reverse);
1424 Diag(Shadow->getTargetDecl()->getLocation(),
1425 diag::note_using_decl_target);
1426 Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
1427 // Recover by ignoring the old declaration.
1428 PrevDecl = PrevClassTemplate = nullptr;
1429 }
1430 }
1431
Hubert Tong5a8ec4e2017-02-10 02:46:19 +00001432 // TODO Memory management; associated constraints are not always stored.
1433 Expr *const CurAC = formAssociatedConstraints(TemplateParams, nullptr);
1434
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001435 if (PrevClassTemplate) {
Richard Smithe85e1762012-04-22 02:13:50 +00001436 // Ensure that the template parameter lists are compatible. Skip this check
1437 // for a friend in a dependent context: the template parameter list itself
1438 // could be dependent.
1439 if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1440 !TemplateParameterListsAreEqual(TemplateParams,
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001441 PrevClassTemplate->getTemplateParameters(),
Douglas Gregor19ac2d62009-11-12 16:20:59 +00001442 /*Complain=*/true,
1443 TPL_TemplateMatch))
Douglas Gregorc08f4892009-03-25 00:13:59 +00001444 return true;
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001445
Hubert Tong5a8ec4e2017-02-10 02:46:19 +00001446 // Check for matching associated constraints on redeclarations.
1447 const Expr *const PrevAC = PrevClassTemplate->getAssociatedConstraints();
1448 const bool RedeclACMismatch = [&] {
1449 if (!(CurAC || PrevAC))
1450 return false; // Nothing to check; no mismatch.
1451 if (CurAC && PrevAC) {
1452 llvm::FoldingSetNodeID CurACInfo, PrevACInfo;
1453 CurAC->Profile(CurACInfo, Context, /*Canonical=*/true);
1454 PrevAC->Profile(PrevACInfo, Context, /*Canonical=*/true);
1455 if (CurACInfo == PrevACInfo)
1456 return false; // All good; no mismatch.
1457 }
1458 return true;
1459 }();
1460
1461 if (RedeclACMismatch) {
1462 Diag(CurAC ? CurAC->getLocStart() : NameLoc,
1463 diag::err_template_different_associated_constraints);
1464 Diag(PrevAC ? PrevAC->getLocStart() : PrevClassTemplate->getLocation(),
1465 diag::note_template_prev_declaration) << /*declaration*/0;
1466 return true;
1467 }
1468
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001469 // C++ [temp.class]p4:
1470 // In a redeclaration, partial specialization, explicit
1471 // specialization or explicit instantiation of a class template,
1472 // the class-key shall agree in kind with the original class
1473 // template declaration (7.1.5.3).
1474 RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl();
Richard Trieucaa33d32011-06-10 03:11:26 +00001475 if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind,
Justin Bognerc6ecb7c2015-07-10 23:05:47 +00001476 TUK == TUK_Definition, KWLoc, Name)) {
Mike Stump11289f42009-09-09 15:08:12 +00001477 Diag(KWLoc, diag::err_use_with_wrong_tag)
Douglas Gregor170512f2009-04-01 23:51:29 +00001478 << Name
Douglas Gregora771f462010-03-31 17:46:05 +00001479 << FixItHint::CreateReplacement(KWLoc, PrevRecordDecl->getKindName());
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001480 Diag(PrevRecordDecl->getLocation(), diag::note_previous_use);
Douglas Gregor170512f2009-04-01 23:51:29 +00001481 Kind = PrevRecordDecl->getTagKind();
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001482 }
1483
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001484 // Check for redefinition of this class template.
John McCall9bb74a52009-07-31 02:45:11 +00001485 if (TUK == TUK_Definition) {
Douglas Gregor0a5a2212010-02-11 01:04:33 +00001486 if (TagDecl *Def = PrevRecordDecl->getDefinition()) {
Richard Smithbe3980b2015-03-27 00:41:57 +00001487 // If we have a prior definition that is not visible, treat this as
1488 // simply making that previous definition visible.
1489 NamedDecl *Hidden = nullptr;
1490 if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
Richard Smithd9ba2242015-05-07 03:54:19 +00001491 SkipBody->ShouldSkip = true;
Richard Smithbe3980b2015-03-27 00:41:57 +00001492 auto *Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();
1493 assert(Tmpl && "original definition of a class template is not a "
1494 "class template?");
Richard Smith858e0e02017-05-11 23:11:16 +00001495 makeMergedDefinitionVisible(Hidden);
1496 makeMergedDefinitionVisible(Tmpl);
Richard Smithbe3980b2015-03-27 00:41:57 +00001497 return Def;
1498 }
1499
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001500 Diag(NameLoc, diag::err_redefinition) << Name;
1501 Diag(Def->getLocation(), diag::note_previous_definition);
1502 // FIXME: Would it make sense to try to "forget" the previous
1503 // definition, as part of error recovery?
Douglas Gregorc08f4892009-03-25 00:13:59 +00001504 return true;
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001505 }
Serge Pavlove50bf752016-06-10 04:39:07 +00001506 }
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001507 } else if (PrevDecl) {
1508 // C++ [temp]p5:
1509 // A class template shall not have the same name as any other
1510 // template, class, function, object, enumeration, enumerator,
1511 // namespace, or type in the same scope (3.3), except as specified
1512 // in (14.5.4).
1513 Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
1514 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Douglas Gregorc08f4892009-03-25 00:13:59 +00001515 return true;
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001516 }
1517
Douglas Gregordba32632009-02-10 19:49:53 +00001518 // Check the template parameter list of this declaration, possibly
1519 // merging in the template parameter list from the previous class
Richard Smithe85e1762012-04-22 02:13:50 +00001520 // template declaration. Skip this check for a friend in a dependent
1521 // context, because the template parameter list might be dependent.
1522 if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
David Majnemerba8f17a2013-06-25 22:08:55 +00001523 CheckTemplateParameterList(
1524 TemplateParams,
Craig Topperc3ec1492014-05-26 06:22:03 +00001525 PrevClassTemplate ? PrevClassTemplate->getTemplateParameters()
1526 : nullptr,
David Majnemerba8f17a2013-06-25 22:08:55 +00001527 (SS.isSet() && SemanticContext && SemanticContext->isRecord() &&
1528 SemanticContext->isDependentContext())
1529 ? TPC_ClassTemplateMember
1530 : TUK == TUK_Friend ? TPC_FriendClassTemplate
1531 : TPC_ClassTemplate))
Douglas Gregordba32632009-02-10 19:49:53 +00001532 Invalid = true;
Mike Stump11289f42009-09-09 15:08:12 +00001533
Douglas Gregorce40e2e2010-04-12 16:00:01 +00001534 if (SS.isSet()) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001535 // If the name of the template was qualified, we must be defining the
Douglas Gregorce40e2e2010-04-12 16:00:01 +00001536 // template out-of-line.
Richard Smithe85e1762012-04-22 02:13:50 +00001537 if (!SS.isInvalid() && !Invalid && !PrevClassTemplate) {
1538 Diag(NameLoc, TUK == TUK_Friend ? diag::err_friend_decl_does_not_match
Richard Smith114394f2013-08-09 04:35:01 +00001539 : diag::err_member_decl_does_not_match)
1540 << Name << SemanticContext << /*IsDefinition*/true << SS.getRange();
Douglas Gregorfe0055e2011-11-01 21:35:16 +00001541 Invalid = true;
1542 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001543 }
1544
Vassil Vassilev352e4412017-01-12 09:16:26 +00001545 // If this is a templated friend in a dependent context we should not put it
1546 // on the redecl chain. In some cases, the templated friend can be the most
1547 // recent declaration tricking the template instantiator to make substitutions
1548 // there.
1549 // FIXME: Figure out how to combine with shouldLinkDependentDeclWithPrevious
1550 bool ShouldAddRedecl
1551 = !(TUK == TUK_Friend && CurContext->isDependentContext());
1552
Mike Stump11289f42009-09-09 15:08:12 +00001553 CXXRecordDecl *NewClass =
Abramo Bagnara29c2d462011-03-09 14:09:51 +00001554 CXXRecordDecl::Create(Context, Kind, SemanticContext, KWLoc, NameLoc, Name,
Vassil Vassilev352e4412017-01-12 09:16:26 +00001555 PrevClassTemplate && ShouldAddRedecl ?
Craig Topperc3ec1492014-05-26 06:22:03 +00001556 PrevClassTemplate->getTemplatedDecl() : nullptr,
Douglas Gregor1ec5e9f2009-05-15 19:11:46 +00001557 /*DelayTypeCreation=*/true);
John McCall3e11ebe2010-03-15 10:12:16 +00001558 SetNestedNameSpecifier(NewClass, SS);
Abramo Bagnara0adf29a2011-03-10 13:28:31 +00001559 if (NumOuterTemplateParamLists > 0)
Benjamin Kramer9cc210652015-08-05 09:40:49 +00001560 NewClass->setTemplateParameterListsInfo(
1561 Context, llvm::makeArrayRef(OuterTemplateParamLists,
1562 NumOuterTemplateParamLists));
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001563
Eli Friedmanedb6f5d2012-02-10 02:02:21 +00001564 // Add alignment attributes if necessary; these attributes are checked when
1565 // the ASTContext lays out the structure.
Eli Friedman0415f3e12012-08-08 21:08:34 +00001566 if (TUK == TUK_Definition) {
1567 AddAlignmentAttributesForRecord(NewClass);
1568 AddMsStructLayoutForRecord(NewClass);
1569 }
Eli Friedmanedb6f5d2012-02-10 02:02:21 +00001570
Hubert Tong5a8ec4e2017-02-10 02:46:19 +00001571 // Attach the associated constraints when the declaration will not be part of
1572 // a decl chain.
1573 Expr *const ACtoAttach =
1574 PrevClassTemplate && ShouldAddRedecl ? nullptr : CurAC;
1575
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001576 ClassTemplateDecl *NewTemplate
1577 = ClassTemplateDecl::Create(Context, SemanticContext, NameLoc,
1578 DeclarationName(Name), TemplateParams,
Hubert Tong5a8ec4e2017-02-10 02:46:19 +00001579 NewClass, ACtoAttach);
Vassil Vassilev352e4412017-01-12 09:16:26 +00001580
1581 if (ShouldAddRedecl)
1582 NewTemplate->setPreviousDecl(PrevClassTemplate);
1583
Douglas Gregor97f1f1c2009-03-26 00:10:35 +00001584 NewClass->setDescribedClassTemplate(NewTemplate);
Simon Pilgrim6905d222016-12-30 22:55:33 +00001585
Douglas Gregor21823bf2011-12-20 18:11:52 +00001586 if (ModulePrivateLoc.isValid())
Douglas Gregoref15bdb2011-09-09 18:32:39 +00001587 NewTemplate->setModulePrivate();
Simon Pilgrim6905d222016-12-30 22:55:33 +00001588
Douglas Gregor1ec5e9f2009-05-15 19:11:46 +00001589 // Build the type for the class template declaration now.
Douglas Gregor9961ce92010-07-08 18:37:38 +00001590 QualType T = NewTemplate->getInjectedClassNameSpecialization();
John McCalle78aac42010-03-10 03:28:59 +00001591 T = Context.getInjectedClassNameType(NewClass, T);
Douglas Gregor1ec5e9f2009-05-15 19:11:46 +00001592 assert(T->isDependentType() && "Class template type is not dependent?");
1593 (void)T;
1594
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001595 // If we are providing an explicit specialization of a member that is a
Douglas Gregorcf915552009-10-13 16:30:37 +00001596 // class template, make a note of that.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001597 if (PrevClassTemplate &&
Douglas Gregorcf915552009-10-13 16:30:37 +00001598 PrevClassTemplate->getInstantiatedFromMemberTemplate())
1599 PrevClassTemplate->setMemberSpecialization();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001600
Anders Carlsson137108d2009-03-26 01:24:28 +00001601 // Set the access specifier.
Douglas Gregor31feb332012-03-17 23:06:31 +00001602 if (!Invalid && TUK != TUK_Friend && NewTemplate->getDeclContext()->isRecord())
John McCall27b5c252009-09-14 21:59:20 +00001603 SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS);
Mike Stump11289f42009-09-09 15:08:12 +00001604
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001605 // Set the lexical context of these templates
1606 NewClass->setLexicalDeclContext(CurContext);
1607 NewTemplate->setLexicalDeclContext(CurContext);
1608
John McCall9bb74a52009-07-31 02:45:11 +00001609 if (TUK == TUK_Definition)
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001610 NewClass->startDefinition();
1611
Erich Keanec480f302018-07-12 21:09:05 +00001612 ProcessDeclAttributeList(S, NewClass, Attr);
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001613
Rafael Espindola0c6c4052012-08-22 14:52:14 +00001614 if (PrevClassTemplate)
1615 mergeDeclAttributes(NewClass, PrevClassTemplate->getTemplatedDecl());
1616
Rafael Espindola385c0422012-07-13 18:04:45 +00001617 AddPushedVisibilityAttribute(NewClass);
1618
Richard Smith234ff472014-08-23 00:49:01 +00001619 if (TUK != TUK_Friend) {
1620 // Per C++ [basic.scope.temp]p2, skip the template parameter scopes.
1621 Scope *Outer = S;
1622 while ((Outer->getFlags() & Scope::TemplateParamScope) != 0)
1623 Outer = Outer->getParent();
1624 PushOnScopeChains(NewTemplate, Outer);
1625 } else {
Douglas Gregor3dad8422009-09-26 06:47:28 +00001626 if (PrevClassTemplate && PrevClassTemplate->getAccess() != AS_none) {
John McCall27b5c252009-09-14 21:59:20 +00001627 NewTemplate->setAccess(PrevClassTemplate->getAccess());
Douglas Gregor3dad8422009-09-26 06:47:28 +00001628 NewClass->setAccess(PrevClassTemplate->getAccess());
1629 }
John McCall27b5c252009-09-14 21:59:20 +00001630
Richard Smith64017682013-07-17 23:53:16 +00001631 NewTemplate->setObjectOfFriendDecl();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001632
John McCall27b5c252009-09-14 21:59:20 +00001633 // Friend templates are visible in fairly strange ways.
1634 if (!CurContext->isDependentContext()) {
Sebastian Redl50c68252010-08-31 00:36:30 +00001635 DeclContext *DC = SemanticContext->getRedeclContext();
Richard Smith05afe5e2012-03-13 03:12:56 +00001636 DC->makeDeclVisibleInContext(NewTemplate);
John McCall27b5c252009-09-14 21:59:20 +00001637 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
1638 PushOnScopeChains(NewTemplate, EnclosingScope,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001639 /* AddToContext = */ false);
John McCall27b5c252009-09-14 21:59:20 +00001640 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00001641
Nikola Smiljanic4fc91532014-07-17 01:59:34 +00001642 FriendDecl *Friend = FriendDecl::Create(
1643 Context, CurContext, NewClass->getLocation(), NewTemplate, FriendLoc);
Douglas Gregor3dad8422009-09-26 06:47:28 +00001644 Friend->setAccess(AS_public);
1645 CurContext->addDecl(Friend);
John McCall27b5c252009-09-14 21:59:20 +00001646 }
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001647
Richard Smithbecb92d2017-10-10 22:33:17 +00001648 if (PrevClassTemplate)
1649 CheckRedeclarationModuleOwnership(NewTemplate, PrevClassTemplate);
1650
Douglas Gregordba32632009-02-10 19:49:53 +00001651 if (Invalid) {
1652 NewTemplate->setInvalidDecl();
1653 NewClass->setInvalidDecl();
1654 }
Rafael Espindolaeca5cd22012-07-13 01:19:08 +00001655
Dmitri Gribenko34df2202012-07-31 22:37:06 +00001656 ActOnDocumentableDecl(NewTemplate);
1657
John McCall48871652010-08-21 09:40:31 +00001658 return NewTemplate;
Douglas Gregorcd72ba92009-02-06 22:42:48 +00001659}
1660
Richard Smith32918772017-02-14 00:25:28 +00001661namespace {
1662/// Transform to convert portions of a constructor declaration into the
1663/// corresponding deduction guide, per C++1z [over.match.class.deduct]p1.
1664struct ConvertConstructorToDeductionGuideTransform {
1665 ConvertConstructorToDeductionGuideTransform(Sema &S,
1666 ClassTemplateDecl *Template)
1667 : SemaRef(S), Template(Template) {}
1668
1669 Sema &SemaRef;
1670 ClassTemplateDecl *Template;
1671
1672 DeclContext *DC = Template->getDeclContext();
1673 CXXRecordDecl *Primary = Template->getTemplatedDecl();
1674 DeclarationName DeductionGuideName =
1675 SemaRef.Context.DeclarationNames.getCXXDeductionGuideName(Template);
1676
1677 QualType DeducedType = SemaRef.Context.getTypeDeclType(Primary);
1678
1679 // Index adjustment to apply to convert depth-1 template parameters into
1680 // depth-0 template parameters.
1681 unsigned Depth1IndexAdjustment = Template->getTemplateParameters()->size();
1682
1683 /// Transform a constructor declaration into a deduction guide.
Richard Smithbc491202017-02-17 20:05:37 +00001684 NamedDecl *transformConstructor(FunctionTemplateDecl *FTD,
1685 CXXConstructorDecl *CD) {
Richard Smith32918772017-02-14 00:25:28 +00001686 SmallVector<TemplateArgument, 16> SubstArgs;
1687
Richard Smithb4f96252017-02-21 06:30:38 +00001688 LocalInstantiationScope Scope(SemaRef);
1689
Richard Smith32918772017-02-14 00:25:28 +00001690 // C++ [over.match.class.deduct]p1:
1691 // -- For each constructor of the class template designated by the
1692 // template-name, a function template with the following properties:
1693
1694 // -- The template parameters are the template parameters of the class
1695 // template followed by the template parameters (including default
1696 // template arguments) of the constructor, if any.
1697 TemplateParameterList *TemplateParams = Template->getTemplateParameters();
1698 if (FTD) {
1699 TemplateParameterList *InnerParams = FTD->getTemplateParameters();
1700 SmallVector<NamedDecl *, 16> AllParams;
1701 AllParams.reserve(TemplateParams->size() + InnerParams->size());
1702 AllParams.insert(AllParams.begin(),
1703 TemplateParams->begin(), TemplateParams->end());
1704 SubstArgs.reserve(InnerParams->size());
1705
1706 // Later template parameters could refer to earlier ones, so build up
1707 // a list of substituted template arguments as we go.
1708 for (NamedDecl *Param : *InnerParams) {
1709 MultiLevelTemplateArgumentList Args;
1710 Args.addOuterTemplateArguments(SubstArgs);
Richard Smithb4f96252017-02-21 06:30:38 +00001711 Args.addOuterRetainedLevel();
Richard Smith32918772017-02-14 00:25:28 +00001712 NamedDecl *NewParam = transformTemplateParameter(Param, Args);
1713 if (!NewParam)
1714 return nullptr;
1715 AllParams.push_back(NewParam);
1716 SubstArgs.push_back(SemaRef.Context.getCanonicalTemplateArgument(
1717 SemaRef.Context.getInjectedTemplateArg(NewParam)));
1718 }
1719 TemplateParams = TemplateParameterList::Create(
1720 SemaRef.Context, InnerParams->getTemplateLoc(),
1721 InnerParams->getLAngleLoc(), AllParams, InnerParams->getRAngleLoc(),
1722 /*FIXME: RequiresClause*/ nullptr);
1723 }
1724
1725 // If we built a new template-parameter-list, track that we need to
1726 // substitute references to the old parameters into references to the
1727 // new ones.
1728 MultiLevelTemplateArgumentList Args;
1729 if (FTD) {
1730 Args.addOuterTemplateArguments(SubstArgs);
Richard Smithb4f96252017-02-21 06:30:38 +00001731 Args.addOuterRetainedLevel();
Richard Smith32918772017-02-14 00:25:28 +00001732 }
1733
Richard Smithbc491202017-02-17 20:05:37 +00001734 FunctionProtoTypeLoc FPTL = CD->getTypeSourceInfo()->getTypeLoc()
Richard Smith32918772017-02-14 00:25:28 +00001735 .getAsAdjusted<FunctionProtoTypeLoc>();
1736 assert(FPTL && "no prototype for constructor declaration");
1737
1738 // Transform the type of the function, adjusting the return type and
1739 // replacing references to the old parameters with references to the
1740 // new ones.
1741 TypeLocBuilder TLB;
1742 SmallVector<ParmVarDecl*, 8> Params;
1743 QualType NewType = transformFunctionProtoType(TLB, FPTL, Params, Args);
1744 if (NewType.isNull())
1745 return nullptr;
1746 TypeSourceInfo *NewTInfo = TLB.getTypeSourceInfo(SemaRef.Context, NewType);
1747
Richard Smithbc491202017-02-17 20:05:37 +00001748 return buildDeductionGuide(TemplateParams, CD->isExplicit(), NewTInfo,
1749 CD->getLocStart(), CD->getLocation(),
1750 CD->getLocEnd());
Richard Smith32918772017-02-14 00:25:28 +00001751 }
1752
1753 /// Build a deduction guide with the specified parameter types.
1754 NamedDecl *buildSimpleDeductionGuide(MutableArrayRef<QualType> ParamTypes) {
1755 SourceLocation Loc = Template->getLocation();
1756
1757 // Build the requested type.
1758 FunctionProtoType::ExtProtoInfo EPI;
1759 EPI.HasTrailingReturn = true;
1760 QualType Result = SemaRef.BuildFunctionType(DeducedType, ParamTypes, Loc,
1761 DeductionGuideName, EPI);
1762 TypeSourceInfo *TSI = SemaRef.Context.getTrivialTypeSourceInfo(Result, Loc);
1763
1764 FunctionProtoTypeLoc FPTL =
1765 TSI->getTypeLoc().castAs<FunctionProtoTypeLoc>();
1766
1767 // Build the parameters, needed during deduction / substitution.
1768 SmallVector<ParmVarDecl*, 4> Params;
1769 for (auto T : ParamTypes) {
1770 ParmVarDecl *NewParam = ParmVarDecl::Create(
1771 SemaRef.Context, DC, Loc, Loc, nullptr, T,
1772 SemaRef.Context.getTrivialTypeSourceInfo(T, Loc), SC_None, nullptr);
1773 NewParam->setScopeInfo(0, Params.size());
1774 FPTL.setParam(Params.size(), NewParam);
1775 Params.push_back(NewParam);
1776 }
1777
1778 return buildDeductionGuide(Template->getTemplateParameters(), false, TSI,
1779 Loc, Loc, Loc);
1780 }
1781
1782private:
1783 /// Transform a constructor template parameter into a deduction guide template
1784 /// parameter, rebuilding any internal references to earlier parameters and
1785 /// renumbering as we go.
1786 NamedDecl *transformTemplateParameter(NamedDecl *TemplateParam,
1787 MultiLevelTemplateArgumentList &Args) {
1788 if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(TemplateParam)) {
1789 // TemplateTypeParmDecl's index cannot be changed after creation, so
1790 // substitute it directly.
1791 auto *NewTTP = TemplateTypeParmDecl::Create(
1792 SemaRef.Context, DC, TTP->getLocStart(), TTP->getLocation(),
1793 /*Depth*/0, Depth1IndexAdjustment + TTP->getIndex(),
1794 TTP->getIdentifier(), TTP->wasDeclaredWithTypename(),
1795 TTP->isParameterPack());
1796 if (TTP->hasDefaultArgument()) {
1797 TypeSourceInfo *InstantiatedDefaultArg =
1798 SemaRef.SubstType(TTP->getDefaultArgumentInfo(), Args,
1799 TTP->getDefaultArgumentLoc(), TTP->getDeclName());
1800 if (InstantiatedDefaultArg)
1801 NewTTP->setDefaultArgument(InstantiatedDefaultArg);
1802 }
Richard Smithb4f96252017-02-21 06:30:38 +00001803 SemaRef.CurrentInstantiationScope->InstantiatedLocal(TemplateParam,
1804 NewTTP);
Richard Smith32918772017-02-14 00:25:28 +00001805 return NewTTP;
1806 }
1807
1808 if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TemplateParam))
1809 return transformTemplateParameterImpl(TTP, Args);
1810
1811 return transformTemplateParameterImpl(
1812 cast<NonTypeTemplateParmDecl>(TemplateParam), Args);
1813 }
1814 template<typename TemplateParmDecl>
1815 TemplateParmDecl *
1816 transformTemplateParameterImpl(TemplateParmDecl *OldParam,
1817 MultiLevelTemplateArgumentList &Args) {
1818 // Ask the template instantiator to do the heavy lifting for us, then adjust
1819 // the index of the parameter once it's done.
1820 auto *NewParam =
1821 cast_or_null<TemplateParmDecl>(SemaRef.SubstDecl(OldParam, DC, Args));
1822 assert(NewParam->getDepth() == 0 && "unexpected template param depth");
1823 NewParam->setPosition(NewParam->getPosition() + Depth1IndexAdjustment);
1824 return NewParam;
1825 }
1826
1827 QualType transformFunctionProtoType(TypeLocBuilder &TLB,
1828 FunctionProtoTypeLoc TL,
1829 SmallVectorImpl<ParmVarDecl*> &Params,
1830 MultiLevelTemplateArgumentList &Args) {
1831 SmallVector<QualType, 4> ParamTypes;
1832 const FunctionProtoType *T = TL.getTypePtr();
1833
1834 // -- The types of the function parameters are those of the constructor.
1835 for (auto *OldParam : TL.getParams()) {
Richard Smithc27b3d72017-02-14 01:49:59 +00001836 ParmVarDecl *NewParam = transformFunctionTypeParam(OldParam, Args);
Richard Smith32918772017-02-14 00:25:28 +00001837 if (!NewParam)
1838 return QualType();
1839 ParamTypes.push_back(NewParam->getType());
1840 Params.push_back(NewParam);
1841 }
1842
1843 // -- The return type is the class template specialization designated by
1844 // the template-name and template arguments corresponding to the
1845 // template parameters obtained from the class template.
1846 //
1847 // We use the injected-class-name type of the primary template instead.
1848 // This has the convenient property that it is different from any type that
1849 // the user can write in a deduction-guide (because they cannot enter the
1850 // context of the template), so implicit deduction guides can never collide
1851 // with explicit ones.
1852 QualType ReturnType = DeducedType;
1853 TLB.pushTypeSpec(ReturnType).setNameLoc(Primary->getLocation());
1854
1855 // Resolving a wording defect, we also inherit the variadicness of the
1856 // constructor.
1857 FunctionProtoType::ExtProtoInfo EPI;
1858 EPI.Variadic = T->isVariadic();
1859 EPI.HasTrailingReturn = true;
1860
1861 QualType Result = SemaRef.BuildFunctionType(
1862 ReturnType, ParamTypes, TL.getLocStart(), DeductionGuideName, EPI);
1863 if (Result.isNull())
1864 return QualType();
1865
1866 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
1867 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
1868 NewTL.setLParenLoc(TL.getLParenLoc());
1869 NewTL.setRParenLoc(TL.getRParenLoc());
1870 NewTL.setExceptionSpecRange(SourceRange());
1871 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
1872 for (unsigned I = 0, E = NewTL.getNumParams(); I != E; ++I)
1873 NewTL.setParam(I, Params[I]);
1874
1875 return Result;
1876 }
1877
1878 ParmVarDecl *
1879 transformFunctionTypeParam(ParmVarDecl *OldParam,
1880 MultiLevelTemplateArgumentList &Args) {
1881 TypeSourceInfo *OldDI = OldParam->getTypeSourceInfo();
Richard Smith479ba8e2017-04-20 01:15:31 +00001882 TypeSourceInfo *NewDI;
1883 if (!Args.getNumLevels())
1884 NewDI = OldDI;
1885 else if (auto PackTL = OldDI->getTypeLoc().getAs<PackExpansionTypeLoc>()) {
1886 // Expand out the one and only element in each inner pack.
1887 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, 0);
1888 NewDI =
1889 SemaRef.SubstType(PackTL.getPatternLoc(), Args,
1890 OldParam->getLocation(), OldParam->getDeclName());
1891 if (!NewDI) return nullptr;
1892 NewDI =
1893 SemaRef.CheckPackExpansion(NewDI, PackTL.getEllipsisLoc(),
1894 PackTL.getTypePtr()->getNumExpansions());
1895 } else
1896 NewDI = SemaRef.SubstType(OldDI, Args, OldParam->getLocation(),
1897 OldParam->getDeclName());
Richard Smith32918772017-02-14 00:25:28 +00001898 if (!NewDI)
1899 return nullptr;
1900
Richard Smithc27b3d72017-02-14 01:49:59 +00001901 // Canonicalize the type. This (for instance) replaces references to
1902 // typedef members of the current instantiations with the definitions of
1903 // those typedefs, avoiding triggering instantiation of the deduced type
1904 // during deduction.
1905 // FIXME: It would be preferable to retain type sugar and source
1906 // information here (and handle this in substitution instead).
1907 NewDI = SemaRef.Context.getTrivialTypeSourceInfo(
1908 SemaRef.Context.getCanonicalType(NewDI->getType()),
1909 OldParam->getLocation());
1910
Richard Smith32918772017-02-14 00:25:28 +00001911 // Resolving a wording defect, we also inherit default arguments from the
1912 // constructor.
1913 ExprResult NewDefArg;
1914 if (OldParam->hasDefaultArg()) {
Richard Smithc27b3d72017-02-14 01:49:59 +00001915 NewDefArg = Args.getNumLevels()
1916 ? SemaRef.SubstExpr(OldParam->getDefaultArg(), Args)
1917 : OldParam->getDefaultArg();
Richard Smith32918772017-02-14 00:25:28 +00001918 if (NewDefArg.isInvalid())
1919 return nullptr;
1920 }
1921
1922 ParmVarDecl *NewParam = ParmVarDecl::Create(SemaRef.Context, DC,
1923 OldParam->getInnerLocStart(),
1924 OldParam->getLocation(),
1925 OldParam->getIdentifier(),
1926 NewDI->getType(),
1927 NewDI,
1928 OldParam->getStorageClass(),
1929 NewDefArg.get());
1930 NewParam->setScopeInfo(OldParam->getFunctionScopeDepth(),
1931 OldParam->getFunctionScopeIndex());
1932 return NewParam;
1933 }
1934
1935 NamedDecl *buildDeductionGuide(TemplateParameterList *TemplateParams,
1936 bool Explicit, TypeSourceInfo *TInfo,
1937 SourceLocation LocStart, SourceLocation Loc,
1938 SourceLocation LocEnd) {
Richard Smithbc491202017-02-17 20:05:37 +00001939 DeclarationNameInfo Name(DeductionGuideName, Loc);
Richard Smithefa919a2017-02-16 21:29:21 +00001940 ArrayRef<ParmVarDecl *> Params =
1941 TInfo->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams();
1942
Richard Smith32918772017-02-14 00:25:28 +00001943 // Build the implicit deduction guide template.
Richard Smithbc491202017-02-17 20:05:37 +00001944 auto *Guide =
1945 CXXDeductionGuideDecl::Create(SemaRef.Context, DC, LocStart, Explicit,
1946 Name, TInfo->getType(), TInfo, LocEnd);
Richard Smith32918772017-02-14 00:25:28 +00001947 Guide->setImplicit();
Richard Smithefa919a2017-02-16 21:29:21 +00001948 Guide->setParams(Params);
1949
1950 for (auto *Param : Params)
1951 Param->setDeclContext(Guide);
Richard Smith32918772017-02-14 00:25:28 +00001952
1953 auto *GuideTemplate = FunctionTemplateDecl::Create(
1954 SemaRef.Context, DC, Loc, DeductionGuideName, TemplateParams, Guide);
1955 GuideTemplate->setImplicit();
1956 Guide->setDescribedFunctionTemplate(GuideTemplate);
1957
1958 if (isa<CXXRecordDecl>(DC)) {
1959 Guide->setAccess(AS_public);
1960 GuideTemplate->setAccess(AS_public);
1961 }
1962
1963 DC->addDecl(GuideTemplate);
1964 return GuideTemplate;
1965 }
1966};
1967}
1968
1969void Sema::DeclareImplicitDeductionGuides(TemplateDecl *Template,
1970 SourceLocation Loc) {
1971 DeclContext *DC = Template->getDeclContext();
1972 if (DC->isDependentContext())
1973 return;
1974
1975 ConvertConstructorToDeductionGuideTransform Transform(
1976 *this, cast<ClassTemplateDecl>(Template));
1977 if (!isCompleteType(Loc, Transform.DeducedType))
1978 return;
1979
1980 // Check whether we've already declared deduction guides for this template.
1981 // FIXME: Consider storing a flag on the template to indicate this.
1982 auto Existing = DC->lookup(Transform.DeductionGuideName);
1983 for (auto *D : Existing)
1984 if (D->isImplicit())
1985 return;
1986
1987 // In case we were expanding a pack when we attempted to declare deduction
1988 // guides, turn off pack expansion for everything we're about to do.
1989 ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
1990 // Create a template instantiation record to track the "instantiation" of
1991 // constructors into deduction guides.
1992 // FIXME: Add a kind for this to give more meaningful diagnostics. But can
1993 // this substitution process actually fail?
1994 InstantiatingTemplate BuildingDeductionGuides(*this, Loc, Template);
Volodymyr Sapsai2f649f32018-05-14 22:49:44 +00001995 if (BuildingDeductionGuides.isInvalid())
1996 return;
Richard Smith32918772017-02-14 00:25:28 +00001997
1998 // Convert declared constructors into deduction guide templates.
1999 // FIXME: Skip constructors for which deduction must necessarily fail (those
2000 // for which some class template parameter without a default argument never
2001 // appears in a deduced context).
2002 bool AddedAny = false;
Richard Smith32918772017-02-14 00:25:28 +00002003 for (NamedDecl *D : LookupConstructors(Transform.Primary)) {
2004 D = D->getUnderlyingDecl();
2005 if (D->isInvalidDecl() || D->isImplicit())
2006 continue;
2007 D = cast<NamedDecl>(D->getCanonicalDecl());
2008
2009 auto *FTD = dyn_cast<FunctionTemplateDecl>(D);
Richard Smithbc491202017-02-17 20:05:37 +00002010 auto *CD =
2011 dyn_cast_or_null<CXXConstructorDecl>(FTD ? FTD->getTemplatedDecl() : D);
Richard Smith32918772017-02-14 00:25:28 +00002012 // Class-scope explicit specializations (MS extension) do not result in
2013 // deduction guides.
Richard Smithbc491202017-02-17 20:05:37 +00002014 if (!CD || (!FTD && CD->isFunctionTemplateSpecialization()))
Richard Smith32918772017-02-14 00:25:28 +00002015 continue;
2016
Richard Smithbc491202017-02-17 20:05:37 +00002017 Transform.transformConstructor(FTD, CD);
Richard Smith32918772017-02-14 00:25:28 +00002018 AddedAny = true;
Richard Smith32918772017-02-14 00:25:28 +00002019 }
2020
Faisal Vali81b756e2017-10-22 14:45:08 +00002021 // C++17 [over.match.class.deduct]
2022 // -- If C is not defined or does not declare any constructors, an
2023 // additional function template derived as above from a hypothetical
2024 // constructor C().
Richard Smith32918772017-02-14 00:25:28 +00002025 if (!AddedAny)
2026 Transform.buildSimpleDeductionGuide(None);
2027
Faisal Vali81b756e2017-10-22 14:45:08 +00002028 // -- An additional function template derived as above from a hypothetical
2029 // constructor C(C), called the copy deduction candidate.
2030 cast<CXXDeductionGuideDecl>(
2031 cast<FunctionTemplateDecl>(
2032 Transform.buildSimpleDeductionGuide(Transform.DeducedType))
2033 ->getTemplatedDecl())
2034 ->setIsCopyDeductionCandidate();
Richard Smith32918772017-02-14 00:25:28 +00002035}
2036
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00002037/// Diagnose the presence of a default template argument on a
Douglas Gregored5731f2009-11-25 17:50:39 +00002038/// template parameter, which is ill-formed in certain contexts.
2039///
2040/// \returns true if the default template argument should be dropped.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002041static bool DiagnoseDefaultTemplateArgument(Sema &S,
Douglas Gregored5731f2009-11-25 17:50:39 +00002042 Sema::TemplateParamListContext TPC,
2043 SourceLocation ParamLoc,
2044 SourceRange DefArgRange) {
2045 switch (TPC) {
2046 case Sema::TPC_ClassTemplate:
Larisse Voufo39a1e502013-08-06 01:03:05 +00002047 case Sema::TPC_VarTemplate:
Richard Smith3f1b5d02011-05-05 21:57:07 +00002048 case Sema::TPC_TypeAliasTemplate:
Douglas Gregored5731f2009-11-25 17:50:39 +00002049 return false;
2050
2051 case Sema::TPC_FunctionTemplate:
Douglas Gregora99fb4c2011-02-04 04:20:44 +00002052 case Sema::TPC_FriendFunctionTemplateDefinition:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002053 // C++ [temp.param]p9:
Douglas Gregored5731f2009-11-25 17:50:39 +00002054 // A default template-argument shall not be specified in a
2055 // function template declaration or a function template
2056 // definition [...]
Simon Pilgrim6905d222016-12-30 22:55:33 +00002057 // If a friend function template declaration specifies a default
Douglas Gregora99fb4c2011-02-04 04:20:44 +00002058 // template-argument, that declaration shall be a definition and shall be
2059 // the only declaration of the function template in the translation unit.
2060 // (C++98/03 doesn't have this wording; see DR226).
Richard Smith2bf7fdb2013-01-02 11:42:31 +00002061 S.Diag(ParamLoc, S.getLangOpts().CPlusPlus11 ?
Richard Smith0bf8a4922011-10-18 20:49:44 +00002062 diag::warn_cxx98_compat_template_parameter_default_in_function_template
2063 : diag::ext_template_parameter_default_in_function_template)
2064 << DefArgRange;
Douglas Gregored5731f2009-11-25 17:50:39 +00002065 return false;
2066
2067 case Sema::TPC_ClassTemplateMember:
2068 // C++0x [temp.param]p9:
2069 // A default template-argument shall not be specified in the
2070 // template-parameter-lists of the definition of a member of a
2071 // class template that appears outside of the member's class.
2072 S.Diag(ParamLoc, diag::err_template_parameter_default_template_member)
2073 << DefArgRange;
2074 return true;
2075
David Majnemerba8f17a2013-06-25 22:08:55 +00002076 case Sema::TPC_FriendClassTemplate:
Douglas Gregored5731f2009-11-25 17:50:39 +00002077 case Sema::TPC_FriendFunctionTemplate:
2078 // C++ [temp.param]p9:
2079 // A default template-argument shall not be specified in a
2080 // friend template declaration.
2081 S.Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
2082 << DefArgRange;
2083 return true;
2084
2085 // FIXME: C++0x [temp.param]p9 allows default template-arguments
2086 // for friend function templates if there is only a single
2087 // declaration (and it is a definition). Strange!
2088 }
2089
David Blaikie8a40f702012-01-17 06:56:22 +00002090 llvm_unreachable("Invalid TemplateParamListContext!");
Douglas Gregored5731f2009-11-25 17:50:39 +00002091}
2092
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00002093/// Check for unexpanded parameter packs within the template parameters
Douglas Gregor38ee75e2010-12-16 15:36:43 +00002094/// of a template template parameter, recursively.
Benjamin Kramer8aef5962011-03-26 12:38:21 +00002095static bool DiagnoseUnexpandedParameterPacks(Sema &S,
2096 TemplateTemplateParmDecl *TTP) {
Richard Smith1fde8ec2012-09-07 02:06:42 +00002097 // A template template parameter which is a parameter pack is also a pack
2098 // expansion.
2099 if (TTP->isParameterPack())
2100 return false;
2101
Douglas Gregor38ee75e2010-12-16 15:36:43 +00002102 TemplateParameterList *Params = TTP->getTemplateParameters();
2103 for (unsigned I = 0, N = Params->size(); I != N; ++I) {
2104 NamedDecl *P = Params->getParam(I);
2105 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
Richard Smith1fde8ec2012-09-07 02:06:42 +00002106 if (!NTTP->isParameterPack() &&
2107 S.DiagnoseUnexpandedParameterPack(NTTP->getLocation(),
Douglas Gregor38ee75e2010-12-16 15:36:43 +00002108 NTTP->getTypeSourceInfo(),
2109 Sema::UPPC_NonTypeTemplateParameterType))
2110 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002111
Douglas Gregor38ee75e2010-12-16 15:36:43 +00002112 continue;
2113 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002114
2115 if (TemplateTemplateParmDecl *InnerTTP
Douglas Gregor38ee75e2010-12-16 15:36:43 +00002116 = dyn_cast<TemplateTemplateParmDecl>(P))
2117 if (DiagnoseUnexpandedParameterPacks(S, InnerTTP))
2118 return true;
2119 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002120
Douglas Gregor38ee75e2010-12-16 15:36:43 +00002121 return false;
2122}
2123
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00002124/// Checks the validity of a template parameter list, possibly
Douglas Gregordba32632009-02-10 19:49:53 +00002125/// considering the template parameter list from a previous
2126/// declaration.
2127///
2128/// If an "old" template parameter list is provided, it must be
2129/// equivalent (per TemplateParameterListsAreEqual) to the "new"
2130/// template parameter list.
2131///
2132/// \param NewParams Template parameter list for a new template
2133/// declaration. This template parameter list will be updated with any
2134/// default arguments that are carried through from the previous
2135/// template parameter list.
2136///
2137/// \param OldParams If provided, template parameter list from a
2138/// previous declaration of the same template. Default template
2139/// arguments will be merged from the old template parameter list to
2140/// the new template parameter list.
2141///
Douglas Gregored5731f2009-11-25 17:50:39 +00002142/// \param TPC Describes the context in which we are checking the given
2143/// template parameter list.
2144///
Douglas Gregordba32632009-02-10 19:49:53 +00002145/// \returns true if an error occurred, false otherwise.
2146bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
Douglas Gregored5731f2009-11-25 17:50:39 +00002147 TemplateParameterList *OldParams,
2148 TemplateParamListContext TPC) {
Douglas Gregordba32632009-02-10 19:49:53 +00002149 bool Invalid = false;
Mike Stump11289f42009-09-09 15:08:12 +00002150
Douglas Gregordba32632009-02-10 19:49:53 +00002151 // C++ [temp.param]p10:
2152 // The set of default template-arguments available for use with a
2153 // template declaration or definition is obtained by merging the
2154 // default arguments from the definition (if in scope) and all
2155 // declarations in scope in the same way default function
2156 // arguments are (8.3.6).
2157 bool SawDefaultArgument = false;
2158 SourceLocation PreviousDefaultArgLoc;
Douglas Gregord32e0282009-02-09 23:23:08 +00002159
Mike Stumpc89c8e32009-02-11 23:03:27 +00002160 // Dummy initialization to avoid warnings.
Douglas Gregor5bd22da2009-02-11 20:46:19 +00002161 TemplateParameterList::iterator OldParam = NewParams->end();
Douglas Gregordba32632009-02-10 19:49:53 +00002162 if (OldParams)
2163 OldParam = OldParams->begin();
2164
Douglas Gregor0693def2011-01-27 01:40:17 +00002165 bool RemoveDefaultArguments = false;
Douglas Gregordba32632009-02-10 19:49:53 +00002166 for (TemplateParameterList::iterator NewParam = NewParams->begin(),
2167 NewParamEnd = NewParams->end();
2168 NewParam != NewParamEnd; ++NewParam) {
2169 // Variables used to diagnose redundant default arguments
2170 bool RedundantDefaultArg = false;
2171 SourceLocation OldDefaultLoc;
2172 SourceLocation NewDefaultLoc;
2173
David Blaikie651c73c2011-10-19 05:19:50 +00002174 // Variable used to diagnose missing default arguments
Douglas Gregordba32632009-02-10 19:49:53 +00002175 bool MissingDefaultArg = false;
2176
David Blaikie651c73c2011-10-19 05:19:50 +00002177 // Variable used to diagnose non-final parameter packs
2178 bool SawParameterPack = false;
Anders Carlsson327865d2009-06-12 23:20:15 +00002179
Douglas Gregordba32632009-02-10 19:49:53 +00002180 if (TemplateTypeParmDecl *NewTypeParm
2181 = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
Douglas Gregored5731f2009-11-25 17:50:39 +00002182 // Check the presence of a default argument here.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002183 if (NewTypeParm->hasDefaultArgument() &&
2184 DiagnoseDefaultTemplateArgument(*this, TPC,
2185 NewTypeParm->getLocation(),
Douglas Gregored5731f2009-11-25 17:50:39 +00002186 NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
Abramo Bagnara1108e7b2010-05-20 10:00:11 +00002187 .getSourceRange()))
Douglas Gregored5731f2009-11-25 17:50:39 +00002188 NewTypeParm->removeDefaultArgument();
2189
2190 // Merge default arguments for template type parameters.
Mike Stump11289f42009-09-09 15:08:12 +00002191 TemplateTypeParmDecl *OldTypeParm
Craig Topperc3ec1492014-05-26 06:22:03 +00002192 = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : nullptr;
Anders Carlsson327865d2009-06-12 23:20:15 +00002193 if (NewTypeParm->isParameterPack()) {
2194 assert(!NewTypeParm->hasDefaultArgument() &&
2195 "Parameter packs can't have a default argument!");
2196 SawParameterPack = true;
Richard Smithe7bd6de2015-06-10 20:30:23 +00002197 } else if (OldTypeParm && hasVisibleDefaultArgument(OldTypeParm) &&
John McCall0ad16662009-10-29 08:12:44 +00002198 NewTypeParm->hasDefaultArgument()) {
Douglas Gregordba32632009-02-10 19:49:53 +00002199 OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc();
2200 NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
2201 SawDefaultArgument = true;
2202 RedundantDefaultArg = true;
2203 PreviousDefaultArgLoc = NewDefaultLoc;
2204 } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) {
2205 // Merge the default argument from the old declaration to the
2206 // new declaration.
Richard Smith1469b912015-06-10 00:29:03 +00002207 NewTypeParm->setInheritedDefaultArgument(Context, OldTypeParm);
Douglas Gregordba32632009-02-10 19:49:53 +00002208 PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc();
2209 } else if (NewTypeParm->hasDefaultArgument()) {
2210 SawDefaultArgument = true;
2211 PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
2212 } else if (SawDefaultArgument)
2213 MissingDefaultArg = true;
Mike Stump12b8ce12009-08-04 21:02:39 +00002214 } else if (NonTypeTemplateParmDecl *NewNonTypeParm
Douglas Gregordba32632009-02-10 19:49:53 +00002215 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
Douglas Gregor38ee75e2010-12-16 15:36:43 +00002216 // Check for unexpanded parameter packs.
Richard Smith1fde8ec2012-09-07 02:06:42 +00002217 if (!NewNonTypeParm->isParameterPack() &&
2218 DiagnoseUnexpandedParameterPack(NewNonTypeParm->getLocation(),
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002219 NewNonTypeParm->getTypeSourceInfo(),
Douglas Gregor38ee75e2010-12-16 15:36:43 +00002220 UPPC_NonTypeTemplateParameterType)) {
2221 Invalid = true;
2222 continue;
2223 }
2224
Douglas Gregored5731f2009-11-25 17:50:39 +00002225 // Check the presence of a default argument here.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002226 if (NewNonTypeParm->hasDefaultArgument() &&
2227 DiagnoseDefaultTemplateArgument(*this, TPC,
2228 NewNonTypeParm->getLocation(),
Douglas Gregored5731f2009-11-25 17:50:39 +00002229 NewNonTypeParm->getDefaultArgument()->getSourceRange())) {
Abramo Bagnara656e3002010-06-09 09:26:05 +00002230 NewNonTypeParm->removeDefaultArgument();
Douglas Gregored5731f2009-11-25 17:50:39 +00002231 }
2232
Mike Stump12b8ce12009-08-04 21:02:39 +00002233 // Merge default arguments for non-type template parameters
Douglas Gregordba32632009-02-10 19:49:53 +00002234 NonTypeTemplateParmDecl *OldNonTypeParm
Craig Topperc3ec1492014-05-26 06:22:03 +00002235 = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : nullptr;
Douglas Gregor0018cdc2011-01-05 16:19:19 +00002236 if (NewNonTypeParm->isParameterPack()) {
2237 assert(!NewNonTypeParm->hasDefaultArgument() &&
2238 "Parameter packs can't have a default argument!");
Richard Smith1fde8ec2012-09-07 02:06:42 +00002239 if (!NewNonTypeParm->isPackExpansion())
2240 SawParameterPack = true;
Richard Smithe7bd6de2015-06-10 20:30:23 +00002241 } else if (OldNonTypeParm && hasVisibleDefaultArgument(OldNonTypeParm) &&
Richard Smith35828f12013-07-22 03:31:14 +00002242 NewNonTypeParm->hasDefaultArgument()) {
Douglas Gregordba32632009-02-10 19:49:53 +00002243 OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc();
2244 NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
2245 SawDefaultArgument = true;
2246 RedundantDefaultArg = true;
2247 PreviousDefaultArgLoc = NewDefaultLoc;
2248 } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) {
2249 // Merge the default argument from the old declaration to the
2250 // new declaration.
Richard Smith1469b912015-06-10 00:29:03 +00002251 NewNonTypeParm->setInheritedDefaultArgument(Context, OldNonTypeParm);
Douglas Gregordba32632009-02-10 19:49:53 +00002252 PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc();
2253 } else if (NewNonTypeParm->hasDefaultArgument()) {
2254 SawDefaultArgument = true;
2255 PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
2256 } else if (SawDefaultArgument)
Mike Stump11289f42009-09-09 15:08:12 +00002257 MissingDefaultArg = true;
Mike Stump12b8ce12009-08-04 21:02:39 +00002258 } else {
Douglas Gregordba32632009-02-10 19:49:53 +00002259 TemplateTemplateParmDecl *NewTemplateParm
2260 = cast<TemplateTemplateParmDecl>(*NewParam);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002261
Douglas Gregor38ee75e2010-12-16 15:36:43 +00002262 // Check for unexpanded parameter packs, recursively.
Douglas Gregor4a2a8f72011-10-25 03:44:56 +00002263 if (::DiagnoseUnexpandedParameterPacks(*this, NewTemplateParm)) {
Douglas Gregor38ee75e2010-12-16 15:36:43 +00002264 Invalid = true;
2265 continue;
2266 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002267
David Blaikie651c73c2011-10-19 05:19:50 +00002268 // Check the presence of a default argument here.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002269 if (NewTemplateParm->hasDefaultArgument() &&
2270 DiagnoseDefaultTemplateArgument(*this, TPC,
2271 NewTemplateParm->getLocation(),
Douglas Gregored5731f2009-11-25 17:50:39 +00002272 NewTemplateParm->getDefaultArgument().getSourceRange()))
Abramo Bagnara656e3002010-06-09 09:26:05 +00002273 NewTemplateParm->removeDefaultArgument();
Douglas Gregored5731f2009-11-25 17:50:39 +00002274
2275 // Merge default arguments for template template parameters
Douglas Gregordba32632009-02-10 19:49:53 +00002276 TemplateTemplateParmDecl *OldTemplateParm
Craig Topperc3ec1492014-05-26 06:22:03 +00002277 = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : nullptr;
Douglas Gregor0018cdc2011-01-05 16:19:19 +00002278 if (NewTemplateParm->isParameterPack()) {
2279 assert(!NewTemplateParm->hasDefaultArgument() &&
2280 "Parameter packs can't have a default argument!");
Richard Smith1fde8ec2012-09-07 02:06:42 +00002281 if (!NewTemplateParm->isPackExpansion())
2282 SawParameterPack = true;
Richard Smithe7bd6de2015-06-10 20:30:23 +00002283 } else if (OldTemplateParm &&
2284 hasVisibleDefaultArgument(OldTemplateParm) &&
2285 NewTemplateParm->hasDefaultArgument()) {
Douglas Gregor9167f8b2009-11-11 01:00:40 +00002286 OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation();
2287 NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation();
Douglas Gregordba32632009-02-10 19:49:53 +00002288 SawDefaultArgument = true;
2289 RedundantDefaultArg = true;
2290 PreviousDefaultArgLoc = NewDefaultLoc;
2291 } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) {
2292 // Merge the default argument from the old declaration to the
2293 // new declaration.
Richard Smith1469b912015-06-10 00:29:03 +00002294 NewTemplateParm->setInheritedDefaultArgument(Context, OldTemplateParm);
Douglas Gregor9167f8b2009-11-11 01:00:40 +00002295 PreviousDefaultArgLoc
2296 = OldTemplateParm->getDefaultArgument().getLocation();
Douglas Gregordba32632009-02-10 19:49:53 +00002297 } else if (NewTemplateParm->hasDefaultArgument()) {
2298 SawDefaultArgument = true;
Douglas Gregor9167f8b2009-11-11 01:00:40 +00002299 PreviousDefaultArgLoc
2300 = NewTemplateParm->getDefaultArgument().getLocation();
Douglas Gregordba32632009-02-10 19:49:53 +00002301 } else if (SawDefaultArgument)
Mike Stump11289f42009-09-09 15:08:12 +00002302 MissingDefaultArg = true;
Douglas Gregordba32632009-02-10 19:49:53 +00002303 }
2304
Richard Smith1fde8ec2012-09-07 02:06:42 +00002305 // C++11 [temp.param]p11:
David Blaikie651c73c2011-10-19 05:19:50 +00002306 // If a template parameter of a primary class template or alias template
2307 // is a template parameter pack, it shall be the last template parameter.
Richard Smith1fde8ec2012-09-07 02:06:42 +00002308 if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
Larisse Voufo39a1e502013-08-06 01:03:05 +00002309 (TPC == TPC_ClassTemplate || TPC == TPC_VarTemplate ||
2310 TPC == TPC_TypeAliasTemplate)) {
David Blaikie651c73c2011-10-19 05:19:50 +00002311 Diag((*NewParam)->getLocation(),
2312 diag::err_template_param_pack_must_be_last_template_parameter);
2313 Invalid = true;
2314 }
2315
Douglas Gregordba32632009-02-10 19:49:53 +00002316 if (RedundantDefaultArg) {
2317 // C++ [temp.param]p12:
2318 // A template-parameter shall not be given default arguments
2319 // by two different declarations in the same scope.
2320 Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
2321 Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
2322 Invalid = true;
Douglas Gregor8b481d82011-02-04 03:57:22 +00002323 } else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) {
Douglas Gregordba32632009-02-10 19:49:53 +00002324 // C++ [temp.param]p11:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002325 // If a template-parameter of a class template has a default
2326 // template-argument, each subsequent template-parameter shall either
Douglas Gregor7dba51f2011-01-05 16:21:17 +00002327 // have a default template-argument supplied or be a template parameter
2328 // pack.
Mike Stump11289f42009-09-09 15:08:12 +00002329 Diag((*NewParam)->getLocation(),
Douglas Gregordba32632009-02-10 19:49:53 +00002330 diag::err_template_param_default_arg_missing);
2331 Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
2332 Invalid = true;
Douglas Gregor0693def2011-01-27 01:40:17 +00002333 RemoveDefaultArguments = true;
Douglas Gregordba32632009-02-10 19:49:53 +00002334 }
2335
2336 // If we have an old template parameter list that we're merging
2337 // in, move on to the next parameter.
2338 if (OldParams)
2339 ++OldParam;
2340 }
2341
Douglas Gregor0693def2011-01-27 01:40:17 +00002342 // We were missing some default arguments at the end of the list, so remove
2343 // all of the default arguments.
2344 if (RemoveDefaultArguments) {
2345 for (TemplateParameterList::iterator NewParam = NewParams->begin(),
2346 NewParamEnd = NewParams->end();
2347 NewParam != NewParamEnd; ++NewParam) {
2348 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*NewParam))
2349 TTP->removeDefaultArgument();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002350 else if (NonTypeTemplateParmDecl *NTTP
Douglas Gregor0693def2011-01-27 01:40:17 +00002351 = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
2352 NTTP->removeDefaultArgument();
2353 else
2354 cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
2355 }
2356 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00002357
Douglas Gregordba32632009-02-10 19:49:53 +00002358 return Invalid;
2359}
Douglas Gregord32e0282009-02-09 23:23:08 +00002360
John McCalla020a012010-10-20 05:44:58 +00002361namespace {
2362
2363/// A class which looks for a use of a certain level of template
2364/// parameter.
2365struct DependencyChecker : RecursiveASTVisitor<DependencyChecker> {
2366 typedef RecursiveASTVisitor<DependencyChecker> super;
2367
2368 unsigned Depth;
Richard Smith57aae072016-12-28 02:37:25 +00002369
2370 // Whether we're looking for a use of a template parameter that makes the
2371 // overall construct type-dependent / a dependent type. This is strictly
2372 // best-effort for now; we may fail to match at all for a dependent type
2373 // in some cases if this is set.
2374 bool IgnoreNonTypeDependent;
2375
John McCalla020a012010-10-20 05:44:58 +00002376 bool Match;
Richard Smith6056d5e2014-02-09 00:54:43 +00002377 SourceLocation MatchLoc;
2378
Richard Smith13894182017-04-13 21:37:24 +00002379 DependencyChecker(unsigned Depth, bool IgnoreNonTypeDependent)
2380 : Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
2381 Match(false) {}
John McCalla020a012010-10-20 05:44:58 +00002382
Richard Smith57aae072016-12-28 02:37:25 +00002383 DependencyChecker(TemplateParameterList *Params, bool IgnoreNonTypeDependent)
Richard Smith13894182017-04-13 21:37:24 +00002384 : IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(false) {
2385 NamedDecl *ND = Params->getParam(0);
2386 if (TemplateTypeParmDecl *PD = dyn_cast<TemplateTypeParmDecl>(ND)) {
2387 Depth = PD->getDepth();
2388 } else if (NonTypeTemplateParmDecl *PD =
2389 dyn_cast<NonTypeTemplateParmDecl>(ND)) {
2390 Depth = PD->getDepth();
2391 } else {
2392 Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
2393 }
2394 }
John McCalla020a012010-10-20 05:44:58 +00002395
Richard Smith6056d5e2014-02-09 00:54:43 +00002396 bool Matches(unsigned ParmDepth, SourceLocation Loc = SourceLocation()) {
Richard Smith13894182017-04-13 21:37:24 +00002397 if (ParmDepth >= Depth) {
John McCalla020a012010-10-20 05:44:58 +00002398 Match = true;
Richard Smith6056d5e2014-02-09 00:54:43 +00002399 MatchLoc = Loc;
John McCalla020a012010-10-20 05:44:58 +00002400 return true;
2401 }
2402 return false;
2403 }
2404
Richard Smith57aae072016-12-28 02:37:25 +00002405 bool TraverseStmt(Stmt *S, DataRecursionQueue *Q = nullptr) {
2406 // Prune out non-type-dependent expressions if requested. This can
2407 // sometimes result in us failing to find a template parameter reference
2408 // (if a value-dependent expression creates a dependent type), but this
2409 // mode is best-effort only.
2410 if (auto *E = dyn_cast_or_null<Expr>(S))
2411 if (IgnoreNonTypeDependent && !E->isTypeDependent())
2412 return true;
2413 return super::TraverseStmt(S, Q);
2414 }
2415
2416 bool TraverseTypeLoc(TypeLoc TL) {
2417 if (IgnoreNonTypeDependent && !TL.isNull() &&
2418 !TL.getType()->isDependentType())
2419 return true;
2420 return super::TraverseTypeLoc(TL);
2421 }
2422
Richard Smith6056d5e2014-02-09 00:54:43 +00002423 bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
2424 return !Matches(TL.getTypePtr()->getDepth(), TL.getNameLoc());
2425 }
2426
John McCalla020a012010-10-20 05:44:58 +00002427 bool VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
Richard Smith57aae072016-12-28 02:37:25 +00002428 // For a best-effort search, keep looking until we find a location.
2429 return IgnoreNonTypeDependent || !Matches(T->getDepth());
John McCalla020a012010-10-20 05:44:58 +00002430 }
2431
2432 bool TraverseTemplateName(TemplateName N) {
2433 if (TemplateTemplateParmDecl *PD =
2434 dyn_cast_or_null<TemplateTemplateParmDecl>(N.getAsTemplateDecl()))
Richard Smith6056d5e2014-02-09 00:54:43 +00002435 if (Matches(PD->getDepth()))
2436 return false;
John McCalla020a012010-10-20 05:44:58 +00002437 return super::TraverseTemplateName(N);
2438 }
2439
2440 bool VisitDeclRefExpr(DeclRefExpr *E) {
2441 if (NonTypeTemplateParmDecl *PD =
Richard Smith6056d5e2014-02-09 00:54:43 +00002442 dyn_cast<NonTypeTemplateParmDecl>(E->getDecl()))
2443 if (Matches(PD->getDepth(), E->getExprLoc()))
John McCalla020a012010-10-20 05:44:58 +00002444 return false;
John McCalla020a012010-10-20 05:44:58 +00002445 return super::VisitDeclRefExpr(E);
2446 }
Richard Smith6056d5e2014-02-09 00:54:43 +00002447
2448 bool VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
2449 return TraverseType(T->getReplacementType());
2450 }
2451
2452 bool
2453 VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
2454 return TraverseTemplateArgument(T->getArgumentPack());
2455 }
2456
Douglas Gregora6a7e3c2011-05-13 00:34:01 +00002457 bool TraverseInjectedClassNameType(const InjectedClassNameType *T) {
2458 return TraverseType(T->getInjectedSpecializationType());
2459 }
John McCalla020a012010-10-20 05:44:58 +00002460};
Eugene Zelenko1ced5092016-02-12 22:53:10 +00002461} // end anonymous namespace
John McCalla020a012010-10-20 05:44:58 +00002462
Douglas Gregor972fe532011-05-10 18:27:06 +00002463/// Determines whether a given type depends on the given parameter
John McCalla020a012010-10-20 05:44:58 +00002464/// list.
2465static bool
Douglas Gregor972fe532011-05-10 18:27:06 +00002466DependsOnTemplateParameters(QualType T, TemplateParameterList *Params) {
Richard Smith57aae072016-12-28 02:37:25 +00002467 DependencyChecker Checker(Params, /*IgnoreNonTypeDependent*/false);
Douglas Gregor972fe532011-05-10 18:27:06 +00002468 Checker.TraverseType(T);
John McCalla020a012010-10-20 05:44:58 +00002469 return Checker.Match;
2470}
2471
Douglas Gregor972fe532011-05-10 18:27:06 +00002472// Find the source range corresponding to the named type in the given
2473// nested-name-specifier, if any.
2474static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context,
2475 QualType T,
2476 const CXXScopeSpec &SS) {
2477 NestedNameSpecifierLoc NNSLoc(SS.getScopeRep(), SS.location_data());
2478 while (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier()) {
2479 if (const Type *CurType = NNS->getAsType()) {
2480 if (Context.hasSameUnqualifiedType(T, QualType(CurType, 0)))
2481 return NNSLoc.getTypeLoc().getSourceRange();
2482 } else
2483 break;
Simon Pilgrim6905d222016-12-30 22:55:33 +00002484
Douglas Gregor972fe532011-05-10 18:27:06 +00002485 NNSLoc = NNSLoc.getPrefix();
2486 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00002487
Douglas Gregor972fe532011-05-10 18:27:06 +00002488 return SourceRange();
2489}
2490
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00002491/// Match the given template parameter lists to the given scope
Douglas Gregord8d297c2009-07-21 23:53:31 +00002492/// specifier, returning the template parameter list that applies to the
2493/// name.
2494///
2495/// \param DeclStartLoc the start of the declaration that has a scope
2496/// specifier or a template parameter list.
Mike Stump11289f42009-09-09 15:08:12 +00002497///
Douglas Gregor972fe532011-05-10 18:27:06 +00002498/// \param DeclLoc The location of the declaration itself.
2499///
Douglas Gregord8d297c2009-07-21 23:53:31 +00002500/// \param SS the scope specifier that will be matched to the given template
2501/// parameter lists. This scope specifier precedes a qualified name that is
2502/// being declared.
2503///
Richard Smith4b55a9c2014-04-17 03:29:33 +00002504/// \param TemplateId The template-id following the scope specifier, if there
2505/// is one. Used to check for a missing 'template<>'.
2506///
Douglas Gregord8d297c2009-07-21 23:53:31 +00002507/// \param ParamLists the template parameter lists, from the outermost to the
2508/// innermost template parameter lists.
2509///
John McCalle820e5e2010-04-13 20:37:33 +00002510/// \param IsFriend Whether to apply the slightly different rules for
2511/// matching template parameters to scope specifiers in friend
2512/// declarations.
2513///
Richard Smithf445f192017-02-09 21:04:43 +00002514/// \param IsMemberSpecialization will be set true if the scope specifier
2515/// denotes a fully-specialized type, and therefore this is a declaration of
2516/// a member specialization.
Douglas Gregor5c0405d2009-10-07 22:35:40 +00002517///
Mike Stump11289f42009-09-09 15:08:12 +00002518/// \returns the template parameter list, if any, that corresponds to the
Douglas Gregord8d297c2009-07-21 23:53:31 +00002519/// name that is preceded by the scope specifier @p SS. This template
Abramo Bagnara60804e12011-03-18 15:16:37 +00002520/// parameter list may have template parameters (if we're declaring a
Mike Stump11289f42009-09-09 15:08:12 +00002521/// template) or may have no template parameters (if we're declaring a
Abramo Bagnara60804e12011-03-18 15:16:37 +00002522/// template specialization), or may be NULL (if what we're declaring isn't
Douglas Gregord8d297c2009-07-21 23:53:31 +00002523/// itself a template).
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00002524TemplateParameterList *Sema::MatchTemplateParametersToScopeSpecifier(
2525 SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS,
Richard Smith4b55a9c2014-04-17 03:29:33 +00002526 TemplateIdAnnotation *TemplateId,
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00002527 ArrayRef<TemplateParameterList *> ParamLists, bool IsFriend,
Richard Smithf445f192017-02-09 21:04:43 +00002528 bool &IsMemberSpecialization, bool &Invalid) {
2529 IsMemberSpecialization = false;
Douglas Gregor972fe532011-05-10 18:27:06 +00002530 Invalid = false;
Simon Pilgrim6905d222016-12-30 22:55:33 +00002531
Douglas Gregor972fe532011-05-10 18:27:06 +00002532 // The sequence of nested types to which we will match up the template
2533 // parameter lists. We first build this list by starting with the type named
2534 // by the nested-name-specifier and walking out until we run out of types.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002535 SmallVector<QualType, 4> NestedTypes;
Douglas Gregor972fe532011-05-10 18:27:06 +00002536 QualType T;
Douglas Gregor9d07dfa2011-05-15 17:27:27 +00002537 if (SS.getScopeRep()) {
Simon Pilgrim6905d222016-12-30 22:55:33 +00002538 if (CXXRecordDecl *Record
Douglas Gregor9d07dfa2011-05-15 17:27:27 +00002539 = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, true)))
2540 T = Context.getTypeDeclType(Record);
2541 else
2542 T = QualType(SS.getScopeRep()->getAsType(), 0);
2543 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00002544
Douglas Gregor972fe532011-05-10 18:27:06 +00002545 // If we found an explicit specialization that prevents us from needing
2546 // 'template<>' headers, this will be set to the location of that
2547 // explicit specialization.
2548 SourceLocation ExplicitSpecLoc;
Simon Pilgrim6905d222016-12-30 22:55:33 +00002549
Douglas Gregor972fe532011-05-10 18:27:06 +00002550 while (!T.isNull()) {
2551 NestedTypes.push_back(T);
Simon Pilgrim6905d222016-12-30 22:55:33 +00002552
Douglas Gregor972fe532011-05-10 18:27:06 +00002553 // Retrieve the parent of a record type.
2554 if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
2555 // If this type is an explicit specialization, we're done.
2556 if (ClassTemplateSpecializationDecl *Spec
2557 = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
Simon Pilgrim6905d222016-12-30 22:55:33 +00002558 if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
Douglas Gregor972fe532011-05-10 18:27:06 +00002559 Spec->getSpecializationKind() == TSK_ExplicitSpecialization) {
2560 ExplicitSpecLoc = Spec->getLocation();
2561 break;
Douglas Gregor65911492009-11-23 12:11:45 +00002562 }
Douglas Gregor972fe532011-05-10 18:27:06 +00002563 } else if (Record->getTemplateSpecializationKind()
2564 == TSK_ExplicitSpecialization) {
2565 ExplicitSpecLoc = Record->getLocation();
John McCalle820e5e2010-04-13 20:37:33 +00002566 break;
2567 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00002568
Douglas Gregor972fe532011-05-10 18:27:06 +00002569 if (TypeDecl *Parent = dyn_cast<TypeDecl>(Record->getParent()))
2570 T = Context.getTypeDeclType(Parent);
2571 else
2572 T = QualType();
2573 continue;
Simon Pilgrim6905d222016-12-30 22:55:33 +00002574 }
2575
Douglas Gregor972fe532011-05-10 18:27:06 +00002576 if (const TemplateSpecializationType *TST
2577 = T->getAs<TemplateSpecializationType>()) {
2578 if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2579 if (TypeDecl *Parent = dyn_cast<TypeDecl>(Template->getDeclContext()))
2580 T = Context.getTypeDeclType(Parent);
2581 else
2582 T = QualType();
Simon Pilgrim6905d222016-12-30 22:55:33 +00002583 continue;
Douglas Gregord8d297c2009-07-21 23:53:31 +00002584 }
Douglas Gregor972fe532011-05-10 18:27:06 +00002585 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00002586
Douglas Gregor972fe532011-05-10 18:27:06 +00002587 // Look one step prior in a dependent template specialization type.
2588 if (const DependentTemplateSpecializationType *DependentTST
2589 = T->getAs<DependentTemplateSpecializationType>()) {
2590 if (NestedNameSpecifier *NNS = DependentTST->getQualifier())
2591 T = QualType(NNS->getAsType(), 0);
2592 else
2593 T = QualType();
2594 continue;
2595 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00002596
Douglas Gregor972fe532011-05-10 18:27:06 +00002597 // Look one step prior in a dependent name type.
2598 if (const DependentNameType *DependentName = T->getAs<DependentNameType>()){
2599 if (NestedNameSpecifier *NNS = DependentName->getQualifier())
2600 T = QualType(NNS->getAsType(), 0);
2601 else
2602 T = QualType();
2603 continue;
2604 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00002605
Douglas Gregor972fe532011-05-10 18:27:06 +00002606 // Retrieve the parent of an enumeration type.
2607 if (const EnumType *EnumT = T->getAs<EnumType>()) {
2608 // FIXME: Forward-declared enums require a TSK_ExplicitSpecialization
2609 // check here.
2610 EnumDecl *Enum = EnumT->getDecl();
Simon Pilgrim6905d222016-12-30 22:55:33 +00002611
Douglas Gregor972fe532011-05-10 18:27:06 +00002612 // Get to the parent type.
2613 if (TypeDecl *Parent = dyn_cast<TypeDecl>(Enum->getParent()))
2614 T = Context.getTypeDeclType(Parent);
2615 else
Simon Pilgrim6905d222016-12-30 22:55:33 +00002616 T = QualType();
Douglas Gregor972fe532011-05-10 18:27:06 +00002617 continue;
Douglas Gregord8d297c2009-07-21 23:53:31 +00002618 }
Mike Stump11289f42009-09-09 15:08:12 +00002619
Douglas Gregor972fe532011-05-10 18:27:06 +00002620 T = QualType();
2621 }
2622 // Reverse the nested types list, since we want to traverse from the outermost
2623 // to the innermost while checking template-parameter-lists.
2624 std::reverse(NestedTypes.begin(), NestedTypes.end());
Douglas Gregor15301382009-07-30 17:40:51 +00002625
Douglas Gregor972fe532011-05-10 18:27:06 +00002626 // C++0x [temp.expl.spec]p17:
2627 // A member or a member template may be nested within many
2628 // enclosing class templates. In an explicit specialization for
2629 // such a member, the member declaration shall be preceded by a
2630 // template<> for each enclosing class template that is
2631 // explicitly specialized.
Douglas Gregor522d5eb2011-06-06 15:22:55 +00002632 bool SawNonEmptyTemplateParameterList = false;
Richard Smith11a80dc2014-04-17 03:52:20 +00002633
NAKAMURA Takumide4077a2014-04-17 08:57:09 +00002634 auto CheckExplicitSpecialization = [&](SourceRange Range, bool Recovery) {
Richard Smith11a80dc2014-04-17 03:52:20 +00002635 if (SawNonEmptyTemplateParameterList) {
2636 Diag(DeclLoc, diag::err_specialize_member_of_template)
2637 << !Recovery << Range;
2638 Invalid = true;
Richard Smithf445f192017-02-09 21:04:43 +00002639 IsMemberSpecialization = false;
Richard Smith11a80dc2014-04-17 03:52:20 +00002640 return true;
2641 }
2642
2643 return false;
2644 };
2645
2646 auto DiagnoseMissingExplicitSpecialization = [&] (SourceRange Range) {
2647 // Check that we can have an explicit specialization here.
2648 if (CheckExplicitSpecialization(Range, true))
2649 return true;
2650
2651 // We don't have a template header, but we should.
2652 SourceLocation ExpectedTemplateLoc;
2653 if (!ParamLists.empty())
2654 ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
2655 else
2656 ExpectedTemplateLoc = DeclStartLoc;
2657
2658 Diag(DeclLoc, diag::err_template_spec_needs_header)
2659 << Range
2660 << FixItHint::CreateInsertion(ExpectedTemplateLoc, "template<> ");
2661 return false;
2662 };
2663
Douglas Gregor972fe532011-05-10 18:27:06 +00002664 unsigned ParamIdx = 0;
2665 for (unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
2666 ++TypeIdx) {
2667 T = NestedTypes[TypeIdx];
Simon Pilgrim6905d222016-12-30 22:55:33 +00002668
Douglas Gregor972fe532011-05-10 18:27:06 +00002669 // Whether we expect a 'template<>' header.
2670 bool NeedEmptyTemplateHeader = false;
2671
2672 // Whether we expect a template header with parameters.
2673 bool NeedNonemptyTemplateHeader = false;
Simon Pilgrim6905d222016-12-30 22:55:33 +00002674
Douglas Gregor972fe532011-05-10 18:27:06 +00002675 // For a dependent type, the set of template parameters that we
2676 // expect to see.
Craig Topperc3ec1492014-05-26 06:22:03 +00002677 TemplateParameterList *ExpectedTemplateParams = nullptr;
Douglas Gregor972fe532011-05-10 18:27:06 +00002678
Douglas Gregor373af9b2011-05-11 23:26:17 +00002679 // C++0x [temp.expl.spec]p15:
Simon Pilgrim6905d222016-12-30 22:55:33 +00002680 // A member or a member template may be nested within many enclosing
2681 // class templates. In an explicit specialization for such a member, the
2682 // member declaration shall be preceded by a template<> for each
Douglas Gregor373af9b2011-05-11 23:26:17 +00002683 // enclosing class template that is explicitly specialized.
Douglas Gregor972fe532011-05-10 18:27:06 +00002684 if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
2685 if (ClassTemplatePartialSpecializationDecl *Partial
2686 = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) {
2687 ExpectedTemplateParams = Partial->getTemplateParameters();
2688 NeedNonemptyTemplateHeader = true;
2689 } else if (Record->isDependentType()) {
2690 if (Record->getDescribedClassTemplate()) {
John McCall2408e322010-04-27 00:57:59 +00002691 ExpectedTemplateParams = Record->getDescribedClassTemplate()
Douglas Gregor972fe532011-05-10 18:27:06 +00002692 ->getTemplateParameters();
2693 NeedNonemptyTemplateHeader = true;
2694 }
2695 } else if (ClassTemplateSpecializationDecl *Spec
2696 = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
2697 // C++0x [temp.expl.spec]p4:
2698 // Members of an explicitly specialized class template are defined
Simon Pilgrim6905d222016-12-30 22:55:33 +00002699 // in the same manner as members of normal classes, and not using
2700 // the template<> syntax.
Douglas Gregor972fe532011-05-10 18:27:06 +00002701 if (Spec->getSpecializationKind() != TSK_ExplicitSpecialization)
2702 NeedEmptyTemplateHeader = true;
2703 else
Douglas Gregorb32e8252011-06-01 22:37:07 +00002704 continue;
Douglas Gregor972fe532011-05-10 18:27:06 +00002705 } else if (Record->getTemplateSpecializationKind()) {
Simon Pilgrim6905d222016-12-30 22:55:33 +00002706 if (Record->getTemplateSpecializationKind()
Douglas Gregor373af9b2011-05-11 23:26:17 +00002707 != TSK_ExplicitSpecialization &&
2708 TypeIdx == NumTypes - 1)
Richard Smithf445f192017-02-09 21:04:43 +00002709 IsMemberSpecialization = true;
Simon Pilgrim6905d222016-12-30 22:55:33 +00002710
Douglas Gregor373af9b2011-05-11 23:26:17 +00002711 continue;
Douglas Gregor972fe532011-05-10 18:27:06 +00002712 }
2713 } else if (const TemplateSpecializationType *TST
2714 = T->getAs<TemplateSpecializationType>()) {
Nico Weber28900612015-01-30 02:35:21 +00002715 if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
Douglas Gregor972fe532011-05-10 18:27:06 +00002716 ExpectedTemplateParams = Template->getTemplateParameters();
Simon Pilgrim6905d222016-12-30 22:55:33 +00002717 NeedNonemptyTemplateHeader = true;
Douglas Gregor972fe532011-05-10 18:27:06 +00002718 }
2719 } else if (T->getAs<DependentTemplateSpecializationType>()) {
2720 // FIXME: We actually could/should check the template arguments here
2721 // against the corresponding template parameter list.
2722 NeedNonemptyTemplateHeader = false;
Simon Pilgrim6905d222016-12-30 22:55:33 +00002723 }
2724
Douglas Gregor522d5eb2011-06-06 15:22:55 +00002725 // C++ [temp.expl.spec]p16:
Simon Pilgrim6905d222016-12-30 22:55:33 +00002726 // In an explicit specialization declaration for a member of a class
2727 // template or a member template that ap- pears in namespace scope, the
2728 // member template and some of its enclosing class templates may remain
2729 // unspecialized, except that the declaration shall not explicitly
2730 // specialize a class member template if its en- closing class templates
Douglas Gregor522d5eb2011-06-06 15:22:55 +00002731 // are not explicitly specialized as well.
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00002732 if (ParamIdx < ParamLists.size()) {
Douglas Gregor522d5eb2011-06-06 15:22:55 +00002733 if (ParamLists[ParamIdx]->size() == 0) {
NAKAMURA Takumide4077a2014-04-17 08:57:09 +00002734 if (CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
2735 false))
Craig Topperc3ec1492014-05-26 06:22:03 +00002736 return nullptr;
Douglas Gregor522d5eb2011-06-06 15:22:55 +00002737 } else
2738 SawNonEmptyTemplateParameterList = true;
2739 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00002740
Douglas Gregor972fe532011-05-10 18:27:06 +00002741 if (NeedEmptyTemplateHeader) {
2742 // If we're on the last of the types, and we need a 'template<>' header
Richard Smithf445f192017-02-09 21:04:43 +00002743 // here, then it's a member specialization.
Douglas Gregor972fe532011-05-10 18:27:06 +00002744 if (TypeIdx == NumTypes - 1)
Richard Smithf445f192017-02-09 21:04:43 +00002745 IsMemberSpecialization = true;
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00002746
2747 if (ParamIdx < ParamLists.size()) {
Douglas Gregor972fe532011-05-10 18:27:06 +00002748 if (ParamLists[ParamIdx]->size() > 0) {
2749 // The header has template parameters when it shouldn't. Complain.
Simon Pilgrim6905d222016-12-30 22:55:33 +00002750 Diag(ParamLists[ParamIdx]->getTemplateLoc(),
Douglas Gregor972fe532011-05-10 18:27:06 +00002751 diag::err_template_param_list_matches_nontemplate)
2752 << T
2753 << SourceRange(ParamLists[ParamIdx]->getLAngleLoc(),
2754 ParamLists[ParamIdx]->getRAngleLoc())
2755 << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
2756 Invalid = true;
Craig Topperc3ec1492014-05-26 06:22:03 +00002757 return nullptr;
Douglas Gregor972fe532011-05-10 18:27:06 +00002758 }
Richard Smith11a80dc2014-04-17 03:52:20 +00002759
Douglas Gregor972fe532011-05-10 18:27:06 +00002760 // Consume this template header.
2761 ++ParamIdx;
2762 continue;
Douglas Gregor972fe532011-05-10 18:27:06 +00002763 }
Richard Smith11a80dc2014-04-17 03:52:20 +00002764
2765 if (!IsFriend)
2766 if (DiagnoseMissingExplicitSpecialization(
2767 getRangeOfTypeInNestedNameSpecifier(Context, T, SS)))
Craig Topperc3ec1492014-05-26 06:22:03 +00002768 return nullptr;
Richard Smith11a80dc2014-04-17 03:52:20 +00002769
Douglas Gregor972fe532011-05-10 18:27:06 +00002770 continue;
2771 }
Richard Smith11a80dc2014-04-17 03:52:20 +00002772
Douglas Gregor972fe532011-05-10 18:27:06 +00002773 if (NeedNonemptyTemplateHeader) {
2774 // In friend declarations we can have template-ids which don't
2775 // depend on the corresponding template parameter lists. But
2776 // assume that empty parameter lists are supposed to match this
2777 // template-id.
2778 if (IsFriend && T->isDependentType()) {
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00002779 if (ParamIdx < ParamLists.size() &&
Douglas Gregor972fe532011-05-10 18:27:06 +00002780 DependsOnTemplateParameters(T, ParamLists[ParamIdx]))
Craig Topperc3ec1492014-05-26 06:22:03 +00002781 ExpectedTemplateParams = nullptr;
Simon Pilgrim6905d222016-12-30 22:55:33 +00002782 else
Douglas Gregor972fe532011-05-10 18:27:06 +00002783 continue;
Mike Stump11289f42009-09-09 15:08:12 +00002784 }
Douglas Gregored5731f2009-11-25 17:50:39 +00002785
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00002786 if (ParamIdx < ParamLists.size()) {
2787 // Check the template parameter list, if we can.
Douglas Gregor972fe532011-05-10 18:27:06 +00002788 if (ExpectedTemplateParams &&
2789 !TemplateParameterListsAreEqual(ParamLists[ParamIdx],
2790 ExpectedTemplateParams,
2791 true, TPL_TemplateMatch))
2792 Invalid = true;
Craig Topperc3ec1492014-05-26 06:22:03 +00002793
Douglas Gregor972fe532011-05-10 18:27:06 +00002794 if (!Invalid &&
Craig Topperc3ec1492014-05-26 06:22:03 +00002795 CheckTemplateParameterList(ParamLists[ParamIdx], nullptr,
Douglas Gregor972fe532011-05-10 18:27:06 +00002796 TPC_ClassTemplateMember))
2797 Invalid = true;
Simon Pilgrim6905d222016-12-30 22:55:33 +00002798
Douglas Gregor972fe532011-05-10 18:27:06 +00002799 ++ParamIdx;
2800 continue;
2801 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00002802
Douglas Gregor972fe532011-05-10 18:27:06 +00002803 Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
2804 << T
2805 << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
2806 Invalid = true;
2807 continue;
2808 }
Douglas Gregord8d297c2009-07-21 23:53:31 +00002809 }
Richard Smith4b55a9c2014-04-17 03:29:33 +00002810
Douglas Gregord8d297c2009-07-21 23:53:31 +00002811 // If there were at least as many template-ids as there were template
2812 // parameter lists, then there are no template parameter lists remaining for
2813 // the declaration itself.
Richard Smith4b55a9c2014-04-17 03:29:33 +00002814 if (ParamIdx >= ParamLists.size()) {
2815 if (TemplateId && !IsFriend) {
Richard Smith4b55a9c2014-04-17 03:29:33 +00002816 // We don't have a template header for the declaration itself, but we
2817 // should.
Richard Smith11a80dc2014-04-17 03:52:20 +00002818 DiagnoseMissingExplicitSpecialization(SourceRange(TemplateId->LAngleLoc,
2819 TemplateId->RAngleLoc));
Richard Smith4b55a9c2014-04-17 03:29:33 +00002820
2821 // Fabricate an empty template parameter list for the invented header.
2822 return TemplateParameterList::Create(Context, SourceLocation(),
David Majnemer902f8c62015-12-27 07:16:27 +00002823 SourceLocation(), None,
Hubert Tonge4a0c0e2016-07-30 22:33:34 +00002824 SourceLocation(), nullptr);
Richard Smith4b55a9c2014-04-17 03:29:33 +00002825 }
2826
Craig Topperc3ec1492014-05-26 06:22:03 +00002827 return nullptr;
Richard Smith4b55a9c2014-04-17 03:29:33 +00002828 }
Mike Stump11289f42009-09-09 15:08:12 +00002829
Douglas Gregord8d297c2009-07-21 23:53:31 +00002830 // If there were too many template parameter lists, complain about that now.
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00002831 if (ParamIdx < ParamLists.size() - 1) {
Douglas Gregor972fe532011-05-10 18:27:06 +00002832 bool HasAnyExplicitSpecHeader = false;
2833 bool AllExplicitSpecHeaders = true;
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00002834 for (unsigned I = ParamIdx, E = ParamLists.size() - 1; I != E; ++I) {
Douglas Gregor972fe532011-05-10 18:27:06 +00002835 if (ParamLists[I]->size() == 0)
2836 HasAnyExplicitSpecHeader = true;
2837 else
2838 AllExplicitSpecHeaders = false;
Douglas Gregord8d297c2009-07-21 23:53:31 +00002839 }
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00002840
Douglas Gregor972fe532011-05-10 18:27:06 +00002841 Diag(ParamLists[ParamIdx]->getTemplateLoc(),
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00002842 AllExplicitSpecHeaders ? diag::warn_template_spec_extra_headers
2843 : diag::err_template_spec_extra_headers)
2844 << SourceRange(ParamLists[ParamIdx]->getTemplateLoc(),
2845 ParamLists[ParamLists.size() - 2]->getRAngleLoc());
Douglas Gregor972fe532011-05-10 18:27:06 +00002846
2847 // If there was a specialization somewhere, such that 'template<>' is
2848 // not required, and there were any 'template<>' headers, note where the
2849 // specialization occurred.
2850 if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader)
Simon Pilgrim6905d222016-12-30 22:55:33 +00002851 Diag(ExplicitSpecLoc,
Douglas Gregor972fe532011-05-10 18:27:06 +00002852 diag::note_explicit_template_spec_does_not_need_header)
2853 << NestedTypes.back();
Simon Pilgrim6905d222016-12-30 22:55:33 +00002854
Douglas Gregor972fe532011-05-10 18:27:06 +00002855 // We have a template parameter list with no corresponding scope, which
2856 // means that the resulting template declaration can't be instantiated
2857 // properly (we'll end up with dependent nodes when we shouldn't).
2858 if (!AllExplicitSpecHeaders)
2859 Invalid = true;
Douglas Gregord8d297c2009-07-21 23:53:31 +00002860 }
Mike Stump11289f42009-09-09 15:08:12 +00002861
Douglas Gregor522d5eb2011-06-06 15:22:55 +00002862 // C++ [temp.expl.spec]p16:
Simon Pilgrim6905d222016-12-30 22:55:33 +00002863 // In an explicit specialization declaration for a member of a class
2864 // template or a member template that ap- pears in namespace scope, the
2865 // member template and some of its enclosing class templates may remain
2866 // unspecialized, except that the declaration shall not explicitly
2867 // specialize a class member template if its en- closing class templates
Douglas Gregor522d5eb2011-06-06 15:22:55 +00002868 // are not explicitly specialized as well.
Richard Smith11a80dc2014-04-17 03:52:20 +00002869 if (ParamLists.back()->size() == 0 &&
NAKAMURA Takumide4077a2014-04-17 08:57:09 +00002870 CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
2871 false))
Craig Topperc3ec1492014-05-26 06:22:03 +00002872 return nullptr;
Richard Smith11a80dc2014-04-17 03:52:20 +00002873
Douglas Gregord8d297c2009-07-21 23:53:31 +00002874 // Return the last template parameter list, which corresponds to the
2875 // entity being declared.
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00002876 return ParamLists.back();
Douglas Gregord8d297c2009-07-21 23:53:31 +00002877}
2878
Douglas Gregor8b6070b2011-03-04 21:37:14 +00002879void Sema::NoteAllFoundTemplates(TemplateName Name) {
2880 if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
2881 Diag(Template->getLocation(), diag::note_template_declared_here)
Larisse Voufo39a1e502013-08-06 01:03:05 +00002882 << (isa<FunctionTemplateDecl>(Template)
2883 ? 0
2884 : isa<ClassTemplateDecl>(Template)
2885 ? 1
2886 : isa<VarTemplateDecl>(Template)
2887 ? 2
2888 : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
2889 << Template->getDeclName();
Douglas Gregor8b6070b2011-03-04 21:37:14 +00002890 return;
2891 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00002892
Douglas Gregor8b6070b2011-03-04 21:37:14 +00002893 if (OverloadedTemplateStorage *OST = Name.getAsOverloadedTemplate()) {
Simon Pilgrim6905d222016-12-30 22:55:33 +00002894 for (OverloadedTemplateStorage::iterator I = OST->begin(),
Douglas Gregor8b6070b2011-03-04 21:37:14 +00002895 IEnd = OST->end();
2896 I != IEnd; ++I)
2897 Diag((*I)->getLocation(), diag::note_template_declared_here)
2898 << 0 << (*I)->getDeclName();
Simon Pilgrim6905d222016-12-30 22:55:33 +00002899
Douglas Gregor8b6070b2011-03-04 21:37:14 +00002900 return;
2901 }
2902}
2903
David Majnemerd9b1a4f2015-11-04 03:40:30 +00002904static QualType
2905checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD,
2906 const SmallVectorImpl<TemplateArgument> &Converted,
2907 SourceLocation TemplateLoc,
2908 TemplateArgumentListInfo &TemplateArgs) {
2909 ASTContext &Context = SemaRef.getASTContext();
2910 switch (BTD->getBuiltinTemplateKind()) {
Eric Fiselier6ad68552016-07-01 01:24:09 +00002911 case BTK__make_integer_seq: {
David Majnemerd9b1a4f2015-11-04 03:40:30 +00002912 // Specializations of __make_integer_seq<S, T, N> are treated like
2913 // S<T, 0, ..., N-1>.
2914
2915 // C++14 [inteseq.intseq]p1:
2916 // T shall be an integer type.
2917 if (!Converted[1].getAsType()->isIntegralType(Context)) {
2918 SemaRef.Diag(TemplateArgs[1].getLocation(),
2919 diag::err_integer_sequence_integral_element_type);
2920 return QualType();
2921 }
2922
2923 // C++14 [inteseq.make]p1:
2924 // If N is negative the program is ill-formed.
2925 TemplateArgument NumArgsArg = Converted[2];
2926 llvm::APSInt NumArgs = NumArgsArg.getAsIntegral();
2927 if (NumArgs < 0) {
2928 SemaRef.Diag(TemplateArgs[2].getLocation(),
2929 diag::err_integer_sequence_negative_length);
2930 return QualType();
2931 }
2932
2933 QualType ArgTy = NumArgsArg.getIntegralType();
2934 TemplateArgumentListInfo SyntheticTemplateArgs;
2935 // The type argument gets reused as the first template argument in the
2936 // synthetic template argument list.
2937 SyntheticTemplateArgs.addArgument(TemplateArgs[1]);
2938 // Expand N into 0 ... N-1.
2939 for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
2940 I < NumArgs; ++I) {
2941 TemplateArgument TA(Context, I, ArgTy);
Richard Smith7873de02016-08-11 22:25:46 +00002942 SyntheticTemplateArgs.addArgument(SemaRef.getTrivialTemplateArgumentLoc(
2943 TA, ArgTy, TemplateArgs[2].getLocation()));
David Majnemerd9b1a4f2015-11-04 03:40:30 +00002944 }
2945 // The first template argument will be reused as the template decl that
2946 // our synthetic template arguments will be applied to.
2947 return SemaRef.CheckTemplateIdType(Converted[0].getAsTemplate(),
2948 TemplateLoc, SyntheticTemplateArgs);
2949 }
Eric Fiselier6ad68552016-07-01 01:24:09 +00002950
2951 case BTK__type_pack_element:
2952 // Specializations of
2953 // __type_pack_element<Index, T_1, ..., T_N>
2954 // are treated like T_Index.
2955 assert(Converted.size() == 2 &&
2956 "__type_pack_element should be given an index and a parameter pack");
2957
2958 // If the Index is out of bounds, the program is ill-formed.
2959 TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
2960 llvm::APSInt Index = IndexArg.getAsIntegral();
2961 assert(Index >= 0 && "the index used with __type_pack_element should be of "
2962 "type std::size_t, and hence be non-negative");
2963 if (Index >= Ts.pack_size()) {
2964 SemaRef.Diag(TemplateArgs[0].getLocation(),
2965 diag::err_type_pack_element_out_of_bounds);
2966 return QualType();
2967 }
2968
2969 // We simply return the type at index `Index`.
2970 auto Nth = std::next(Ts.pack_begin(), Index.getExtValue());
2971 return Nth->getAsType();
2972 }
David Majnemerd9b1a4f2015-11-04 03:40:30 +00002973 llvm_unreachable("unexpected BuiltinTemplateDecl!");
2974}
2975
Douglas Gregor00fa10b2017-07-05 20:20:14 +00002976/// Determine whether this alias template is "enable_if_t".
2977static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate) {
2978 return AliasTemplate->getName().equals("enable_if_t");
2979}
2980
2981/// Collect all of the separable terms in the given condition, which
2982/// might be a conjunction.
2983///
2984/// FIXME: The right answer is to convert the logical expression into
2985/// disjunctive normal form, so we can find the first failed term
2986/// within each possible clause.
2987static void collectConjunctionTerms(Expr *Clause,
2988 SmallVectorImpl<Expr *> &Terms) {
2989 if (auto BinOp = dyn_cast<BinaryOperator>(Clause->IgnoreParenImpCasts())) {
2990 if (BinOp->getOpcode() == BO_LAnd) {
2991 collectConjunctionTerms(BinOp->getLHS(), Terms);
2992 collectConjunctionTerms(BinOp->getRHS(), Terms);
2993 }
2994
2995 return;
2996 }
2997
2998 Terms.push_back(Clause);
2999}
3000
Douglas Gregorbb33f572017-07-05 20:20:15 +00003001// The ranges-v3 library uses an odd pattern of a top-level "||" with
3002// a left-hand side that is value-dependent but never true. Identify
3003// the idiom and ignore that term.
3004static Expr *lookThroughRangesV3Condition(Preprocessor &PP, Expr *Cond) {
3005 // Top-level '||'.
3006 auto *BinOp = dyn_cast<BinaryOperator>(Cond->IgnoreParenImpCasts());
3007 if (!BinOp) return Cond;
3008
3009 if (BinOp->getOpcode() != BO_LOr) return Cond;
3010
3011 // With an inner '==' that has a literal on the right-hand side.
3012 Expr *LHS = BinOp->getLHS();
Douglas Gregorc0fe1f22017-07-05 21:12:37 +00003013 auto *InnerBinOp = dyn_cast<BinaryOperator>(LHS->IgnoreParenImpCasts());
Douglas Gregorbb33f572017-07-05 20:20:15 +00003014 if (!InnerBinOp) return Cond;
3015
3016 if (InnerBinOp->getOpcode() != BO_EQ ||
3017 !isa<IntegerLiteral>(InnerBinOp->getRHS()))
3018 return Cond;
3019
3020 // If the inner binary operation came from a macro expansion named
3021 // CONCEPT_REQUIRES or CONCEPT_REQUIRES_, return the right-hand side
3022 // of the '||', which is the real, user-provided condition.
Douglas Gregorc0fe1f22017-07-05 21:12:37 +00003023 SourceLocation Loc = InnerBinOp->getExprLoc();
Douglas Gregorbb33f572017-07-05 20:20:15 +00003024 if (!Loc.isMacroID()) return Cond;
3025
3026 StringRef MacroName = PP.getImmediateMacroName(Loc);
3027 if (MacroName == "CONCEPT_REQUIRES" || MacroName == "CONCEPT_REQUIRES_")
3028 return BinOp->getRHS();
3029
3030 return Cond;
3031}
3032
Douglas Gregor672281a2017-09-14 23:38:42 +00003033std::pair<Expr *, std::string>
3034Sema::findFailedBooleanCondition(Expr *Cond, bool AllowTopLevelCond) {
3035 Cond = lookThroughRangesV3Condition(PP, Cond);
Douglas Gregorbb33f572017-07-05 20:20:15 +00003036
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003037 // Separate out all of the terms in a conjunction.
3038 SmallVector<Expr *, 4> Terms;
3039 collectConjunctionTerms(Cond, Terms);
3040
3041 // Determine which term failed.
3042 Expr *FailedCond = nullptr;
3043 for (Expr *Term : Terms) {
Douglas Gregor672281a2017-09-14 23:38:42 +00003044 Expr *TermAsWritten = Term->IgnoreParenImpCasts();
3045
3046 // Literals are uninteresting.
3047 if (isa<CXXBoolLiteralExpr>(TermAsWritten) ||
3048 isa<IntegerLiteral>(TermAsWritten))
3049 continue;
3050
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003051 // The initialization of the parameter from the argument is
3052 // a constant-evaluated context.
3053 EnterExpressionEvaluationContext ConstantEvaluated(
Douglas Gregor672281a2017-09-14 23:38:42 +00003054 *this, Sema::ExpressionEvaluationContext::ConstantEvaluated);
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003055
3056 bool Succeeded;
Douglas Gregor672281a2017-09-14 23:38:42 +00003057 if (Term->EvaluateAsBooleanCondition(Succeeded, Context) &&
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003058 !Succeeded) {
Douglas Gregor672281a2017-09-14 23:38:42 +00003059 FailedCond = TermAsWritten;
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003060 break;
3061 }
3062 }
3063
Douglas Gregor672281a2017-09-14 23:38:42 +00003064 if (!FailedCond) {
3065 if (!AllowTopLevelCond)
3066 return { nullptr, "" };
3067
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003068 FailedCond = Cond->IgnoreParenImpCasts();
Douglas Gregor672281a2017-09-14 23:38:42 +00003069 }
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003070
3071 std::string Description;
3072 {
3073 llvm::raw_string_ostream Out(Description);
Douglas Gregor672281a2017-09-14 23:38:42 +00003074 FailedCond->printPretty(Out, nullptr, getPrintingPolicy());
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003075 }
3076 return { FailedCond, Description };
3077}
3078
Douglas Gregordc572a32009-03-30 22:58:21 +00003079QualType Sema::CheckTemplateIdType(TemplateName Name,
3080 SourceLocation TemplateLoc,
Douglas Gregor739b107a2011-03-03 02:41:12 +00003081 TemplateArgumentListInfo &TemplateArgs) {
John McCalld9dfe3a2011-06-30 08:33:18 +00003082 DependentTemplateName *DTN
3083 = Name.getUnderlying().getAsDependentTemplateName();
Richard Smith3f1b5d02011-05-05 21:57:07 +00003084 if (DTN && DTN->isIdentifier())
3085 // When building a template-id where the template-name is dependent,
3086 // assume the template is a type template. Either our assumption is
3087 // correct, or the code is ill-formed and will be diagnosed when the
3088 // dependent name is substituted.
3089 return Context.getDependentTemplateSpecializationType(ETK_None,
3090 DTN->getQualifier(),
3091 DTN->getIdentifier(),
3092 TemplateArgs);
3093
Douglas Gregordc572a32009-03-30 22:58:21 +00003094 TemplateDecl *Template = Name.getAsTemplateDecl();
Richard Smith8f658062013-12-04 00:56:29 +00003095 if (!Template || isa<FunctionTemplateDecl>(Template) ||
Faisal Valia534f072018-04-26 00:42:40 +00003096 isa<VarTemplateDecl>(Template)) {
Douglas Gregor8b6070b2011-03-04 21:37:14 +00003097 // We might have a substituted template template parameter pack. If so,
3098 // build a template specialization type for it.
3099 if (Name.getAsSubstTemplateTemplateParmPack())
3100 return Context.getTemplateSpecializationType(Name, TemplateArgs);
Richard Smith3f1b5d02011-05-05 21:57:07 +00003101
Douglas Gregor8b6070b2011-03-04 21:37:14 +00003102 Diag(TemplateLoc, diag::err_template_id_not_a_type)
3103 << Name;
3104 NoteAllFoundTemplates(Name);
3105 return QualType();
Douglas Gregorb67535d2009-03-31 00:43:58 +00003106 }
Douglas Gregordc572a32009-03-30 22:58:21 +00003107
Douglas Gregorc40290e2009-03-09 23:48:35 +00003108 // Check that the template argument list is well-formed for this
3109 // template.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003110 SmallVector<TemplateArgument, 4> Converted;
John McCall6b51f282009-11-23 01:53:49 +00003111 if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
Richard Smith83b11aa2014-01-09 02:22:22 +00003112 false, Converted))
Douglas Gregorc40290e2009-03-09 23:48:35 +00003113 return QualType();
3114
Douglas Gregorc40290e2009-03-09 23:48:35 +00003115 QualType CanonType;
3116
Douglas Gregor678d76c2011-07-01 01:22:09 +00003117 bool InstantiationDependent = false;
Richard Smith83b11aa2014-01-09 02:22:22 +00003118 if (TypeAliasTemplateDecl *AliasTemplate =
3119 dyn_cast<TypeAliasTemplateDecl>(Template)) {
Richard Smith3f1b5d02011-05-05 21:57:07 +00003120 // Find the canonical type for this type alias template specialization.
3121 TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
3122 if (Pattern->isInvalidDecl())
3123 return QualType();
3124
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003125 TemplateArgumentList StackTemplateArgs(TemplateArgumentList::OnStack,
3126 Converted);
Richard Smith3f1b5d02011-05-05 21:57:07 +00003127
3128 // Only substitute for the innermost template argument list.
3129 MultiLevelTemplateArgumentList TemplateArgLists;
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003130 TemplateArgLists.addOuterTemplateArguments(&StackTemplateArgs);
Richard Smith5e96d832011-05-12 00:06:17 +00003131 unsigned Depth = AliasTemplate->getTemplateParameters()->getDepth();
3132 for (unsigned I = 0; I < Depth; ++I)
Richard Smith841d8b22013-05-17 03:04:50 +00003133 TemplateArgLists.addOuterTemplateArguments(None);
Richard Smith3f1b5d02011-05-05 21:57:07 +00003134
Richard Smith802c4b72012-08-23 06:16:52 +00003135 LocalInstantiationScope Scope(*this);
Richard Smith3f1b5d02011-05-05 21:57:07 +00003136 InstantiatingTemplate Inst(*this, TemplateLoc, Template);
Alp Tokerd4a72d52013-10-08 08:09:04 +00003137 if (Inst.isInvalid())
Richard Smith8a874c92012-07-08 02:38:24 +00003138 return QualType();
Richard Smith802c4b72012-08-23 06:16:52 +00003139
Richard Smith3f1b5d02011-05-05 21:57:07 +00003140 CanonType = SubstType(Pattern->getUnderlyingType(),
3141 TemplateArgLists, AliasTemplate->getLocation(),
3142 AliasTemplate->getDeclName());
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003143 if (CanonType.isNull()) {
3144 // If this was enable_if and we failed to find the nested type
3145 // within enable_if in a SFINAE context, dig out the specific
3146 // enable_if condition that failed and present that instead.
3147 if (isEnableIfAliasTemplate(AliasTemplate)) {
3148 if (auto DeductionInfo = isSFINAEContext()) {
3149 if (*DeductionInfo &&
3150 (*DeductionInfo)->hasSFINAEDiagnostic() &&
3151 (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
3152 diag::err_typename_nested_not_found_enable_if &&
3153 TemplateArgs[0].getArgument().getKind()
3154 == TemplateArgument::Expression) {
3155 Expr *FailedCond;
3156 std::string FailedDescription;
3157 std::tie(FailedCond, FailedDescription) =
Douglas Gregor672281a2017-09-14 23:38:42 +00003158 findFailedBooleanCondition(
3159 TemplateArgs[0].getSourceExpression(),
3160 /*AllowTopLevelCond=*/true);
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003161
3162 // Remove the old SFINAE diagnostic.
3163 PartialDiagnosticAt OldDiag =
3164 {SourceLocation(), PartialDiagnostic::NullDiagnostic()};
3165 (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);
3166
3167 // Add a new SFINAE diagnostic specifying which condition
3168 // failed.
3169 (*DeductionInfo)->addSFINAEDiagnostic(
3170 OldDiag.first,
3171 PDiag(diag::err_typename_nested_not_found_requirement)
3172 << FailedDescription
3173 << FailedCond->getSourceRange());
3174 }
3175 }
3176 }
3177
Richard Smith3f1b5d02011-05-05 21:57:07 +00003178 return QualType();
Douglas Gregor00fa10b2017-07-05 20:20:14 +00003179 }
Richard Smith3f1b5d02011-05-05 21:57:07 +00003180 } else if (Name.isDependent() ||
3181 TemplateSpecializationType::anyDependentTemplateArguments(
Douglas Gregor678d76c2011-07-01 01:22:09 +00003182 TemplateArgs, InstantiationDependent)) {
Douglas Gregorc40290e2009-03-09 23:48:35 +00003183 // This class template specialization is a dependent
3184 // type. Therefore, its canonical type is another class template
3185 // specialization type that contains all of the converted
3186 // arguments in canonical form. This ensures that, e.g., A<T> and
3187 // A<T, T> have identical types when A is declared as:
3188 //
3189 // template<typename T, typename U = T> struct A;
Vassil Vassilev2999d0e2017-01-10 09:09:09 +00003190 CanonType = Context.getCanonicalTemplateSpecializationType(Name, Converted);
John McCall2408e322010-04-27 00:57:59 +00003191
3192 // This might work out to be a current instantiation, in which
3193 // case the canonical type needs to be the InjectedClassNameType.
3194 //
3195 // TODO: in theory this could be a simple hashtable lookup; most
3196 // changes to CurContext don't change the set of current
3197 // instantiations.
3198 if (isa<ClassTemplateDecl>(Template)) {
3199 for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getLookupParent()) {
3200 // If we get out to a namespace, we're done.
3201 if (Ctx->isFileContext()) break;
3202
3203 // If this isn't a record, keep looking.
3204 CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx);
3205 if (!Record) continue;
3206
3207 // Look for one of the two cases with InjectedClassNameTypes
3208 // and check whether it's the same template.
3209 if (!isa<ClassTemplatePartialSpecializationDecl>(Record) &&
3210 !Record->getDescribedClassTemplate())
3211 continue;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00003212
John McCall2408e322010-04-27 00:57:59 +00003213 // Fetch the injected class name type and check whether its
3214 // injected type is equal to the type we just built.
3215 QualType ICNT = Context.getTypeDeclType(Record);
3216 QualType Injected = cast<InjectedClassNameType>(ICNT)
3217 ->getInjectedSpecializationType();
3218
3219 if (CanonType != Injected->getCanonicalTypeInternal())
3220 continue;
3221
3222 // If so, the canonical type of this TST is the injected
3223 // class name type of the record we just found.
3224 assert(ICNT.isCanonical());
3225 CanonType = ICNT;
John McCall2408e322010-04-27 00:57:59 +00003226 break;
3227 }
3228 }
Mike Stump11289f42009-09-09 15:08:12 +00003229 } else if (ClassTemplateDecl *ClassTemplate
Douglas Gregordc572a32009-03-30 22:58:21 +00003230 = dyn_cast<ClassTemplateDecl>(Template)) {
Douglas Gregorc40290e2009-03-09 23:48:35 +00003231 // Find the class template specialization declaration that
3232 // corresponds to these arguments.
Craig Topperc3ec1492014-05-26 06:22:03 +00003233 void *InsertPos = nullptr;
Douglas Gregorc40290e2009-03-09 23:48:35 +00003234 ClassTemplateSpecializationDecl *Decl
Craig Topper7e0daca2014-06-26 04:58:53 +00003235 = ClassTemplate->findSpecialization(Converted, InsertPos);
Douglas Gregorc40290e2009-03-09 23:48:35 +00003236 if (!Decl) {
3237 // This is the first time we have referenced this class template
3238 // specialization. Create the canonical declaration and add it to
3239 // the set of specializations.
Mike Stump11289f42009-09-09 15:08:12 +00003240 Decl = ClassTemplateSpecializationDecl::Create(Context,
Douglas Gregore9029562010-05-06 00:28:52 +00003241 ClassTemplate->getTemplatedDecl()->getTagKind(),
3242 ClassTemplate->getDeclContext(),
Abramo Bagnarafd3a4552011-10-03 20:34:03 +00003243 ClassTemplate->getTemplatedDecl()->getLocStart(),
Abramo Bagnara29c2d462011-03-09 14:09:51 +00003244 ClassTemplate->getLocation(),
Douglas Gregor1ccc8412010-11-07 23:05:16 +00003245 ClassTemplate,
David Majnemer8b622692016-07-03 21:17:51 +00003246 Converted, nullptr);
Argyrios Kyrtzidis47470f22010-07-20 13:59:28 +00003247 ClassTemplate->AddSpecialization(Decl, InsertPos);
Abramo Bagnara02b95532012-09-05 09:05:18 +00003248 if (ClassTemplate->isOutOfLine())
3249 Decl->setLexicalDeclContext(ClassTemplate->getLexicalDeclContext());
Douglas Gregorc40290e2009-03-09 23:48:35 +00003250 }
3251
Erich Keanea32910d2017-03-23 18:51:54 +00003252 if (Decl->getSpecializationKind() == TSK_Undeclared) {
3253 MultiLevelTemplateArgumentList TemplateArgLists;
3254 TemplateArgLists.addOuterTemplateArguments(Converted);
3255 InstantiateAttrsForDecl(TemplateArgLists, ClassTemplate->getTemplatedDecl(),
3256 Decl);
3257 }
3258
Chandler Carruth2acfb222013-09-27 22:14:40 +00003259 // Diagnose uses of this specialization.
3260 (void)DiagnoseUseOfDecl(Decl, TemplateLoc);
3261
Douglas Gregorc40290e2009-03-09 23:48:35 +00003262 CanonType = Context.getTypeDeclType(Decl);
John McCalle78aac42010-03-10 03:28:59 +00003263 assert(isa<RecordType>(CanonType) &&
3264 "type of non-dependent specialization is not a RecordType");
David Majnemerd9b1a4f2015-11-04 03:40:30 +00003265 } else if (auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
3266 CanonType = checkBuiltinTemplateIdType(*this, BTD, Converted, TemplateLoc,
3267 TemplateArgs);
Douglas Gregorc40290e2009-03-09 23:48:35 +00003268 }
Mike Stump11289f42009-09-09 15:08:12 +00003269
Douglas Gregorc40290e2009-03-09 23:48:35 +00003270 // Build the fully-sugared type for this class template
3271 // specialization, which refers back to the class template
3272 // specialization we created or found.
John McCall30576cd2010-06-13 09:25:03 +00003273 return Context.getTemplateSpecializationType(Name, TemplateArgs, CanonType);
Douglas Gregorc40290e2009-03-09 23:48:35 +00003274}
3275
John McCallfaf5fb42010-08-26 23:41:50 +00003276TypeResult
Abramo Bagnara48c05be2012-02-06 14:41:24 +00003277Sema::ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
Richard Smith74f02342017-01-19 21:00:13 +00003278 TemplateTy TemplateD, IdentifierInfo *TemplateII,
3279 SourceLocation TemplateIILoc,
Mike Stump11289f42009-09-09 15:08:12 +00003280 SourceLocation LAngleLoc,
Douglas Gregordc572a32009-03-30 22:58:21 +00003281 ASTTemplateArgsPtr TemplateArgsIn,
Abramo Bagnara4244b432012-01-27 08:46:19 +00003282 SourceLocation RAngleLoc,
Richard Smith62559bd2017-02-01 21:36:38 +00003283 bool IsCtorOrDtorName, bool IsClassName) {
Douglas Gregore7c20652011-03-02 00:47:37 +00003284 if (SS.isInvalid())
3285 return true;
3286
Richard Smith62559bd2017-02-01 21:36:38 +00003287 if (!IsCtorOrDtorName && !IsClassName && SS.isSet()) {
3288 DeclContext *LookupCtx = computeDeclContext(SS, /*EnteringContext*/false);
3289
3290 // C++ [temp.res]p3:
3291 // A qualified-id that refers to a type and in which the
3292 // nested-name-specifier depends on a template-parameter (14.6.2)
3293 // shall be prefixed by the keyword typename to indicate that the
3294 // qualified-id denotes a type, forming an
3295 // elaborated-type-specifier (7.1.5.3).
3296 if (!LookupCtx && isDependentScopeSpecifier(SS)) {
Richard Smith3411fbf2017-02-01 21:41:18 +00003297 Diag(SS.getBeginLoc(), diag::err_typename_missing_template)
Richard Smith62559bd2017-02-01 21:36:38 +00003298 << SS.getScopeRep() << TemplateII->getName();
3299 // Recover as if 'typename' were specified.
3300 // FIXME: This is not quite correct recovery as we don't transform SS
3301 // into the corresponding dependent form (and we don't diagnose missing
3302 // 'template' keywords within SS as a result).
3303 return ActOnTypenameType(nullptr, SourceLocation(), SS, TemplateKWLoc,
3304 TemplateD, TemplateII, TemplateIILoc, LAngleLoc,
3305 TemplateArgsIn, RAngleLoc);
3306 }
3307
3308 // Per C++ [class.qual]p2, if the template-id was an injected-class-name,
3309 // it's not actually allowed to be used as a type in most cases. Because
3310 // we annotate it before we know whether it's valid, we have to check for
3311 // this case here.
3312 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
Richard Smith74f02342017-01-19 21:00:13 +00003313 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
3314 Diag(TemplateIILoc,
3315 TemplateKWLoc.isInvalid()
3316 ? diag::err_out_of_line_qualified_id_type_names_constructor
3317 : diag::ext_out_of_line_qualified_id_type_names_constructor)
3318 << TemplateII << 0 /*injected-class-name used as template name*/
3319 << 1 /*if any keyword was present, it was 'template'*/;
3320 }
3321 }
3322
Serge Pavlov9ddb76e2013-08-27 13:15:56 +00003323 TemplateName Template = TemplateD.get();
Douglas Gregor8bf42052009-02-09 18:46:07 +00003324
Douglas Gregorc40290e2009-03-09 23:48:35 +00003325 // Translate the parser's template argument list in our AST format.
John McCall6b51f282009-11-23 01:53:49 +00003326 TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
Douglas Gregorb53edfb2009-11-10 19:49:08 +00003327 translateTemplateArguments(TemplateArgsIn, TemplateArgs);
Douglas Gregord32e0282009-02-09 23:23:08 +00003328
Douglas Gregor5a064722011-02-28 17:23:35 +00003329 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
Abramo Bagnara4244b432012-01-27 08:46:19 +00003330 QualType T
3331 = Context.getDependentTemplateSpecializationType(ETK_None,
3332 DTN->getQualifier(),
3333 DTN->getIdentifier(),
3334 TemplateArgs);
3335 // Build type-source information.
Douglas Gregor5a064722011-02-28 17:23:35 +00003336 TypeLocBuilder TLB;
3337 DependentTemplateSpecializationTypeLoc SpecTL
3338 = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
Abramo Bagnara48c05be2012-02-06 14:41:24 +00003339 SpecTL.setElaboratedKeywordLoc(SourceLocation());
3340 SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
Abramo Bagnarae0a70b22012-02-06 22:45:07 +00003341 SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
Richard Smith74f02342017-01-19 21:00:13 +00003342 SpecTL.setTemplateNameLoc(TemplateIILoc);
Douglas Gregor5a064722011-02-28 17:23:35 +00003343 SpecTL.setLAngleLoc(LAngleLoc);
3344 SpecTL.setRAngleLoc(RAngleLoc);
Douglas Gregor5a064722011-02-28 17:23:35 +00003345 for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
3346 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
3347 return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
3348 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00003349
Richard Smith74f02342017-01-19 21:00:13 +00003350 QualType Result = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
Douglas Gregorfe3d7d02009-04-01 21:51:26 +00003351 if (Result.isNull())
3352 return true;
3353
Douglas Gregore7c20652011-03-02 00:47:37 +00003354 // Build type-source information.
Abramo Bagnara48c05be2012-02-06 14:41:24 +00003355 TypeLocBuilder TLB;
Douglas Gregore7c20652011-03-02 00:47:37 +00003356 TemplateSpecializationTypeLoc SpecTL
3357 = TLB.push<TemplateSpecializationTypeLoc>(Result);
Abramo Bagnara48c05be2012-02-06 14:41:24 +00003358 SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
Richard Smith74f02342017-01-19 21:00:13 +00003359 SpecTL.setTemplateNameLoc(TemplateIILoc);
Douglas Gregore7c20652011-03-02 00:47:37 +00003360 SpecTL.setLAngleLoc(LAngleLoc);
3361 SpecTL.setRAngleLoc(RAngleLoc);
3362 for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
3363 SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
John McCall0ad16662009-10-29 08:12:44 +00003364
Abramo Bagnara4244b432012-01-27 08:46:19 +00003365 // NOTE: avoid constructing an ElaboratedTypeLoc if this is a
3366 // constructor or destructor name (in such a case, the scope specifier
3367 // will be attached to the enclosing Decl or Expr node).
3368 if (SS.isNotEmpty() && !IsCtorOrDtorName) {
Douglas Gregore7c20652011-03-02 00:47:37 +00003369 // Create an elaborated-type-specifier containing the nested-name-specifier.
3370 Result = Context.getElaboratedType(ETK_None, SS.getScopeRep(), Result);
3371 ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
Abramo Bagnara9033e2b2012-02-06 19:09:27 +00003372 ElabTL.setElaboratedKeywordLoc(SourceLocation());
Douglas Gregore7c20652011-03-02 00:47:37 +00003373 ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
3374 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00003375
Douglas Gregore7c20652011-03-02 00:47:37 +00003376 return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
John McCalld8fe9af2009-09-08 17:47:29 +00003377}
John McCall06f6fe8d2009-09-04 01:14:41 +00003378
Douglas Gregore7c20652011-03-02 00:47:37 +00003379TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK,
John McCallfaf5fb42010-08-26 23:41:50 +00003380 TypeSpecifierType TagSpec,
Douglas Gregore7c20652011-03-02 00:47:37 +00003381 SourceLocation TagLoc,
3382 CXXScopeSpec &SS,
Abramo Bagnara48c05be2012-02-06 14:41:24 +00003383 SourceLocation TemplateKWLoc,
3384 TemplateTy TemplateD,
Douglas Gregore7c20652011-03-02 00:47:37 +00003385 SourceLocation TemplateLoc,
3386 SourceLocation LAngleLoc,
3387 ASTTemplateArgsPtr TemplateArgsIn,
3388 SourceLocation RAngleLoc) {
Serge Pavlov9ddb76e2013-08-27 13:15:56 +00003389 TemplateName Template = TemplateD.get();
Simon Pilgrim6905d222016-12-30 22:55:33 +00003390
Douglas Gregore7c20652011-03-02 00:47:37 +00003391 // Translate the parser's template argument list in our AST format.
3392 TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
3393 translateTemplateArguments(TemplateArgsIn, TemplateArgs);
Simon Pilgrim6905d222016-12-30 22:55:33 +00003394
Douglas Gregore7c20652011-03-02 00:47:37 +00003395 // Determine the tag kind
Abramo Bagnara6150c882010-05-11 21:36:43 +00003396 TagTypeKind TagKind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
Douglas Gregore7c20652011-03-02 00:47:37 +00003397 ElaboratedTypeKeyword Keyword
3398 = TypeWithKeyword::getKeywordForTagTypeKind(TagKind);
Mike Stump11289f42009-09-09 15:08:12 +00003399
Douglas Gregore7c20652011-03-02 00:47:37 +00003400 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
3401 QualType T = Context.getDependentTemplateSpecializationType(Keyword,
Simon Pilgrim6905d222016-12-30 22:55:33 +00003402 DTN->getQualifier(),
3403 DTN->getIdentifier(),
Douglas Gregore7c20652011-03-02 00:47:37 +00003404 TemplateArgs);
Simon Pilgrim6905d222016-12-30 22:55:33 +00003405
3406 // Build type-source information.
Douglas Gregore7c20652011-03-02 00:47:37 +00003407 TypeLocBuilder TLB;
3408 DependentTemplateSpecializationTypeLoc SpecTL
Abramo Bagnara48c05be2012-02-06 14:41:24 +00003409 = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
3410 SpecTL.setElaboratedKeywordLoc(TagLoc);
3411 SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
Abramo Bagnarae0a70b22012-02-06 22:45:07 +00003412 SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
Abramo Bagnara48c05be2012-02-06 14:41:24 +00003413 SpecTL.setTemplateNameLoc(TemplateLoc);
Douglas Gregore7c20652011-03-02 00:47:37 +00003414 SpecTL.setLAngleLoc(LAngleLoc);
3415 SpecTL.setRAngleLoc(RAngleLoc);
Douglas Gregore7c20652011-03-02 00:47:37 +00003416 for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
3417 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
3418 return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
3419 }
Richard Smith3f1b5d02011-05-05 21:57:07 +00003420
3421 if (TypeAliasTemplateDecl *TAT =
3422 dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) {
3423 // C++0x [dcl.type.elab]p2:
3424 // If the identifier resolves to a typedef-name or the simple-template-id
3425 // resolves to an alias template specialization, the
3426 // elaborated-type-specifier is ill-formed.
Reid Kleckner1a4ab7e2016-12-09 19:47:58 +00003427 Diag(TemplateLoc, diag::err_tag_reference_non_tag)
3428 << TAT << NTK_TypeAliasTemplate << TagKind;
Richard Smith3f1b5d02011-05-05 21:57:07 +00003429 Diag(TAT->getLocation(), diag::note_declared_at);
3430 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00003431
Douglas Gregore7c20652011-03-02 00:47:37 +00003432 QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
3433 if (Result.isNull())
Matt Beaumont-Gay045bde42011-08-25 23:22:24 +00003434 return TypeResult(true);
Simon Pilgrim6905d222016-12-30 22:55:33 +00003435
Douglas Gregore7c20652011-03-02 00:47:37 +00003436 // Check the tag kind
3437 if (const RecordType *RT = Result->getAs<RecordType>()) {
John McCalld8fe9af2009-09-08 17:47:29 +00003438 RecordDecl *D = RT->getDecl();
Simon Pilgrim6905d222016-12-30 22:55:33 +00003439
John McCalld8fe9af2009-09-08 17:47:29 +00003440 IdentifierInfo *Id = D->getIdentifier();
3441 assert(Id && "templated class must have an identifier");
Simon Pilgrim6905d222016-12-30 22:55:33 +00003442
Richard Trieucaa33d32011-06-10 03:11:26 +00003443 if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition,
Justin Bognerc6ecb7c2015-07-10 23:05:47 +00003444 TagLoc, Id)) {
John McCalld8fe9af2009-09-08 17:47:29 +00003445 Diag(TagLoc, diag::err_use_with_wrong_tag)
Douglas Gregore7c20652011-03-02 00:47:37 +00003446 << Result
Douglas Gregora771f462010-03-31 17:46:05 +00003447 << FixItHint::CreateReplacement(SourceRange(TagLoc), D->getKindName());
John McCall7f41d982009-09-11 04:59:25 +00003448 Diag(D->getLocation(), diag::note_previous_use);
John McCall06f6fe8d2009-09-04 01:14:41 +00003449 }
3450 }
Abramo Bagnara48c05be2012-02-06 14:41:24 +00003451
Douglas Gregore7c20652011-03-02 00:47:37 +00003452 // Provide source-location information for the template specialization.
3453 TypeLocBuilder TLB;
3454 TemplateSpecializationTypeLoc SpecTL
3455 = TLB.push<TemplateSpecializationTypeLoc>(Result);
Abramo Bagnara48c05be2012-02-06 14:41:24 +00003456 SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
Douglas Gregore7c20652011-03-02 00:47:37 +00003457 SpecTL.setTemplateNameLoc(TemplateLoc);
3458 SpecTL.setLAngleLoc(LAngleLoc);
3459 SpecTL.setRAngleLoc(RAngleLoc);
3460 for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
3461 SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
John McCall06f6fe8d2009-09-04 01:14:41 +00003462
Douglas Gregore7c20652011-03-02 00:47:37 +00003463 // Construct an elaborated type containing the nested-name-specifier (if any)
Abramo Bagnara48c05be2012-02-06 14:41:24 +00003464 // and tag keyword.
Douglas Gregore7c20652011-03-02 00:47:37 +00003465 Result = Context.getElaboratedType(Keyword, SS.getScopeRep(), Result);
3466 ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
Abramo Bagnara9033e2b2012-02-06 19:09:27 +00003467 ElabTL.setElaboratedKeywordLoc(TagLoc);
Douglas Gregore7c20652011-03-02 00:47:37 +00003468 ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
3469 return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
Douglas Gregor8bf42052009-02-09 18:46:07 +00003470}
3471
Larisse Voufo39a1e502013-08-06 01:03:05 +00003472static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized,
3473 NamedDecl *PrevDecl,
3474 SourceLocation Loc,
3475 bool IsPartialSpecialization);
3476
3477static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003478
Richard Smith300e0c32013-09-24 04:49:23 +00003479static bool isTemplateArgumentTemplateParameter(
3480 const TemplateArgument &Arg, unsigned Depth, unsigned Index) {
3481 switch (Arg.getKind()) {
3482 case TemplateArgument::Null:
3483 case TemplateArgument::NullPtr:
3484 case TemplateArgument::Integral:
3485 case TemplateArgument::Declaration:
3486 case TemplateArgument::Pack:
3487 case TemplateArgument::TemplateExpansion:
3488 return false;
3489
3490 case TemplateArgument::Type: {
3491 QualType Type = Arg.getAsType();
3492 const TemplateTypeParmType *TPT =
3493 Arg.getAsType()->getAs<TemplateTypeParmType>();
3494 return TPT && !Type.hasQualifiers() &&
3495 TPT->getDepth() == Depth && TPT->getIndex() == Index;
3496 }
3497
3498 case TemplateArgument::Expression: {
3499 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg.getAsExpr());
3500 if (!DRE || !DRE->getDecl())
3501 return false;
3502 const NonTypeTemplateParmDecl *NTTP =
3503 dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
3504 return NTTP && NTTP->getDepth() == Depth && NTTP->getIndex() == Index;
3505 }
3506
3507 case TemplateArgument::Template:
3508 const TemplateTemplateParmDecl *TTP =
3509 dyn_cast_or_null<TemplateTemplateParmDecl>(
3510 Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl());
3511 return TTP && TTP->getDepth() == Depth && TTP->getIndex() == Index;
3512 }
3513 llvm_unreachable("unexpected kind of template argument");
3514}
3515
3516static bool isSameAsPrimaryTemplate(TemplateParameterList *Params,
3517 ArrayRef<TemplateArgument> Args) {
3518 if (Params->size() != Args.size())
3519 return false;
3520
3521 unsigned Depth = Params->getDepth();
3522
3523 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
3524 TemplateArgument Arg = Args[I];
3525
3526 // If the parameter is a pack expansion, the argument must be a pack
3527 // whose only element is a pack expansion.
3528 if (Params->getParam(I)->isParameterPack()) {
3529 if (Arg.getKind() != TemplateArgument::Pack || Arg.pack_size() != 1 ||
3530 !Arg.pack_begin()->isPackExpansion())
3531 return false;
3532 Arg = Arg.pack_begin()->getPackExpansionPattern();
3533 }
3534
3535 if (!isTemplateArgumentTemplateParameter(Arg, Depth, I))
3536 return false;
3537 }
3538
3539 return true;
3540}
3541
Richard Smith4b55a9c2014-04-17 03:29:33 +00003542/// Convert the parser's template argument list representation into our form.
3543static TemplateArgumentListInfo
3544makeTemplateArgumentListInfo(Sema &S, TemplateIdAnnotation &TemplateId) {
3545 TemplateArgumentListInfo TemplateArgs(TemplateId.LAngleLoc,
3546 TemplateId.RAngleLoc);
3547 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId.getTemplateArgs(),
3548 TemplateId.NumArgs);
3549 S.translateTemplateArguments(TemplateArgsPtr, TemplateArgs);
3550 return TemplateArgs;
3551}
3552
Richard Smith0e617ec2016-12-27 07:56:27 +00003553template<typename PartialSpecDecl>
3554static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial) {
3555 if (Partial->getDeclContext()->isDependentContext())
3556 return;
3557
3558 // FIXME: Get the TDK from deduction in order to provide better diagnostics
3559 // for non-substitution-failure issues?
3560 TemplateDeductionInfo Info(Partial->getLocation());
3561 if (S.isMoreSpecializedThanPrimary(Partial, Info))
3562 return;
3563
3564 auto *Template = Partial->getSpecializedTemplate();
3565 S.Diag(Partial->getLocation(),
Richard Smithfa4a09d2016-12-27 20:03:09 +00003566 diag::ext_partial_spec_not_more_specialized_than_primary)
3567 << isa<VarTemplateDecl>(Template);
Richard Smith0e617ec2016-12-27 07:56:27 +00003568
3569 if (Info.hasSFINAEDiagnostic()) {
3570 PartialDiagnosticAt Diag = {SourceLocation(),
3571 PartialDiagnostic::NullDiagnostic()};
3572 Info.takeSFINAEDiagnostic(Diag);
3573 SmallString<128> SFINAEArgString;
3574 Diag.second.EmitToString(S.getDiagnostics(), SFINAEArgString);
3575 S.Diag(Diag.first,
3576 diag::note_partial_spec_not_more_specialized_than_primary)
3577 << SFINAEArgString;
3578 }
3579
3580 S.Diag(Template->getLocation(), diag::note_template_decl_here);
3581}
3582
Richard Smith4e05eaa2017-02-16 00:36:47 +00003583static void
3584noteNonDeducibleParameters(Sema &S, TemplateParameterList *TemplateParams,
3585 const llvm::SmallBitVector &DeducibleParams) {
3586 for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
3587 if (!DeducibleParams[I]) {
George Burgess IV00f70bd2018-03-01 05:43:23 +00003588 NamedDecl *Param = TemplateParams->getParam(I);
Richard Smith4e05eaa2017-02-16 00:36:47 +00003589 if (Param->getDeclName())
3590 S.Diag(Param->getLocation(), diag::note_non_deducible_parameter)
3591 << Param->getDeclName();
3592 else
3593 S.Diag(Param->getLocation(), diag::note_non_deducible_parameter)
3594 << "(anonymous)";
3595 }
3596 }
3597}
3598
3599
Richard Smith57aae072016-12-28 02:37:25 +00003600template<typename PartialSpecDecl>
3601static void checkTemplatePartialSpecialization(Sema &S,
3602 PartialSpecDecl *Partial) {
3603 // C++1z [temp.class.spec]p8: (DR1495)
3604 // - The specialization shall be more specialized than the primary
3605 // template (14.5.5.2).
3606 checkMoreSpecializedThanPrimary(S, Partial);
3607
3608 // C++ [temp.class.spec]p8: (DR1315)
3609 // - Each template-parameter shall appear at least once in the
3610 // template-id outside a non-deduced context.
3611 // C++1z [temp.class.spec.match]p3 (P0127R2)
3612 // If the template arguments of a partial specialization cannot be
3613 // deduced because of the structure of its template-parameter-list
3614 // and the template-id, the program is ill-formed.
3615 auto *TemplateParams = Partial->getTemplateParameters();
3616 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
3617 S.MarkUsedTemplateParameters(Partial->getTemplateArgs(), true,
3618 TemplateParams->getDepth(), DeducibleParams);
3619
3620 if (!DeducibleParams.all()) {
3621 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
3622 S.Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
3623 << isa<VarTemplatePartialSpecializationDecl>(Partial)
3624 << (NumNonDeducible > 1)
3625 << SourceRange(Partial->getLocation(),
3626 Partial->getTemplateArgsAsWritten()->RAngleLoc);
Richard Smith4e05eaa2017-02-16 00:36:47 +00003627 noteNonDeducibleParameters(S, TemplateParams, DeducibleParams);
Richard Smith57aae072016-12-28 02:37:25 +00003628 }
3629}
3630
3631void Sema::CheckTemplatePartialSpecialization(
3632 ClassTemplatePartialSpecializationDecl *Partial) {
3633 checkTemplatePartialSpecialization(*this, Partial);
3634}
3635
3636void Sema::CheckTemplatePartialSpecialization(
3637 VarTemplatePartialSpecializationDecl *Partial) {
3638 checkTemplatePartialSpecialization(*this, Partial);
3639}
3640
Richard Smith4e05eaa2017-02-16 00:36:47 +00003641void Sema::CheckDeductionGuideTemplate(FunctionTemplateDecl *TD) {
3642 // C++1z [temp.param]p11:
3643 // A template parameter of a deduction guide template that does not have a
3644 // default-argument shall be deducible from the parameter-type-list of the
3645 // deduction guide template.
3646 auto *TemplateParams = TD->getTemplateParameters();
3647 llvm::SmallBitVector DeducibleParams(TemplateParams->size());
3648 MarkDeducedTemplateParameters(TD, DeducibleParams);
3649 for (unsigned I = 0; I != TemplateParams->size(); ++I) {
3650 // A parameter pack is deducible (to an empty pack).
3651 auto *Param = TemplateParams->getParam(I);
3652 if (Param->isParameterPack() || hasVisibleDefaultArgument(Param))
3653 DeducibleParams[I] = true;
3654 }
3655
3656 if (!DeducibleParams.all()) {
3657 unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
3658 Diag(TD->getLocation(), diag::err_deduction_guide_template_not_deducible)
3659 << (NumNonDeducible > 1);
3660 noteNonDeducibleParameters(*this, TemplateParams, DeducibleParams);
3661 }
3662}
3663
Larisse Voufo39a1e502013-08-06 01:03:05 +00003664DeclResult Sema::ActOnVarTemplateSpecialization(
Richard Smithbeef3452014-01-16 23:39:20 +00003665 Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc,
Craig Topperc79e5e32014-10-31 06:57:13 +00003666 TemplateParameterList *TemplateParams, StorageClass SC,
Richard Smithbeef3452014-01-16 23:39:20 +00003667 bool IsPartialSpecialization) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00003668 // D must be variable template id.
Faisal Vali2ab8c152017-12-30 04:15:27 +00003669 assert(D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId &&
Larisse Voufo39a1e502013-08-06 01:03:05 +00003670 "Variable template specialization is declared with a template it.");
3671
3672 TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
Richard Smith4b55a9c2014-04-17 03:29:33 +00003673 TemplateArgumentListInfo TemplateArgs =
3674 makeTemplateArgumentListInfo(*this, *TemplateId);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003675 SourceLocation TemplateNameLoc = D.getIdentifierLoc();
3676 SourceLocation LAngleLoc = TemplateId->LAngleLoc;
3677 SourceLocation RAngleLoc = TemplateId->RAngleLoc;
Richard Smith4b55a9c2014-04-17 03:29:33 +00003678
Richard Smithbeef3452014-01-16 23:39:20 +00003679 TemplateName Name = TemplateId->Template.get();
3680
3681 // The template-id must name a variable template.
3682 VarTemplateDecl *VarTemplate =
Karthik Bhat967c13d2014-05-08 13:16:20 +00003683 dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());
3684 if (!VarTemplate) {
3685 NamedDecl *FnTemplate;
3686 if (auto *OTS = Name.getAsOverloadedTemplate())
3687 FnTemplate = *OTS->begin();
3688 else
3689 FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());
3690 if (FnTemplate)
3691 return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template_but_method)
3692 << FnTemplate->getDeclName();
Richard Smithbeef3452014-01-16 23:39:20 +00003693 return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template)
3694 << IsPartialSpecialization;
Karthik Bhat967c13d2014-05-08 13:16:20 +00003695 }
Larisse Voufo39a1e502013-08-06 01:03:05 +00003696
3697 // Check for unexpanded parameter packs in any of the template arguments.
3698 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
3699 if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
3700 UPPC_PartialSpecialization))
3701 return true;
3702
3703 // Check that the template argument list is well-formed for this
3704 // template.
3705 SmallVector<TemplateArgument, 4> Converted;
3706 if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
3707 false, Converted))
3708 return true;
3709
Larisse Voufo39a1e502013-08-06 01:03:05 +00003710 // Find the variable template (partial) specialization declaration that
3711 // corresponds to these arguments.
3712 if (IsPartialSpecialization) {
Richard Smith57aae072016-12-28 02:37:25 +00003713 if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, VarTemplate,
3714 TemplateArgs.size(), Converted))
Larisse Voufo39a1e502013-08-06 01:03:05 +00003715 return true;
3716
Richard Smith57aae072016-12-28 02:37:25 +00003717 // FIXME: Move these checks to CheckTemplatePartialSpecializationArgs so we
3718 // also do them during instantiation.
Larisse Voufo39a1e502013-08-06 01:03:05 +00003719 bool InstantiationDependent;
3720 if (!Name.isDependent() &&
3721 !TemplateSpecializationType::anyDependentTemplateArguments(
David Majnemer6fbeee32016-07-07 04:43:07 +00003722 TemplateArgs.arguments(),
Larisse Voufo39a1e502013-08-06 01:03:05 +00003723 InstantiationDependent)) {
3724 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
3725 << VarTemplate->getDeclName();
3726 IsPartialSpecialization = false;
3727 }
Richard Smith300e0c32013-09-24 04:49:23 +00003728
3729 if (isSameAsPrimaryTemplate(VarTemplate->getTemplateParameters(),
3730 Converted)) {
3731 // C++ [temp.class.spec]p9b3:
3732 //
3733 // -- The argument list of the specialization shall not be identical
3734 // to the implicit argument list of the primary template.
3735 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
3736 << /*variable template*/ 1
3737 << /*is definition*/(SC != SC_Extern && !CurContext->isRecord())
3738 << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
3739 // FIXME: Recover from this by treating the declaration as a redeclaration
3740 // of the primary template.
3741 return true;
3742 }
Larisse Voufo39a1e502013-08-06 01:03:05 +00003743 }
3744
Craig Topperc3ec1492014-05-26 06:22:03 +00003745 void *InsertPos = nullptr;
3746 VarTemplateSpecializationDecl *PrevDecl = nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003747
3748 if (IsPartialSpecialization)
3749 // FIXME: Template parameter list matters too
Craig Topper7e0daca2014-06-26 04:58:53 +00003750 PrevDecl = VarTemplate->findPartialSpecialization(Converted, InsertPos);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003751 else
Craig Topper7e0daca2014-06-26 04:58:53 +00003752 PrevDecl = VarTemplate->findSpecialization(Converted, InsertPos);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003753
Craig Topperc3ec1492014-05-26 06:22:03 +00003754 VarTemplateSpecializationDecl *Specialization = nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003755
3756 // Check whether we can declare a variable template specialization in
3757 // the current scope.
3758 if (CheckTemplateSpecializationScope(*this, VarTemplate, PrevDecl,
3759 TemplateNameLoc,
3760 IsPartialSpecialization))
3761 return true;
3762
3763 if (PrevDecl && PrevDecl->getSpecializationKind() == TSK_Undeclared) {
3764 // Since the only prior variable template specialization with these
3765 // arguments was referenced but not declared, reuse that
3766 // declaration node as our own, updating its source location and
3767 // the list of outer template parameters to reflect our new declaration.
3768 Specialization = PrevDecl;
3769 Specialization->setLocation(TemplateNameLoc);
Craig Topperc3ec1492014-05-26 06:22:03 +00003770 PrevDecl = nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003771 } else if (IsPartialSpecialization) {
3772 // Create a new class template partial specialization declaration node.
3773 VarTemplatePartialSpecializationDecl *PrevPartial =
3774 cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003775 VarTemplatePartialSpecializationDecl *Partial =
3776 VarTemplatePartialSpecializationDecl::Create(
3777 Context, VarTemplate->getDeclContext(), TemplateKWLoc,
3778 TemplateNameLoc, TemplateParams, VarTemplate, DI->getType(), DI, SC,
David Majnemer8b622692016-07-03 21:17:51 +00003779 Converted, TemplateArgs);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003780
3781 if (!PrevPartial)
3782 VarTemplate->AddPartialSpecialization(Partial, InsertPos);
3783 Specialization = Partial;
3784
3785 // If we are providing an explicit specialization of a member variable
3786 // template specialization, make a note of that.
3787 if (PrevPartial && PrevPartial->getInstantiatedFromMember())
Larisse Voufo4cda4612013-08-22 00:28:27 +00003788 PrevPartial->setMemberSpecialization();
Larisse Voufo39a1e502013-08-06 01:03:05 +00003789
Richard Smith57aae072016-12-28 02:37:25 +00003790 CheckTemplatePartialSpecialization(Partial);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003791 } else {
3792 // Create a new class template specialization declaration node for
3793 // this explicit specialization or friend declaration.
3794 Specialization = VarTemplateSpecializationDecl::Create(
3795 Context, VarTemplate->getDeclContext(), TemplateKWLoc, TemplateNameLoc,
David Majnemer8b622692016-07-03 21:17:51 +00003796 VarTemplate, DI->getType(), DI, SC, Converted);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003797 Specialization->setTemplateArgsInfo(TemplateArgs);
3798
3799 if (!PrevDecl)
3800 VarTemplate->AddSpecialization(Specialization, InsertPos);
3801 }
3802
3803 // C++ [temp.expl.spec]p6:
3804 // If a template, a member template or the member of a class template is
3805 // explicitly specialized then that specialization shall be declared
3806 // before the first use of that specialization that would cause an implicit
3807 // instantiation to take place, in every translation unit in which such a
3808 // use occurs; no diagnostic is required.
3809 if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
3810 bool Okay = false;
3811 for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
3812 // Is there any previous explicit specialization declaration?
3813 if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
3814 Okay = true;
3815 break;
3816 }
3817 }
3818
3819 if (!Okay) {
3820 SourceRange Range(TemplateNameLoc, RAngleLoc);
3821 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
3822 << Name << Range;
3823
3824 Diag(PrevDecl->getPointOfInstantiation(),
3825 diag::note_instantiation_required_here)
3826 << (PrevDecl->getTemplateSpecializationKind() !=
3827 TSK_ImplicitInstantiation);
3828 return true;
3829 }
3830 }
3831
3832 Specialization->setTemplateKeywordLoc(TemplateKWLoc);
3833 Specialization->setLexicalDeclContext(CurContext);
3834
3835 // Add the specialization into its lexical context, so that it can
3836 // be seen when iterating through the list of declarations in that
3837 // context. However, specializations are not found by name lookup.
3838 CurContext->addDecl(Specialization);
3839
3840 // Note that this is an explicit specialization.
3841 Specialization->setSpecializationKind(TSK_ExplicitSpecialization);
3842
3843 if (PrevDecl) {
3844 // Check that this isn't a redefinition of this specialization,
3845 // merging with previous declarations.
3846 LookupResult PrevSpec(*this, GetNameForDeclarator(D), LookupOrdinaryName,
Richard Smithbecb92d2017-10-10 22:33:17 +00003847 forRedeclarationInCurContext());
Larisse Voufo39a1e502013-08-06 01:03:05 +00003848 PrevSpec.addDecl(PrevDecl);
3849 D.setRedeclaration(CheckVariableDeclaration(Specialization, PrevSpec));
Larisse Voufo4cda4612013-08-22 00:28:27 +00003850 } else if (Specialization->isStaticDataMember() &&
3851 Specialization->isOutOfLine()) {
3852 Specialization->setAccess(VarTemplate->getAccess());
Larisse Voufo39a1e502013-08-06 01:03:05 +00003853 }
3854
3855 // Link instantiations of static data members back to the template from
3856 // which they were instantiated.
3857 if (Specialization->isStaticDataMember())
3858 Specialization->setInstantiationOfStaticDataMember(
3859 VarTemplate->getTemplatedDecl(),
3860 Specialization->getSpecializationKind());
3861
3862 return Specialization;
3863}
3864
3865namespace {
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00003866/// A partial specialization whose template arguments have matched
Larisse Voufo39a1e502013-08-06 01:03:05 +00003867/// a given template-id.
3868struct PartialSpecMatchResult {
3869 VarTemplatePartialSpecializationDecl *Partial;
3870 TemplateArgumentList *Args;
3871};
Eugene Zelenko1ced5092016-02-12 22:53:10 +00003872} // end anonymous namespace
Larisse Voufo39a1e502013-08-06 01:03:05 +00003873
3874DeclResult
3875Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc,
3876 SourceLocation TemplateNameLoc,
3877 const TemplateArgumentListInfo &TemplateArgs) {
3878 assert(Template && "A variable template id without template?");
3879
3880 // Check that the template argument list is well-formed for this template.
3881 SmallVector<TemplateArgument, 4> Converted;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003882 if (CheckTemplateArgumentList(
3883 Template, TemplateNameLoc,
3884 const_cast<TemplateArgumentListInfo &>(TemplateArgs), false,
Richard Smith83b11aa2014-01-09 02:22:22 +00003885 Converted))
Larisse Voufo39a1e502013-08-06 01:03:05 +00003886 return true;
3887
3888 // Find the variable template specialization declaration that
3889 // corresponds to these arguments.
Craig Topperc3ec1492014-05-26 06:22:03 +00003890 void *InsertPos = nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00003891 if (VarTemplateSpecializationDecl *Spec = Template->findSpecialization(
Richard Smith6739a102016-05-05 00:56:12 +00003892 Converted, InsertPos)) {
3893 checkSpecializationVisibility(TemplateNameLoc, Spec);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003894 // If we already have a variable template specialization, return it.
3895 return Spec;
Richard Smith6739a102016-05-05 00:56:12 +00003896 }
Larisse Voufo39a1e502013-08-06 01:03:05 +00003897
3898 // This is the first time we have referenced this variable template
3899 // specialization. Create the canonical declaration and add it to
3900 // the set of specializations, based on the closest partial specialization
3901 // that it represents. That is,
3902 VarDecl *InstantiationPattern = Template->getTemplatedDecl();
3903 TemplateArgumentList TemplateArgList(TemplateArgumentList::OnStack,
David Majnemer8b622692016-07-03 21:17:51 +00003904 Converted);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003905 TemplateArgumentList *InstantiationArgs = &TemplateArgList;
3906 bool AmbiguousPartialSpec = false;
3907 typedef PartialSpecMatchResult MatchResult;
3908 SmallVector<MatchResult, 4> Matched;
3909 SourceLocation PointOfInstantiation = TemplateNameLoc;
George Burgess IV3e3bb95b2015-12-02 21:58:08 +00003910 TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation,
3911 /*ForTakingAddress=*/false);
Larisse Voufo39a1e502013-08-06 01:03:05 +00003912
3913 // 1. Attempt to find the closest partial specialization that this
3914 // specializes, if any.
3915 // If any of the template arguments is dependent, then this is probably
3916 // a placeholder for an incomplete declarative context; which must be
3917 // complete by instantiation time. Thus, do not search through the partial
3918 // specializations yet.
Larisse Voufo30616382013-08-23 22:21:36 +00003919 // TODO: Unify with InstantiateClassTemplateSpecialization()?
3920 // Perhaps better after unification of DeduceTemplateArguments() and
3921 // getMoreSpecializedPartialSpecialization().
Larisse Voufo39a1e502013-08-06 01:03:05 +00003922 bool InstantiationDependent = false;
3923 if (!TemplateSpecializationType::anyDependentTemplateArguments(
3924 TemplateArgs, InstantiationDependent)) {
3925
3926 SmallVector<VarTemplatePartialSpecializationDecl *, 4> PartialSpecs;
3927 Template->getPartialSpecializations(PartialSpecs);
3928
3929 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
3930 VarTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
3931 TemplateDeductionInfo Info(FailedCandidates.getLocation());
3932
3933 if (TemplateDeductionResult Result =
3934 DeduceTemplateArguments(Partial, TemplateArgList, Info)) {
3935 // Store the failed-deduction information for use in diagnostics, later.
Larisse Voufo30616382013-08-23 22:21:36 +00003936 // TODO: Actually use the failed-deduction info?
Richard Smithc2bebe92016-05-11 20:37:46 +00003937 FailedCandidates.addCandidate().set(
3938 DeclAccessPair::make(Template, AS_public), Partial,
3939 MakeDeductionFailureInfo(Context, Result, Info));
Larisse Voufo39a1e502013-08-06 01:03:05 +00003940 (void)Result;
3941 } else {
3942 Matched.push_back(PartialSpecMatchResult());
3943 Matched.back().Partial = Partial;
3944 Matched.back().Args = Info.take();
3945 }
3946 }
3947
Larisse Voufo39a1e502013-08-06 01:03:05 +00003948 if (Matched.size() >= 1) {
3949 SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
3950 if (Matched.size() == 1) {
3951 // -- If exactly one matching specialization is found, the
3952 // instantiation is generated from that specialization.
3953 // We don't need to do anything for this.
3954 } else {
3955 // -- If more than one matching specialization is found, the
3956 // partial order rules (14.5.4.2) are used to determine
3957 // whether one of the specializations is more specialized
3958 // than the others. If none of the specializations is more
3959 // specialized than all of the other matching
3960 // specializations, then the use of the variable template is
3961 // ambiguous and the program is ill-formed.
3962 for (SmallVector<MatchResult, 4>::iterator P = Best + 1,
3963 PEnd = Matched.end();
3964 P != PEnd; ++P) {
3965 if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
3966 PointOfInstantiation) ==
3967 P->Partial)
3968 Best = P;
3969 }
3970
3971 // Determine if the best partial specialization is more specialized than
3972 // the others.
3973 for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
3974 PEnd = Matched.end();
3975 P != PEnd; ++P) {
3976 if (P != Best && getMoreSpecializedPartialSpecialization(
3977 P->Partial, Best->Partial,
3978 PointOfInstantiation) != Best->Partial) {
3979 AmbiguousPartialSpec = true;
3980 break;
3981 }
3982 }
3983 }
3984
3985 // Instantiate using the best variable template partial specialization.
3986 InstantiationPattern = Best->Partial;
3987 InstantiationArgs = Best->Args;
3988 } else {
3989 // -- If no match is found, the instantiation is generated
3990 // from the primary template.
3991 // InstantiationPattern = Template->getTemplatedDecl();
3992 }
3993 }
3994
Larisse Voufo39a1e502013-08-06 01:03:05 +00003995 // 2. Create the canonical declaration.
Richard Smith6739a102016-05-05 00:56:12 +00003996 // Note that we do not instantiate a definition until we see an odr-use
3997 // in DoMarkVarDeclReferenced().
Larisse Voufo39a1e502013-08-06 01:03:05 +00003998 // FIXME: LateAttrs et al.?
3999 VarTemplateSpecializationDecl *Decl = BuildVarTemplateInstantiation(
4000 Template, InstantiationPattern, *InstantiationArgs, TemplateArgs,
4001 Converted, TemplateNameLoc, InsertPos /*, LateAttrs, StartingScope*/);
4002 if (!Decl)
4003 return true;
4004
4005 if (AmbiguousPartialSpec) {
4006 // Partial ordering did not produce a clear winner. Complain.
4007 Decl->setInvalidDecl();
4008 Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
4009 << Decl;
4010
4011 // Print the matching partial specializations.
Yaron Keren1cb81462016-11-16 13:45:34 +00004012 for (MatchResult P : Matched)
4013 Diag(P.Partial->getLocation(), diag::note_partial_spec_match)
4014 << getTemplateArgumentBindingsText(P.Partial->getTemplateParameters(),
4015 *P.Args);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004016 return true;
4017 }
4018
4019 if (VarTemplatePartialSpecializationDecl *D =
4020 dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
4021 Decl->setInstantiationOf(D, InstantiationArgs);
4022
Richard Smith6739a102016-05-05 00:56:12 +00004023 checkSpecializationVisibility(TemplateNameLoc, Decl);
4024
Larisse Voufo39a1e502013-08-06 01:03:05 +00004025 assert(Decl && "No variable template specialization?");
4026 return Decl;
4027}
4028
4029ExprResult
4030Sema::CheckVarTemplateId(const CXXScopeSpec &SS,
4031 const DeclarationNameInfo &NameInfo,
4032 VarTemplateDecl *Template, SourceLocation TemplateLoc,
4033 const TemplateArgumentListInfo *TemplateArgs) {
4034
4035 DeclResult Decl = CheckVarTemplateId(Template, TemplateLoc, NameInfo.getLoc(),
4036 *TemplateArgs);
4037 if (Decl.isInvalid())
4038 return ExprError();
4039
4040 VarDecl *Var = cast<VarDecl>(Decl.get());
4041 if (!Var->getTemplateSpecializationKind())
4042 Var->setTemplateSpecializationKind(TSK_ImplicitInstantiation,
4043 NameInfo.getLoc());
4044
4045 // Build an ordinary singleton decl ref.
4046 return BuildDeclarationNameExpr(SS, NameInfo, Var,
Craig Topperc3ec1492014-05-26 06:22:03 +00004047 /*FoundD=*/nullptr, TemplateArgs);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004048}
4049
Richard Smithecad88d2018-04-26 01:08:00 +00004050void Sema::diagnoseMissingTemplateArguments(TemplateName Name,
4051 SourceLocation Loc) {
4052 Diag(Loc, diag::err_template_missing_args)
4053 << (int)getTemplateNameKindForDiagnostics(Name) << Name;
4054 if (TemplateDecl *TD = Name.getAsTemplateDecl()) {
4055 Diag(TD->getLocation(), diag::note_template_decl_here)
4056 << TD->getTemplateParameters()->getSourceRange();
4057 }
4058}
4059
John McCalldadc5752010-08-24 06:29:42 +00004060ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
Abramo Bagnara7945c982012-01-27 09:46:47 +00004061 SourceLocation TemplateKWLoc,
Douglas Gregor0da1d432011-02-28 20:01:57 +00004062 LookupResult &R,
4063 bool RequiresADL,
Abramo Bagnara65f7c3d2012-02-06 14:31:00 +00004064 const TemplateArgumentListInfo *TemplateArgs) {
Douglas Gregora727cb92009-06-30 22:34:41 +00004065 // FIXME: Can we do any checking at this point? I guess we could check the
4066 // template arguments that we have against the template name, if the template
Mike Stump11289f42009-09-09 15:08:12 +00004067 // name refers to a single template. That's not a terribly common case,
Douglas Gregora727cb92009-06-30 22:34:41 +00004068 // though.
Douglas Gregorb491ed32011-02-19 21:32:49 +00004069 // foo<int> could identify a single function unambiguously
4070 // This approach does NOT work, since f<int>(1);
4071 // gets resolved prior to resorting to overload resolution
4072 // i.e., template<class T> void f(double);
4073 // vs template<class T, class U> void f(U);
John McCalle66edc12009-11-24 19:00:30 +00004074
4075 // These should be filtered out by our callers.
4076 assert(!R.empty() && "empty lookup results when building templateid");
4077 assert(!R.isAmbiguous() && "ambiguous lookup when building templateid");
4078
Richard Smith04100942018-04-26 02:10:22 +00004079 // Non-function templates require a template argument list.
4080 if (auto *TD = R.getAsSingle<TemplateDecl>()) {
4081 if (!TemplateArgs && !isa<FunctionTemplateDecl>(TD)) {
4082 diagnoseMissingTemplateArguments(TemplateName(TD), R.getNameLoc());
4083 return ExprError();
4084 }
4085 }
4086
Richard Smith0bf96f92018-04-25 22:58:55 +00004087 auto AnyDependentArguments = [&]() -> bool {
4088 bool InstantiationDependent;
4089 return TemplateArgs &&
4090 TemplateSpecializationType::anyDependentTemplateArguments(
4091 *TemplateArgs, InstantiationDependent);
4092 };
4093
Larisse Voufo39a1e502013-08-06 01:03:05 +00004094 // In C++1y, check variable template ids.
Richard Smith0bf96f92018-04-25 22:58:55 +00004095 if (R.getAsSingle<VarTemplateDecl>() && !AnyDependentArguments()) {
Richard Smithd7d11ef2014-02-03 20:09:56 +00004096 return CheckVarTemplateId(SS, R.getLookupNameInfo(),
4097 R.getAsSingle<VarTemplateDecl>(),
4098 TemplateKWLoc, TemplateArgs);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004099 }
4100
John McCall58cc69d2010-01-27 01:50:18 +00004101 // We don't want lookup warnings at this point.
4102 R.suppressDiagnostics();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004103
John McCalle66edc12009-11-24 19:00:30 +00004104 UnresolvedLookupExpr *ULE
Douglas Gregora6e053e2010-12-15 01:34:56 +00004105 = UnresolvedLookupExpr::Create(Context, R.getNamingClass(),
Douglas Gregor0da1d432011-02-28 20:01:57 +00004106 SS.getWithLocInContext(Context),
Abramo Bagnara7945c982012-01-27 09:46:47 +00004107 TemplateKWLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004108 R.getLookupNameInfo(),
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004109 RequiresADL, TemplateArgs,
Douglas Gregor30a4f4c2010-05-23 18:57:34 +00004110 R.begin(), R.end());
John McCalle66edc12009-11-24 19:00:30 +00004111
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00004112 return ULE;
Douglas Gregora727cb92009-06-30 22:34:41 +00004113}
4114
John McCalle66edc12009-11-24 19:00:30 +00004115// We actually only call this from template instantiation.
John McCalldadc5752010-08-24 06:29:42 +00004116ExprResult
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00004117Sema::BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,
Abramo Bagnara7945c982012-01-27 09:46:47 +00004118 SourceLocation TemplateKWLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004119 const DeclarationNameInfo &NameInfo,
Abramo Bagnara65f7c3d2012-02-06 14:31:00 +00004120 const TemplateArgumentListInfo *TemplateArgs) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00004121
Abramo Bagnara65f7c3d2012-02-06 14:31:00 +00004122 assert(TemplateArgs || TemplateKWLoc.isValid());
John McCalle66edc12009-11-24 19:00:30 +00004123 DeclContext *DC;
4124 if (!(DC = computeDeclContext(SS, false)) ||
4125 DC->isDependentContext() ||
John McCall0b66eb32010-05-01 00:40:08 +00004126 RequireCompleteDeclContext(SS, DC))
Reid Kleckner034531d2014-12-18 18:17:42 +00004127 return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
Mike Stump11289f42009-09-09 15:08:12 +00004128
Douglas Gregor786123d2010-05-21 23:18:07 +00004129 bool MemberOfUnknownSpecialization;
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004130 LookupResult R(*this, NameInfo, LookupOrdinaryName);
Richard Smith79810042018-05-11 02:43:08 +00004131 if (LookupTemplateName(R, (Scope *)nullptr, SS, QualType(),
4132 /*Entering*/false, MemberOfUnknownSpecialization,
4133 TemplateKWLoc))
4134 return ExprError();
Mike Stump11289f42009-09-09 15:08:12 +00004135
John McCalle66edc12009-11-24 19:00:30 +00004136 if (R.isAmbiguous())
4137 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004138
John McCalle66edc12009-11-24 19:00:30 +00004139 if (R.empty()) {
Richard Smith79810042018-05-11 02:43:08 +00004140 Diag(NameInfo.getLoc(), diag::err_no_member)
4141 << NameInfo.getName() << DC << SS.getRange();
John McCalle66edc12009-11-24 19:00:30 +00004142 return ExprError();
4143 }
4144
4145 if (ClassTemplateDecl *Temp = R.getAsSingle<ClassTemplateDecl>()) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004146 Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_class_template)
Aaron Ballman4a979672014-01-03 13:56:08 +00004147 << SS.getScopeRep()
Reid Kleckner32506ed2014-06-12 23:03:48 +00004148 << NameInfo.getName().getAsString() << SS.getRange();
John McCalle66edc12009-11-24 19:00:30 +00004149 Diag(Temp->getLocation(), diag::note_referenced_class_template);
4150 return ExprError();
4151 }
4152
Abramo Bagnara7945c982012-01-27 09:46:47 +00004153 return BuildTemplateIdExpr(SS, TemplateKWLoc, R, /*ADL*/ false, TemplateArgs);
Douglas Gregora727cb92009-06-30 22:34:41 +00004154}
4155
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00004156/// Form a dependent template name.
Douglas Gregorb67535d2009-03-31 00:43:58 +00004157///
4158/// This action forms a dependent template name given the template
4159/// name and its (presumably dependent) scope specifier. For
4160/// example, given "MetaFun::template apply", the scope specifier \p
4161/// SS will be "MetaFun::", \p TemplateKWLoc contains the location
4162/// of the "template" keyword, and "apply" is the \p Name.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004163TemplateNameKind Sema::ActOnDependentTemplateName(Scope *S,
Douglas Gregorbb119652010-06-16 23:00:59 +00004164 CXXScopeSpec &SS,
Abramo Bagnara7945c982012-01-27 09:46:47 +00004165 SourceLocation TemplateKWLoc,
Richard Smithc08b6932018-04-27 02:00:13 +00004166 const UnqualifiedId &Name,
John McCallba7bf592010-08-24 05:47:05 +00004167 ParsedType ObjectType,
Douglas Gregorbb119652010-06-16 23:00:59 +00004168 bool EnteringContext,
Richard Smithfd3dae02017-01-20 00:20:39 +00004169 TemplateTy &Result,
4170 bool AllowInjectedClassName) {
Richard Smith0bf8a4922011-10-18 20:49:44 +00004171 if (TemplateKWLoc.isValid() && S && !S->getTemplateParamParent())
4172 Diag(TemplateKWLoc,
Richard Smith2bf7fdb2013-01-02 11:42:31 +00004173 getLangOpts().CPlusPlus11 ?
Richard Smith0bf8a4922011-10-18 20:49:44 +00004174 diag::warn_cxx98_compat_template_outside_of_template :
4175 diag::ext_template_outside_of_template)
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004176 << FixItHint::CreateRemoval(TemplateKWLoc);
4177
Craig Topperc3ec1492014-05-26 06:22:03 +00004178 DeclContext *LookupCtx = nullptr;
Douglas Gregor9abe2372010-01-19 16:01:07 +00004179 if (SS.isSet())
4180 LookupCtx = computeDeclContext(SS, EnteringContext);
4181 if (!LookupCtx && ObjectType)
John McCallba7bf592010-08-24 05:47:05 +00004182 LookupCtx = computeDeclContext(ObjectType.get());
Douglas Gregor9abe2372010-01-19 16:01:07 +00004183 if (LookupCtx) {
Douglas Gregorb67535d2009-03-31 00:43:58 +00004184 // C++0x [temp.names]p5:
4185 // If a name prefixed by the keyword template is not the name of
4186 // a template, the program is ill-formed. [Note: the keyword
4187 // template may not be applied to non-template members of class
4188 // templates. -end note ] [ Note: as is the case with the
4189 // typename prefix, the template prefix is allowed in cases
4190 // where it is not strictly necessary; i.e., when the
4191 // nested-name-specifier or the expression on the left of the ->
4192 // or . is not dependent on a template-parameter, or the use
4193 // does not appear in the scope of a template. -end note]
4194 //
4195 // Note: C++03 was more strict here, because it banned the use of
4196 // the "template" keyword prior to a template-name that was not a
4197 // dependent name. C++ DR468 relaxed this requirement (the
4198 // "template" keyword is now permitted). We follow the C++0x
Douglas Gregorc9d26822010-06-14 22:07:54 +00004199 // rules, even in C++03 mode with a warning, retroactively applying the DR.
Douglas Gregor786123d2010-05-21 23:18:07 +00004200 bool MemberOfUnknownSpecialization;
Richard Smithaf416962012-11-15 00:31:27 +00004201 TemplateNameKind TNK = isTemplateName(S, SS, TemplateKWLoc.isValid(), Name,
Abramo Bagnara7c5dee42010-08-06 12:11:11 +00004202 ObjectType, EnteringContext, Result,
Douglas Gregor786123d2010-05-21 23:18:07 +00004203 MemberOfUnknownSpecialization);
Richard Smith79810042018-05-11 02:43:08 +00004204 if (TNK == TNK_Non_template && MemberOfUnknownSpecialization) {
Douglas Gregorbb119652010-06-16 23:00:59 +00004205 // This is a dependent template. Handle it below.
Douglas Gregord2e6a452010-01-14 17:47:39 +00004206 } else if (TNK == TNK_Non_template) {
Richard Smith79810042018-05-11 02:43:08 +00004207 // Do the lookup again to determine if this is a "nothing found" case or
4208 // a "not a template" case. FIXME: Refactor isTemplateName so we don't
4209 // need to do this.
4210 DeclarationNameInfo DNI = GetNameFromUnqualifiedId(Name);
4211 LookupResult R(*this, DNI.getName(), Name.getLocStart(),
4212 LookupOrdinaryName);
4213 bool MOUS;
4214 if (!LookupTemplateName(R, S, SS, ObjectType.get(), EnteringContext,
4215 MOUS, TemplateKWLoc))
4216 Diag(Name.getLocStart(), diag::err_no_member)
4217 << DNI.getName() << LookupCtx << SS.getRange();
Douglas Gregorbb119652010-06-16 23:00:59 +00004218 return TNK_Non_template;
Douglas Gregord2e6a452010-01-14 17:47:39 +00004219 } else {
4220 // We found something; return it.
Richard Smithfd3dae02017-01-20 00:20:39 +00004221 auto *LookupRD = dyn_cast<CXXRecordDecl>(LookupCtx);
4222 if (!AllowInjectedClassName && SS.isSet() && LookupRD &&
Faisal Vali2ab8c152017-12-30 04:15:27 +00004223 Name.getKind() == UnqualifiedIdKind::IK_Identifier &&
4224 Name.Identifier && LookupRD->getIdentifier() == Name.Identifier) {
Richard Smithfd3dae02017-01-20 00:20:39 +00004225 // C++14 [class.qual]p2:
4226 // In a lookup in which function names are not ignored and the
4227 // nested-name-specifier nominates a class C, if the name specified
4228 // [...] is the injected-class-name of C, [...] the name is instead
4229 // considered to name the constructor
4230 //
4231 // We don't get here if naming the constructor would be valid, so we
4232 // just reject immediately and recover by treating the
4233 // injected-class-name as naming the template.
4234 Diag(Name.getLocStart(),
4235 diag::ext_out_of_line_qualified_id_type_names_constructor)
4236 << Name.Identifier << 0 /*injected-class-name used as template name*/
4237 << 1 /*'template' keyword was used*/;
4238 }
Douglas Gregorbb119652010-06-16 23:00:59 +00004239 return TNK;
Douglas Gregorb67535d2009-03-31 00:43:58 +00004240 }
Douglas Gregorb67535d2009-03-31 00:43:58 +00004241 }
4242
Aaron Ballman4a979672014-01-03 13:56:08 +00004243 NestedNameSpecifier *Qualifier = SS.getScopeRep();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004244
Douglas Gregor3cf81312009-11-03 23:16:33 +00004245 switch (Name.getKind()) {
Faisal Vali2ab8c152017-12-30 04:15:27 +00004246 case UnqualifiedIdKind::IK_Identifier:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004247 Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
Douglas Gregorbb119652010-06-16 23:00:59 +00004248 Name.Identifier));
4249 return TNK_Dependent_template_name;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004250
Faisal Vali2ab8c152017-12-30 04:15:27 +00004251 case UnqualifiedIdKind::IK_OperatorFunctionId:
Douglas Gregorbb119652010-06-16 23:00:59 +00004252 Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
Douglas Gregor71395fa2009-11-04 00:56:37 +00004253 Name.OperatorFunctionId.Operator));
Richard Smith72bfbd82013-12-04 00:28:23 +00004254 return TNK_Function_template;
Alexis Hunted0530f2009-11-28 08:58:14 +00004255
Faisal Vali2ab8c152017-12-30 04:15:27 +00004256 case UnqualifiedIdKind::IK_LiteralOperatorId:
Richard Smithd091dc12013-12-05 00:58:33 +00004257 llvm_unreachable("literal operator id cannot have a dependent scope");
Alexis Hunted0530f2009-11-28 08:58:14 +00004258
Douglas Gregor3cf81312009-11-03 23:16:33 +00004259 default:
4260 break;
4261 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004262
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004263 Diag(Name.getLocStart(),
Douglas Gregor3cf81312009-11-03 23:16:33 +00004264 diag::err_template_kw_refers_to_non_template)
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004265 << GetNameFromUnqualifiedId(Name).getName()
Douglas Gregorb22ee882010-05-05 05:58:24 +00004266 << Name.getSourceRange()
4267 << TemplateKWLoc;
Douglas Gregorbb119652010-06-16 23:00:59 +00004268 return TNK_Non_template;
Douglas Gregorb67535d2009-03-31 00:43:58 +00004269}
4270
Mike Stump11289f42009-09-09 15:08:12 +00004271bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
Reid Kleckner377c1592014-06-10 23:29:48 +00004272 TemplateArgumentLoc &AL,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004273 SmallVectorImpl<TemplateArgument> &Converted) {
John McCall0ad16662009-10-29 08:12:44 +00004274 const TemplateArgument &Arg = AL.getArgument();
Reid Kleckner377c1592014-06-10 23:29:48 +00004275 QualType ArgType;
4276 TypeSourceInfo *TSI = nullptr;
John McCall0ad16662009-10-29 08:12:44 +00004277
Anders Carlssonc8cbb2d2009-06-13 00:33:33 +00004278 // Check template type parameter.
Jeffrey Yasskin823015d2010-04-08 00:03:06 +00004279 switch(Arg.getKind()) {
4280 case TemplateArgument::Type:
Anders Carlssonc8cbb2d2009-06-13 00:33:33 +00004281 // C++ [temp.arg.type]p1:
4282 // A template-argument for a template-parameter which is a
4283 // type shall be a type-id.
Reid Kleckner377c1592014-06-10 23:29:48 +00004284 ArgType = Arg.getAsType();
4285 TSI = AL.getTypeSourceInfo();
Jeffrey Yasskin823015d2010-04-08 00:03:06 +00004286 break;
Richard Smith77a9c602018-02-28 03:02:23 +00004287 case TemplateArgument::Template:
4288 case TemplateArgument::TemplateExpansion: {
Jeffrey Yasskin823015d2010-04-08 00:03:06 +00004289 // We have a template type parameter but the template argument
4290 // is a template without any arguments.
4291 SourceRange SR = AL.getSourceRange();
Richard Smith77a9c602018-02-28 03:02:23 +00004292 TemplateName Name = Arg.getAsTemplateOrTemplatePattern();
Richard Smithecad88d2018-04-26 01:08:00 +00004293 diagnoseMissingTemplateArguments(Name, SR.getEnd());
Jeffrey Yasskin823015d2010-04-08 00:03:06 +00004294 return true;
4295 }
Kaelyn Uhrain864d0b02012-05-18 23:42:49 +00004296 case TemplateArgument::Expression: {
4297 // We have a template type parameter but the template argument is an
4298 // expression; see if maybe it is missing the "typename" keyword.
4299 CXXScopeSpec SS;
4300 DeclarationNameInfo NameInfo;
4301
4302 if (DeclRefExpr *ArgExpr = dyn_cast<DeclRefExpr>(Arg.getAsExpr())) {
4303 SS.Adopt(ArgExpr->getQualifierLoc());
4304 NameInfo = ArgExpr->getNameInfo();
4305 } else if (DependentScopeDeclRefExpr *ArgExpr =
4306 dyn_cast<DependentScopeDeclRefExpr>(Arg.getAsExpr())) {
4307 SS.Adopt(ArgExpr->getQualifierLoc());
4308 NameInfo = ArgExpr->getNameInfo();
4309 } else if (CXXDependentScopeMemberExpr *ArgExpr =
4310 dyn_cast<CXXDependentScopeMemberExpr>(Arg.getAsExpr())) {
Kaelyn Uhrain055e9472012-06-08 01:07:26 +00004311 if (ArgExpr->isImplicitAccess()) {
4312 SS.Adopt(ArgExpr->getQualifierLoc());
4313 NameInfo = ArgExpr->getMemberNameInfo();
4314 }
Kaelyn Uhrain864d0b02012-05-18 23:42:49 +00004315 }
4316
Reid Kleckner377c1592014-06-10 23:29:48 +00004317 if (auto *II = NameInfo.getName().getAsIdentifierInfo()) {
Kaelyn Uhrain864d0b02012-05-18 23:42:49 +00004318 LookupResult Result(*this, NameInfo, LookupOrdinaryName);
4319 LookupParsedName(Result, CurScope, &SS);
4320
Kaelyn Uhrain055e9472012-06-08 01:07:26 +00004321 if (Result.getAsSingle<TypeDecl>() ||
4322 Result.getResultKind() ==
Reid Kleckner377c1592014-06-10 23:29:48 +00004323 LookupResult::NotFoundInCurrentInstantiation) {
4324 // Suggest that the user add 'typename' before the NNS.
Kaelyn Uhrain864d0b02012-05-18 23:42:49 +00004325 SourceLocation Loc = AL.getSourceRange().getBegin();
Reid Kleckner377c1592014-06-10 23:29:48 +00004326 Diag(Loc, getLangOpts().MSVCCompat
4327 ? diag::ext_ms_template_type_arg_missing_typename
4328 : diag::err_template_arg_must_be_type_suggest)
4329 << FixItHint::CreateInsertion(Loc, "typename ");
Kaelyn Uhrain864d0b02012-05-18 23:42:49 +00004330 Diag(Param->getLocation(), diag::note_template_param_here);
Reid Kleckner377c1592014-06-10 23:29:48 +00004331
4332 // Recover by synthesizing a type using the location information that we
4333 // already have.
4334 ArgType =
4335 Context.getDependentNameType(ETK_Typename, SS.getScopeRep(), II);
4336 TypeLocBuilder TLB;
4337 DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(ArgType);
4338 TL.setElaboratedKeywordLoc(SourceLocation(/*synthesized*/));
4339 TL.setQualifierLoc(SS.getWithLocInContext(Context));
4340 TL.setNameLoc(NameInfo.getLoc());
4341 TSI = TLB.getTypeSourceInfo(Context, ArgType);
4342
4343 // Overwrite our input TemplateArgumentLoc so that we can recover
4344 // properly.
4345 AL = TemplateArgumentLoc(TemplateArgument(ArgType),
4346 TemplateArgumentLocInfo(TSI));
4347
4348 break;
Kaelyn Uhrain864d0b02012-05-18 23:42:49 +00004349 }
4350 }
4351 // fallthrough
Galina Kistanova3779cb32017-06-07 06:25:05 +00004352 LLVM_FALLTHROUGH;
Kaelyn Uhrain864d0b02012-05-18 23:42:49 +00004353 }
Jeffrey Yasskin823015d2010-04-08 00:03:06 +00004354 default: {
Anders Carlssonc8cbb2d2009-06-13 00:33:33 +00004355 // We have a template type parameter but the template argument
4356 // is not a type.
John McCall0d07eb32009-10-29 18:45:58 +00004357 SourceRange SR = AL.getSourceRange();
4358 Diag(SR.getBegin(), diag::err_template_arg_must_be_type) << SR;
Anders Carlssonc8cbb2d2009-06-13 00:33:33 +00004359 Diag(Param->getLocation(), diag::note_template_param_here);
Mike Stump11289f42009-09-09 15:08:12 +00004360
Anders Carlssonc8cbb2d2009-06-13 00:33:33 +00004361 return true;
Mike Stump11289f42009-09-09 15:08:12 +00004362 }
Jeffrey Yasskin823015d2010-04-08 00:03:06 +00004363 }
Anders Carlssonc8cbb2d2009-06-13 00:33:33 +00004364
Reid Kleckner377c1592014-06-10 23:29:48 +00004365 if (CheckTemplateArgument(Param, TSI))
Anders Carlssonc8cbb2d2009-06-13 00:33:33 +00004366 return true;
Mike Stump11289f42009-09-09 15:08:12 +00004367
Anders Carlssonc8cbb2d2009-06-13 00:33:33 +00004368 // Add the converted template type argument.
Reid Kleckner377c1592014-06-10 23:29:48 +00004369 ArgType = Context.getCanonicalType(ArgType);
Simon Pilgrim6905d222016-12-30 22:55:33 +00004370
Douglas Gregore46db902011-06-17 22:11:49 +00004371 // Objective-C ARC:
4372 // If an explicitly-specified template argument type is a lifetime type
4373 // with no lifetime qualifier, the __strong lifetime qualifier is inferred.
David Blaikiebbafb8a2012-03-11 07:00:24 +00004374 if (getLangOpts().ObjCAutoRefCount &&
Douglas Gregore46db902011-06-17 22:11:49 +00004375 ArgType->isObjCLifetimeType() &&
4376 !ArgType.getObjCLifetime()) {
4377 Qualifiers Qs;
4378 Qs.setObjCLifetime(Qualifiers::OCL_Strong);
4379 ArgType = Context.getQualifiedType(ArgType, Qs);
4380 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00004381
Douglas Gregore46db902011-06-17 22:11:49 +00004382 Converted.push_back(TemplateArgument(ArgType));
Anders Carlssonc8cbb2d2009-06-13 00:33:33 +00004383 return false;
4384}
4385
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00004386/// Substitute template arguments into the default template argument for
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004387/// the given template type parameter.
4388///
4389/// \param SemaRef the semantic analysis object for which we are performing
4390/// the substitution.
4391///
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004392/// \param Template the template that we are synthesizing template arguments
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004393/// for.
4394///
4395/// \param TemplateLoc the location of the template name that started the
4396/// template-id we are checking.
4397///
4398/// \param RAngleLoc the location of the right angle bracket ('>') that
4399/// terminates the template-id.
4400///
4401/// \param Param the template template parameter whose default we are
4402/// substituting into.
4403///
4404/// \param Converted the list of template arguments provided for template
4405/// parameters that precede \p Param in the template parameter list.
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004406/// \returns the substituted template argument, or NULL if an error occurred.
John McCallbcd03502009-12-07 02:54:59 +00004407static TypeSourceInfo *
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004408SubstDefaultTemplateArgument(Sema &SemaRef,
4409 TemplateDecl *Template,
4410 SourceLocation TemplateLoc,
4411 SourceLocation RAngleLoc,
4412 TemplateTypeParmDecl *Param,
Vassil Vassilev2999d0e2017-01-10 09:09:09 +00004413 SmallVectorImpl<TemplateArgument> &Converted) {
John McCallbcd03502009-12-07 02:54:59 +00004414 TypeSourceInfo *ArgType = Param->getDefaultArgumentInfo();
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004415
4416 // If the argument type is dependent, instantiate it now based
4417 // on the previously-computed template arguments.
4418 if (ArgType->getType()->isDependentType()) {
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004419 Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
Richard Smith54f18e82016-08-31 02:15:21 +00004420 Param, Template, Converted,
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004421 SourceRange(TemplateLoc, RAngleLoc));
Alp Tokerd4a72d52013-10-08 08:09:04 +00004422 if (Inst.isInvalid())
Craig Topperc3ec1492014-05-26 06:22:03 +00004423 return nullptr;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004424
David Majnemer8b622692016-07-03 21:17:51 +00004425 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
David Majnemer89189202013-08-28 23:48:32 +00004426
4427 // Only substitute for the innermost template argument list.
4428 MultiLevelTemplateArgumentList TemplateArgLists;
4429 TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
4430 for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
4431 TemplateArgLists.addOuterTemplateArguments(None);
4432
Argyrios Kyrtzidis6fe744c2012-04-25 18:39:17 +00004433 Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
David Majnemer89189202013-08-28 23:48:32 +00004434 ArgType =
4435 SemaRef.SubstType(ArgType, TemplateArgLists,
4436 Param->getDefaultArgumentLoc(), Param->getDeclName());
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004437 }
4438
4439 return ArgType;
4440}
4441
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00004442/// Substitute template arguments into the default template argument for
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004443/// the given non-type template parameter.
4444///
4445/// \param SemaRef the semantic analysis object for which we are performing
4446/// the substitution.
4447///
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004448/// \param Template the template that we are synthesizing template arguments
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004449/// for.
4450///
4451/// \param TemplateLoc the location of the template name that started the
4452/// template-id we are checking.
4453///
4454/// \param RAngleLoc the location of the right angle bracket ('>') that
4455/// terminates the template-id.
4456///
Douglas Gregor9167f8b2009-11-11 01:00:40 +00004457/// \param Param the non-type template parameter whose default we are
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004458/// substituting into.
4459///
4460/// \param Converted the list of template arguments provided for template
4461/// parameters that precede \p Param in the template parameter list.
4462///
4463/// \returns the substituted template argument, or NULL if an error occurred.
John McCalldadc5752010-08-24 06:29:42 +00004464static ExprResult
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004465SubstDefaultTemplateArgument(Sema &SemaRef,
4466 TemplateDecl *Template,
4467 SourceLocation TemplateLoc,
4468 SourceLocation RAngleLoc,
4469 NonTypeTemplateParmDecl *Param,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004470 SmallVectorImpl<TemplateArgument> &Converted) {
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004471 Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
Richard Smith54f18e82016-08-31 02:15:21 +00004472 Param, Template, Converted,
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004473 SourceRange(TemplateLoc, RAngleLoc));
Alp Tokerd4a72d52013-10-08 08:09:04 +00004474 if (Inst.isInvalid())
Richard Smith8a874c92012-07-08 02:38:24 +00004475 return ExprError();
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004476
David Majnemer8b622692016-07-03 21:17:51 +00004477 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
David Majnemer89189202013-08-28 23:48:32 +00004478
4479 // Only substitute for the innermost template argument list.
4480 MultiLevelTemplateArgumentList TemplateArgLists;
4481 TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
4482 for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
4483 TemplateArgLists.addOuterTemplateArguments(None);
4484
Faisal Valid143a0c2017-04-01 21:30:49 +00004485 EnterExpressionEvaluationContext ConstantEvaluated(
4486 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
David Majnemer89189202013-08-28 23:48:32 +00004487 return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists);
Douglas Gregor36d7c5f2009-11-09 19:17:50 +00004488}
4489
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00004490/// Substitute template arguments into the default template argument for
Douglas Gregor9167f8b2009-11-11 01:00:40 +00004491/// the given template template parameter.
4492///
4493/// \param SemaRef the semantic analysis object for which we are performing
4494/// the substitution.
4495///
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004496/// \param Template the template that we are synthesizing template arguments
Douglas Gregor9167f8b2009-11-11 01:00:40 +00004497/// for.
4498///
4499/// \param TemplateLoc the location of the template name that started the
4500/// template-id we are checking.
4501///
4502/// \param RAngleLoc the location of the right angle bracket ('>') that
4503/// terminates the template-id.
4504///
4505/// \param Param the template template parameter whose default we are
4506/// substituting into.
4507///
4508/// \param Converted the list of template arguments provided for template
4509/// parameters that precede \p Param in the template parameter list.
4510///
Simon Pilgrim6905d222016-12-30 22:55:33 +00004511/// \param QualifierLoc Will be set to the nested-name-specifier (with
Douglas Gregordf846d12011-03-02 18:46:51 +00004512/// source-location information) that precedes the template name.
Douglas Gregor9d802122011-03-02 17:09:35 +00004513///
Douglas Gregor9167f8b2009-11-11 01:00:40 +00004514/// \returns the substituted template argument, or NULL if an error occurred.
4515static TemplateName
4516SubstDefaultTemplateArgument(Sema &SemaRef,
4517 TemplateDecl *Template,
4518 SourceLocation TemplateLoc,
4519 SourceLocation RAngleLoc,
4520 TemplateTemplateParmDecl *Param,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004521 SmallVectorImpl<TemplateArgument> &Converted,
Douglas Gregor9d802122011-03-02 17:09:35 +00004522 NestedNameSpecifierLoc &QualifierLoc) {
Richard Smith54f18e82016-08-31 02:15:21 +00004523 Sema::InstantiatingTemplate Inst(
4524 SemaRef, TemplateLoc, TemplateParameter(Param), Template, Converted,
4525 SourceRange(TemplateLoc, RAngleLoc));
Alp Tokerd4a72d52013-10-08 08:09:04 +00004526 if (Inst.isInvalid())
Richard Smith8a874c92012-07-08 02:38:24 +00004527 return TemplateName();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004528
David Majnemer8b622692016-07-03 21:17:51 +00004529 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
David Majnemer89189202013-08-28 23:48:32 +00004530
4531 // Only substitute for the innermost template argument list.
4532 MultiLevelTemplateArgumentList TemplateArgLists;
4533 TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
4534 for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
4535 TemplateArgLists.addOuterTemplateArguments(None);
4536
Argyrios Kyrtzidis6fe744c2012-04-25 18:39:17 +00004537 Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
David Majnemer89189202013-08-28 23:48:32 +00004538 // Substitute into the nested-name-specifier first,
Douglas Gregordf846d12011-03-02 18:46:51 +00004539 QualifierLoc = Param->getDefaultArgument().getTemplateQualifierLoc();
Douglas Gregor9d802122011-03-02 17:09:35 +00004540 if (QualifierLoc) {
David Majnemer89189202013-08-28 23:48:32 +00004541 QualifierLoc =
4542 SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgLists);
Douglas Gregor9d802122011-03-02 17:09:35 +00004543 if (!QualifierLoc)
4544 return TemplateName();
4545 }
David Majnemer89189202013-08-28 23:48:32 +00004546
4547 return SemaRef.SubstTemplateName(
4548 QualifierLoc,
4549 Param->getDefaultArgument().getArgument().getAsTemplate(),
4550 Param->getDefaultArgument().getTemplateNameLoc(),
4551 TemplateArgLists);
Douglas Gregor9167f8b2009-11-11 01:00:40 +00004552}
4553
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00004554/// If the given template parameter has a default template
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004555/// argument, substitute into that default template argument and
4556/// return the corresponding template argument.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004557TemplateArgumentLoc
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004558Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
4559 SourceLocation TemplateLoc,
4560 SourceLocation RAngleLoc,
4561 Decl *Param,
Richard Smithc87b9382013-07-04 01:01:24 +00004562 SmallVectorImpl<TemplateArgument>
4563 &Converted,
4564 bool &HasDefaultArg) {
4565 HasDefaultArg = false;
4566
4567 if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) {
Richard Smith95d83952015-06-10 20:36:34 +00004568 if (!hasVisibleDefaultArgument(TypeParm))
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004569 return TemplateArgumentLoc();
4570
Richard Smithc87b9382013-07-04 01:01:24 +00004571 HasDefaultArg = true;
John McCallbcd03502009-12-07 02:54:59 +00004572 TypeSourceInfo *DI = SubstDefaultTemplateArgument(*this, Template,
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004573 TemplateLoc,
4574 RAngleLoc,
4575 TypeParm,
4576 Converted);
4577 if (DI)
4578 return TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
4579
4580 return TemplateArgumentLoc();
4581 }
4582
4583 if (NonTypeTemplateParmDecl *NonTypeParm
4584 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
Richard Smith95d83952015-06-10 20:36:34 +00004585 if (!hasVisibleDefaultArgument(NonTypeParm))
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004586 return TemplateArgumentLoc();
4587
Richard Smithc87b9382013-07-04 01:01:24 +00004588 HasDefaultArg = true;
John McCalldadc5752010-08-24 06:29:42 +00004589 ExprResult Arg = SubstDefaultTemplateArgument(*this, Template,
Douglas Gregor9d802122011-03-02 17:09:35 +00004590 TemplateLoc,
4591 RAngleLoc,
4592 NonTypeParm,
4593 Converted);
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004594 if (Arg.isInvalid())
4595 return TemplateArgumentLoc();
4596
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004597 Expr *ArgE = Arg.getAs<Expr>();
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004598 return TemplateArgumentLoc(TemplateArgument(ArgE), ArgE);
4599 }
4600
4601 TemplateTemplateParmDecl *TempTempParm
4602 = cast<TemplateTemplateParmDecl>(Param);
Richard Smith95d83952015-06-10 20:36:34 +00004603 if (!hasVisibleDefaultArgument(TempTempParm))
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004604 return TemplateArgumentLoc();
4605
Richard Smithc87b9382013-07-04 01:01:24 +00004606 HasDefaultArg = true;
Douglas Gregordf846d12011-03-02 18:46:51 +00004607 NestedNameSpecifierLoc QualifierLoc;
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004608 TemplateName TName = SubstDefaultTemplateArgument(*this, Template,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004609 TemplateLoc,
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004610 RAngleLoc,
4611 TempTempParm,
Douglas Gregor9d802122011-03-02 17:09:35 +00004612 Converted,
4613 QualifierLoc);
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004614 if (TName.isNull())
4615 return TemplateArgumentLoc();
4616
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004617 return TemplateArgumentLoc(TemplateArgument(TName),
Douglas Gregor9d802122011-03-02 17:09:35 +00004618 TempTempParm->getDefaultArgument().getTemplateQualifierLoc(),
Douglas Gregor5c80a27b2009-11-25 18:55:14 +00004619 TempTempParm->getDefaultArgument().getTemplateNameLoc());
4620}
4621
Richard Smith11255ec2017-01-18 19:19:22 +00004622/// Convert a template-argument that we parsed as a type into a template, if
4623/// possible. C++ permits injected-class-names to perform dual service as
4624/// template template arguments and as template type arguments.
4625static TemplateArgumentLoc convertTypeTemplateArgumentToTemplate(TypeLoc TLoc) {
4626 // Extract and step over any surrounding nested-name-specifier.
4627 NestedNameSpecifierLoc QualLoc;
4628 if (auto ETLoc = TLoc.getAs<ElaboratedTypeLoc>()) {
4629 if (ETLoc.getTypePtr()->getKeyword() != ETK_None)
4630 return TemplateArgumentLoc();
4631
4632 QualLoc = ETLoc.getQualifierLoc();
4633 TLoc = ETLoc.getNamedTypeLoc();
4634 }
4635
4636 // If this type was written as an injected-class-name, it can be used as a
4637 // template template argument.
4638 if (auto InjLoc = TLoc.getAs<InjectedClassNameTypeLoc>())
4639 return TemplateArgumentLoc(InjLoc.getTypePtr()->getTemplateName(),
4640 QualLoc, InjLoc.getNameLoc());
4641
4642 // If this type was written as an injected-class-name, it may have been
4643 // converted to a RecordType during instantiation. If the RecordType is
4644 // *not* wrapped in a TemplateSpecializationType and denotes a class
4645 // template specialization, it must have come from an injected-class-name.
4646 if (auto RecLoc = TLoc.getAs<RecordTypeLoc>())
4647 if (auto *CTSD =
4648 dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))
4649 return TemplateArgumentLoc(TemplateName(CTSD->getSpecializedTemplate()),
4650 QualLoc, RecLoc.getNameLoc());
4651
4652 return TemplateArgumentLoc();
4653}
4654
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00004655/// Check that the given template argument corresponds to the given
Douglas Gregorda0fb532009-11-11 19:31:23 +00004656/// template parameter.
Douglas Gregor0231d8d2011-01-19 20:10:05 +00004657///
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004658/// \param Param The template parameter against which the argument will be
Douglas Gregor0231d8d2011-01-19 20:10:05 +00004659/// checked.
4660///
Richard Trieu15b66532015-01-24 02:48:32 +00004661/// \param Arg The template argument, which may be updated due to conversions.
Douglas Gregor0231d8d2011-01-19 20:10:05 +00004662///
4663/// \param Template The template in which the template argument resides.
4664///
4665/// \param TemplateLoc The location of the template name for the template
4666/// whose argument list we're matching.
4667///
4668/// \param RAngleLoc The location of the right angle bracket ('>') that closes
4669/// the template argument list.
4670///
4671/// \param ArgumentPackIndex The index into the argument pack where this
4672/// argument will be placed. Only valid if the parameter is a parameter pack.
4673///
4674/// \param Converted The checked, converted argument will be added to the
4675/// end of this small vector.
4676///
4677/// \param CTAK Describes how we arrived at this particular template argument:
4678/// explicitly written, deduced, etc.
4679///
4680/// \returns true on error, false otherwise.
Douglas Gregorda0fb532009-11-11 19:31:23 +00004681bool Sema::CheckTemplateArgument(NamedDecl *Param,
Reid Kleckner377c1592014-06-10 23:29:48 +00004682 TemplateArgumentLoc &Arg,
Douglas Gregorca4686d2011-01-04 23:35:54 +00004683 NamedDecl *Template,
Douglas Gregorda0fb532009-11-11 19:31:23 +00004684 SourceLocation TemplateLoc,
Douglas Gregorda0fb532009-11-11 19:31:23 +00004685 SourceLocation RAngleLoc,
Douglas Gregor0231d8d2011-01-19 20:10:05 +00004686 unsigned ArgumentPackIndex,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004687 SmallVectorImpl<TemplateArgument> &Converted,
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00004688 CheckTemplateArgumentKind CTAK) {
Douglas Gregoreebed722009-11-11 19:41:09 +00004689 // Check template type parameters.
4690 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
Douglas Gregorda0fb532009-11-11 19:31:23 +00004691 return CheckTemplateTypeArgument(TTP, Arg, Converted);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004692
Douglas Gregoreebed722009-11-11 19:41:09 +00004693 // Check non-type template parameters.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004694 if (NonTypeTemplateParmDecl *NTTP =dyn_cast<NonTypeTemplateParmDecl>(Param)) {
Douglas Gregorda0fb532009-11-11 19:31:23 +00004695 // Do substitution on the type of the non-type template parameter
Peter Collingbourne01687632010-12-10 17:08:53 +00004696 // with the template arguments we've seen thus far. But if the
4697 // template has a dependent context then we cannot substitute yet.
Douglas Gregorda0fb532009-11-11 19:31:23 +00004698 QualType NTTPType = NTTP->getType();
Douglas Gregor0231d8d2011-01-19 20:10:05 +00004699 if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
4700 NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004701
Richard Smith5d331022018-03-08 01:07:33 +00004702 // FIXME: Do we need to substitute into parameters here if they're
4703 // instantiation-dependent but not dependent?
Peter Collingbourne01687632010-12-10 17:08:53 +00004704 if (NTTPType->isDependentType() &&
4705 !isa<TemplateTemplateParmDecl>(Template) &&
4706 !Template->getDeclContext()->isDependentContext()) {
Douglas Gregorda0fb532009-11-11 19:31:23 +00004707 // Do substitution on the type of the non-type template parameter.
4708 InstantiatingTemplate Inst(*this, TemplateLoc, Template,
Richard Smith80934652012-07-16 01:09:10 +00004709 NTTP, Converted,
Douglas Gregorda0fb532009-11-11 19:31:23 +00004710 SourceRange(TemplateLoc, RAngleLoc));
Alp Tokerd4a72d52013-10-08 08:09:04 +00004711 if (Inst.isInvalid())
Richard Smith8a874c92012-07-08 02:38:24 +00004712 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004713
4714 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
David Majnemer8b622692016-07-03 21:17:51 +00004715 Converted);
Douglas Gregorda0fb532009-11-11 19:31:23 +00004716 NTTPType = SubstType(NTTPType,
4717 MultiLevelTemplateArgumentList(TemplateArgs),
4718 NTTP->getLocation(),
4719 NTTP->getDeclName());
4720 // If that worked, check the non-type template parameter type
4721 // for validity.
4722 if (!NTTPType.isNull())
4723 NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
4724 NTTP->getLocation());
4725 if (NTTPType.isNull())
4726 return true;
4727 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004728
Douglas Gregorda0fb532009-11-11 19:31:23 +00004729 switch (Arg.getArgument().getKind()) {
4730 case TemplateArgument::Null:
David Blaikie83d382b2011-09-23 05:06:16 +00004731 llvm_unreachable("Should never see a NULL template argument here");
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004732
Douglas Gregorda0fb532009-11-11 19:31:23 +00004733 case TemplateArgument::Expression: {
Douglas Gregorda0fb532009-11-11 19:31:23 +00004734 TemplateArgument Result;
Erich Keanec90bb6d2018-05-07 17:05:20 +00004735 unsigned CurSFINAEErrors = NumSFINAEErrors;
John Wiegley01296292011-04-08 18:41:53 +00004736 ExprResult Res =
4737 CheckTemplateArgument(NTTP, NTTPType, Arg.getArgument().getAsExpr(),
4738 Result, CTAK);
4739 if (Res.isInvalid())
Douglas Gregorda0fb532009-11-11 19:31:23 +00004740 return true;
Erich Keanec90bb6d2018-05-07 17:05:20 +00004741 // If the current template argument causes an error, give up now.
4742 if (CurSFINAEErrors < NumSFINAEErrors)
4743 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004744
Richard Trieu15b66532015-01-24 02:48:32 +00004745 // If the resulting expression is new, then use it in place of the
4746 // old expression in the template argument.
4747 if (Res.get() != Arg.getArgument().getAsExpr()) {
4748 TemplateArgument TA(Res.get());
4749 Arg = TemplateArgumentLoc(TA, Res.get());
4750 }
4751
Douglas Gregor1ccc8412010-11-07 23:05:16 +00004752 Converted.push_back(Result);
Douglas Gregorda0fb532009-11-11 19:31:23 +00004753 break;
4754 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004755
Douglas Gregorda0fb532009-11-11 19:31:23 +00004756 case TemplateArgument::Declaration:
4757 case TemplateArgument::Integral:
Eli Friedmanb826a002012-09-26 02:36:12 +00004758 case TemplateArgument::NullPtr:
Douglas Gregorda0fb532009-11-11 19:31:23 +00004759 // We've already checked this template argument, so just copy
4760 // it to the list of converted arguments.
Douglas Gregor1ccc8412010-11-07 23:05:16 +00004761 Converted.push_back(Arg.getArgument());
Douglas Gregorda0fb532009-11-11 19:31:23 +00004762 break;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004763
Douglas Gregorda0fb532009-11-11 19:31:23 +00004764 case TemplateArgument::Template:
Douglas Gregore4ff4b52011-01-05 18:58:31 +00004765 case TemplateArgument::TemplateExpansion:
Douglas Gregorda0fb532009-11-11 19:31:23 +00004766 // We were given a template template argument. It may not be ill-formed;
4767 // see below.
4768 if (DependentTemplateName *DTN
Douglas Gregore4ff4b52011-01-05 18:58:31 +00004769 = Arg.getArgument().getAsTemplateOrTemplatePattern()
4770 .getAsDependentTemplateName()) {
Douglas Gregorda0fb532009-11-11 19:31:23 +00004771 // We have a template argument such as \c T::template X, which we
4772 // parsed as a template template argument. However, since we now
4773 // know that we need a non-type template argument, convert this
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00004774 // template name into an expression.
4775
4776 DeclarationNameInfo NameInfo(DTN->getIdentifier(),
4777 Arg.getTemplateNameLoc());
4778
Douglas Gregor3a43fd62011-02-25 20:49:16 +00004779 CXXScopeSpec SS;
Douglas Gregor9d802122011-03-02 17:09:35 +00004780 SS.Adopt(Arg.getTemplateQualifierLoc());
Abramo Bagnara7945c982012-01-27 09:46:47 +00004781 // FIXME: the template-template arg was a DependentTemplateName,
4782 // so it was provided with a template keyword. However, its source
4783 // location is not stored in the template argument structure.
4784 SourceLocation TemplateKWLoc;
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00004785 ExprResult E = DependentScopeDeclRefExpr::Create(
4786 Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
4787 nullptr);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004788
Douglas Gregore4ff4b52011-01-05 18:58:31 +00004789 // If we parsed the template argument as a pack expansion, create a
4790 // pack expansion expression.
4791 if (Arg.getArgument().getKind() == TemplateArgument::TemplateExpansion){
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004792 E = ActOnPackExpansion(E.get(), Arg.getTemplateEllipsisLoc());
John Wiegley01296292011-04-08 18:41:53 +00004793 if (E.isInvalid())
Douglas Gregore4ff4b52011-01-05 18:58:31 +00004794 return true;
Douglas Gregore4ff4b52011-01-05 18:58:31 +00004795 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004796
Douglas Gregorda0fb532009-11-11 19:31:23 +00004797 TemplateArgument Result;
Nikola Smiljanic01a75982014-05-29 10:55:11 +00004798 E = CheckTemplateArgument(NTTP, NTTPType, E.get(), Result);
John Wiegley01296292011-04-08 18:41:53 +00004799 if (E.isInvalid())
Douglas Gregorda0fb532009-11-11 19:31:23 +00004800 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004801
Douglas Gregor1ccc8412010-11-07 23:05:16 +00004802 Converted.push_back(Result);
Douglas Gregorda0fb532009-11-11 19:31:23 +00004803 break;
4804 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004805
Douglas Gregorda0fb532009-11-11 19:31:23 +00004806 // We have a template argument that actually does refer to a class
Richard Smith3f1b5d02011-05-05 21:57:07 +00004807 // template, alias template, or template template parameter, and
Douglas Gregorda0fb532009-11-11 19:31:23 +00004808 // therefore cannot be a non-type template argument.
4809 Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr)
4810 << Arg.getSourceRange();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004811
Douglas Gregorda0fb532009-11-11 19:31:23 +00004812 Diag(Param->getLocation(), diag::note_template_param_here);
4813 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004814
Douglas Gregorda0fb532009-11-11 19:31:23 +00004815 case TemplateArgument::Type: {
4816 // We have a non-type template parameter but the template
4817 // argument is a type.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004818
Douglas Gregorda0fb532009-11-11 19:31:23 +00004819 // C++ [temp.arg]p2:
4820 // In a template-argument, an ambiguity between a type-id and
4821 // an expression is resolved to a type-id, regardless of the
4822 // form of the corresponding template-parameter.
4823 //
4824 // We warn specifically about this case, since it can be rather
4825 // confusing for users.
4826 QualType T = Arg.getArgument().getAsType();
4827 SourceRange SR = Arg.getSourceRange();
4828 if (T->isFunctionType())
4829 Diag(SR.getBegin(), diag::err_template_arg_nontype_ambig) << SR << T;
4830 else
4831 Diag(SR.getBegin(), diag::err_template_arg_must_be_expr) << SR;
4832 Diag(Param->getLocation(), diag::note_template_param_here);
4833 return true;
4834 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004835
Douglas Gregorda0fb532009-11-11 19:31:23 +00004836 case TemplateArgument::Pack:
Jeffrey Yasskin1615d452009-12-12 05:05:38 +00004837 llvm_unreachable("Caller must expand template argument packs");
Douglas Gregorda0fb532009-11-11 19:31:23 +00004838 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004839
Douglas Gregorda0fb532009-11-11 19:31:23 +00004840 return false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004841 }
4842
4843
Douglas Gregorda0fb532009-11-11 19:31:23 +00004844 // Check template template parameters.
4845 TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(Param);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004846
Richard Smith5d331022018-03-08 01:07:33 +00004847 TemplateParameterList *Params = TempParm->getTemplateParameters();
4848 if (TempParm->isExpandedParameterPack())
4849 Params = TempParm->getExpansionTemplateParameters(ArgumentPackIndex);
4850
Douglas Gregorda0fb532009-11-11 19:31:23 +00004851 // Substitute into the template parameter list of the template
4852 // template parameter, since previously-supplied template arguments
4853 // may appear within the template template parameter.
Richard Smith5d331022018-03-08 01:07:33 +00004854 //
4855 // FIXME: Skip this if the parameters aren't instantiation-dependent.
Douglas Gregorda0fb532009-11-11 19:31:23 +00004856 {
4857 // Set up a template instantiation context.
4858 LocalInstantiationScope Scope(*this);
4859 InstantiatingTemplate Inst(*this, TemplateLoc, Template,
Richard Smith80934652012-07-16 01:09:10 +00004860 TempParm, Converted,
Douglas Gregorda0fb532009-11-11 19:31:23 +00004861 SourceRange(TemplateLoc, RAngleLoc));
Alp Tokerd4a72d52013-10-08 08:09:04 +00004862 if (Inst.isInvalid())
Richard Smith8a874c92012-07-08 02:38:24 +00004863 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004864
David Majnemer8b622692016-07-03 21:17:51 +00004865 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
Richard Smith5d331022018-03-08 01:07:33 +00004866 Params = SubstTemplateParams(Params, CurContext,
4867 MultiLevelTemplateArgumentList(TemplateArgs));
4868 if (!Params)
Douglas Gregorda0fb532009-11-11 19:31:23 +00004869 return true;
Douglas Gregorda0fb532009-11-11 19:31:23 +00004870 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004871
Richard Smith11255ec2017-01-18 19:19:22 +00004872 // C++1z [temp.local]p1: (DR1004)
4873 // When [the injected-class-name] is used [...] as a template-argument for
4874 // a template template-parameter [...] it refers to the class template
4875 // itself.
4876 if (Arg.getArgument().getKind() == TemplateArgument::Type) {
4877 TemplateArgumentLoc ConvertedArg = convertTypeTemplateArgumentToTemplate(
4878 Arg.getTypeSourceInfo()->getTypeLoc());
4879 if (!ConvertedArg.getArgument().isNull())
4880 Arg = ConvertedArg;
4881 }
4882
Douglas Gregorda0fb532009-11-11 19:31:23 +00004883 switch (Arg.getArgument().getKind()) {
4884 case TemplateArgument::Null:
David Blaikie83d382b2011-09-23 05:06:16 +00004885 llvm_unreachable("Should never see a NULL template argument here");
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004886
Douglas Gregorda0fb532009-11-11 19:31:23 +00004887 case TemplateArgument::Template:
Douglas Gregore4ff4b52011-01-05 18:58:31 +00004888 case TemplateArgument::TemplateExpansion:
Richard Smith5d331022018-03-08 01:07:33 +00004889 if (CheckTemplateTemplateArgument(Params, Arg))
Douglas Gregorda0fb532009-11-11 19:31:23 +00004890 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004891
Douglas Gregor1ccc8412010-11-07 23:05:16 +00004892 Converted.push_back(Arg.getArgument());
Douglas Gregorda0fb532009-11-11 19:31:23 +00004893 break;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004894
Douglas Gregorda0fb532009-11-11 19:31:23 +00004895 case TemplateArgument::Expression:
4896 case TemplateArgument::Type:
4897 // We have a template template parameter but the template
4898 // argument does not refer to a template.
Richard Smith3f1b5d02011-05-05 21:57:07 +00004899 Diag(Arg.getLocation(), diag::err_template_arg_must_be_template)
Richard Smith2bf7fdb2013-01-02 11:42:31 +00004900 << getLangOpts().CPlusPlus11;
Douglas Gregorda0fb532009-11-11 19:31:23 +00004901 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004902
Douglas Gregorda0fb532009-11-11 19:31:23 +00004903 case TemplateArgument::Declaration:
David Blaikie8a40f702012-01-17 06:56:22 +00004904 llvm_unreachable("Declaration argument with template template parameter");
Douglas Gregorda0fb532009-11-11 19:31:23 +00004905 case TemplateArgument::Integral:
David Blaikie8a40f702012-01-17 06:56:22 +00004906 llvm_unreachable("Integral argument with template template parameter");
Eli Friedmanb826a002012-09-26 02:36:12 +00004907 case TemplateArgument::NullPtr:
4908 llvm_unreachable("Null pointer argument with template template parameter");
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004909
Douglas Gregorda0fb532009-11-11 19:31:23 +00004910 case TemplateArgument::Pack:
Jeffrey Yasskin1615d452009-12-12 05:05:38 +00004911 llvm_unreachable("Caller must expand template argument packs");
Douglas Gregorda0fb532009-11-11 19:31:23 +00004912 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00004913
Douglas Gregorda0fb532009-11-11 19:31:23 +00004914 return false;
4915}
4916
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00004917/// Diagnose an arity mismatch in the
Douglas Gregor8e072612012-02-03 07:34:46 +00004918static bool diagnoseArityMismatch(Sema &S, TemplateDecl *Template,
4919 SourceLocation TemplateLoc,
4920 TemplateArgumentListInfo &TemplateArgs) {
4921 TemplateParameterList *Params = Template->getTemplateParameters();
4922 unsigned NumParams = Params->size();
4923 unsigned NumArgs = TemplateArgs.size();
4924
4925 SourceRange Range;
4926 if (NumArgs > NumParams)
Simon Pilgrim6905d222016-12-30 22:55:33 +00004927 Range = SourceRange(TemplateArgs[NumParams].getLocation(),
Douglas Gregor8e072612012-02-03 07:34:46 +00004928 TemplateArgs.getRAngleLoc());
4929 S.Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
4930 << (NumArgs > NumParams)
Richard Smith0c062b42017-01-14 02:19:59 +00004931 << (int)S.getTemplateNameKindForDiagnostics(TemplateName(Template))
Douglas Gregor8e072612012-02-03 07:34:46 +00004932 << Template << Range;
4933 S.Diag(Template->getLocation(), diag::note_template_decl_here)
4934 << Params->getSourceRange();
4935 return true;
4936}
4937
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00004938/// Check whether the template parameter is a pack expansion, and if so,
Richard Smith1fde8ec2012-09-07 02:06:42 +00004939/// determine the number of parameters produced by that expansion. For instance:
4940///
4941/// \code
4942/// template<typename ...Ts> struct A {
4943/// template<Ts ...NTs, template<Ts> class ...TTs, typename ...Us> struct B;
4944/// };
4945/// \endcode
4946///
4947/// In \c A<int,int>::B, \c NTs and \c TTs have expanded pack size 2, and \c Us
4948/// is not a pack expansion, so returns an empty Optional.
David Blaikie05785d12013-02-20 22:23:23 +00004949static Optional<unsigned> getExpandedPackSize(NamedDecl *Param) {
Richard Smith1fde8ec2012-09-07 02:06:42 +00004950 if (NonTypeTemplateParmDecl *NTTP
4951 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4952 if (NTTP->isExpandedParameterPack())
4953 return NTTP->getNumExpansionTypes();
4954 }
4955
4956 if (TemplateTemplateParmDecl *TTP
4957 = dyn_cast<TemplateTemplateParmDecl>(Param)) {
4958 if (TTP->isExpandedParameterPack())
4959 return TTP->getNumExpansionTemplateParameters();
4960 }
4961
David Blaikie7a30dc52013-02-21 01:47:18 +00004962 return None;
Richard Smith1fde8ec2012-09-07 02:06:42 +00004963}
4964
Richard Smith35c1df52015-06-17 20:16:32 +00004965/// Diagnose a missing template argument.
4966template<typename TemplateParmDecl>
4967static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc,
4968 TemplateDecl *TD,
4969 const TemplateParmDecl *D,
4970 TemplateArgumentListInfo &Args) {
4971 // Dig out the most recent declaration of the template parameter; there may be
4972 // declarations of the template that are more recent than TD.
4973 D = cast<TemplateParmDecl>(cast<TemplateDecl>(TD->getMostRecentDecl())
4974 ->getTemplateParameters()
4975 ->getParam(D->getIndex()));
4976
4977 // If there's a default argument that's not visible, diagnose that we're
4978 // missing a module import.
4979 llvm::SmallVector<Module*, 8> Modules;
4980 if (D->hasDefaultArgument() && !S.hasVisibleDefaultArgument(D, &Modules)) {
4981 S.diagnoseMissingImport(Loc, cast<NamedDecl>(TD),
4982 D->getDefaultArgumentLoc(), Modules,
4983 Sema::MissingImportKind::DefaultArgument,
Richard Smith6739a102016-05-05 00:56:12 +00004984 /*Recover*/true);
Richard Smith35c1df52015-06-17 20:16:32 +00004985 return true;
4986 }
4987
4988 // FIXME: If there's a more recent default argument that *is* visible,
4989 // diagnose that it was declared too late.
4990
4991 return diagnoseArityMismatch(S, TD, Loc, Args);
4992}
4993
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00004994/// Check that the given template argument list is well-formed
Douglas Gregord32e0282009-02-09 23:23:08 +00004995/// for specializing the given template.
Richard Smith11255ec2017-01-18 19:19:22 +00004996bool Sema::CheckTemplateArgumentList(
4997 TemplateDecl *Template, SourceLocation TemplateLoc,
4998 TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs,
4999 SmallVectorImpl<TemplateArgument> &Converted,
5000 bool UpdateArgsWithConversions) {
Richard Trieu15b66532015-01-24 02:48:32 +00005001 // Make a copy of the template arguments for processing. Only make the
5002 // changes at the end when successful in matching the arguments to the
5003 // template.
5004 TemplateArgumentListInfo NewArgs = TemplateArgs;
5005
Erich Keaneaf0795b2017-10-24 01:39:56 +00005006 // Make sure we get the template parameter list from the most
5007 // recentdeclaration, since that is the only one that has is guaranteed to
5008 // have all the default template argument information.
5009 TemplateParameterList *Params =
5010 cast<TemplateDecl>(Template->getMostRecentDecl())
5011 ->getTemplateParameters();
Douglas Gregord32e0282009-02-09 23:23:08 +00005012
Richard Trieu15b66532015-01-24 02:48:32 +00005013 SourceLocation RAngleLoc = NewArgs.getRAngleLoc();
John McCall6b51f282009-11-23 01:53:49 +00005014
Mike Stump11289f42009-09-09 15:08:12 +00005015 // C++ [temp.arg]p1:
Douglas Gregord32e0282009-02-09 23:23:08 +00005016 // [...] The type and form of each template-argument specified in
5017 // a template-id shall match the type and form specified for the
5018 // corresponding parameter declared by the template in its
5019 // template-parameter-list.
Douglas Gregor739b107a2011-03-03 02:41:12 +00005020 bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005021 SmallVector<TemplateArgument, 2> ArgumentPack;
Richard Trieu15b66532015-01-24 02:48:32 +00005022 unsigned ArgIdx = 0, NumArgs = NewArgs.size();
Douglas Gregorf143cd52011-01-24 16:14:37 +00005023 LocalInstantiationScope InstScope(*this, true);
Richard Smith1fde8ec2012-09-07 02:06:42 +00005024 for (TemplateParameterList::iterator Param = Params->begin(),
5025 ParamEnd = Params->end();
5026 Param != ParamEnd; /* increment in loop */) {
5027 // If we have an expanded parameter pack, make sure we don't have too
5028 // many arguments.
David Blaikie05785d12013-02-20 22:23:23 +00005029 if (Optional<unsigned> Expansions = getExpandedPackSize(*Param)) {
Richard Smith1fde8ec2012-09-07 02:06:42 +00005030 if (*Expansions == ArgumentPack.size()) {
5031 // We're done with this parameter pack. Pack up its arguments and add
5032 // them to the list.
Eli Friedmanb826a002012-09-26 02:36:12 +00005033 Converted.push_back(
Benjamin Kramercce63472015-08-05 09:40:22 +00005034 TemplateArgument::CreatePackCopy(Context, ArgumentPack));
Eli Friedmanb826a002012-09-26 02:36:12 +00005035 ArgumentPack.clear();
5036
Richard Smith1fde8ec2012-09-07 02:06:42 +00005037 // This argument is assigned to the next parameter.
5038 ++Param;
5039 continue;
5040 } else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
5041 // Not enough arguments for this parameter pack.
5042 Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5043 << false
Richard Smith0c062b42017-01-14 02:19:59 +00005044 << (int)getTemplateNameKindForDiagnostics(TemplateName(Template))
Richard Smith1fde8ec2012-09-07 02:06:42 +00005045 << Template;
5046 Diag(Template->getLocation(), diag::note_template_decl_here)
5047 << Params->getSourceRange();
5048 return true;
Douglas Gregor0231d8d2011-01-19 20:10:05 +00005049 }
Richard Smith1fde8ec2012-09-07 02:06:42 +00005050 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005051
Richard Smith1fde8ec2012-09-07 02:06:42 +00005052 if (ArgIdx < NumArgs) {
Douglas Gregor84d49a22009-11-11 21:54:23 +00005053 // Check the template argument we were given.
Richard Trieu15b66532015-01-24 02:48:32 +00005054 if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005055 TemplateLoc, RAngleLoc,
Douglas Gregor0231d8d2011-01-19 20:10:05 +00005056 ArgumentPack.size(), Converted))
Douglas Gregor84d49a22009-11-11 21:54:23 +00005057 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005058
Richard Smith96d71c32014-11-12 23:38:38 +00005059 bool PackExpansionIntoNonPack =
Richard Trieu15b66532015-01-24 02:48:32 +00005060 NewArgs[ArgIdx].getArgument().isPackExpansion() &&
Richard Smith96d71c32014-11-12 23:38:38 +00005061 (!(*Param)->isTemplateParameterPack() || getExpandedPackSize(*Param));
5062 if (PackExpansionIntoNonPack && isa<TypeAliasTemplateDecl>(Template)) {
Richard Smith83b11aa2014-01-09 02:22:22 +00005063 // Core issue 1430: we have a pack expansion as an argument to an
Richard Smith96d71c32014-11-12 23:38:38 +00005064 // alias template, and it's not part of a parameter pack. This
Richard Smith83b11aa2014-01-09 02:22:22 +00005065 // can't be canonicalized, so reject it now.
Richard Trieu15b66532015-01-24 02:48:32 +00005066 Diag(NewArgs[ArgIdx].getLocation(),
Richard Smith83b11aa2014-01-09 02:22:22 +00005067 diag::err_alias_template_expansion_into_fixed_list)
Richard Trieu15b66532015-01-24 02:48:32 +00005068 << NewArgs[ArgIdx].getSourceRange();
Richard Smith83b11aa2014-01-09 02:22:22 +00005069 Diag((*Param)->getLocation(), diag::note_template_param_here);
5070 return true;
5071 }
5072
Richard Smith1fde8ec2012-09-07 02:06:42 +00005073 // We're now done with this argument.
5074 ++ArgIdx;
5075
Douglas Gregor9abeaf52010-12-20 16:57:52 +00005076 if ((*Param)->isTemplateParameterPack()) {
5077 // The template parameter was a template parameter pack, so take the
5078 // deduced argument and place it on the argument pack. Note that we
5079 // stay on the same template parameter so that we can deduce more
5080 // arguments.
Robert Wilhelm25284cc2013-08-23 16:11:15 +00005081 ArgumentPack.push_back(Converted.pop_back_val());
Douglas Gregor9abeaf52010-12-20 16:57:52 +00005082 } else {
5083 // Move to the next template parameter.
5084 ++Param;
5085 }
Richard Smith1fde8ec2012-09-07 02:06:42 +00005086
Richard Smith96d71c32014-11-12 23:38:38 +00005087 // If we just saw a pack expansion into a non-pack, then directly convert
5088 // the remaining arguments, because we don't know what parameters they'll
5089 // match up with.
5090 if (PackExpansionIntoNonPack) {
5091 if (!ArgumentPack.empty()) {
Richard Smith1fde8ec2012-09-07 02:06:42 +00005092 // If we were part way through filling in an expanded parameter pack,
5093 // fall back to just producing individual arguments.
5094 Converted.insert(Converted.end(),
5095 ArgumentPack.begin(), ArgumentPack.end());
5096 ArgumentPack.clear();
5097 }
5098
5099 while (ArgIdx < NumArgs) {
Richard Trieu15b66532015-01-24 02:48:32 +00005100 Converted.push_back(NewArgs[ArgIdx].getArgument());
Richard Smith1fde8ec2012-09-07 02:06:42 +00005101 ++ArgIdx;
5102 }
5103
Richard Smith1fde8ec2012-09-07 02:06:42 +00005104 return false;
Douglas Gregor8e072612012-02-03 07:34:46 +00005105 }
Richard Smith1fde8ec2012-09-07 02:06:42 +00005106
Douglas Gregor84d49a22009-11-11 21:54:23 +00005107 continue;
Douglas Gregor264ec4f2009-02-17 01:05:43 +00005108 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005109
Douglas Gregor2f157c92011-06-03 02:59:40 +00005110 // If we're checking a partial template argument list, we're done.
5111 if (PartialTemplateArgs) {
5112 if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
Benjamin Kramercce63472015-08-05 09:40:22 +00005113 Converted.push_back(
5114 TemplateArgument::CreatePackCopy(Context, ArgumentPack));
5115
Richard Smith1fde8ec2012-09-07 02:06:42 +00005116 return false;
Douglas Gregor2f157c92011-06-03 02:59:40 +00005117 }
5118
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005119 // If we have a template parameter pack with no more corresponding
Douglas Gregor9abeaf52010-12-20 16:57:52 +00005120 // arguments, just break out now and we'll fill in the argument pack below.
Richard Smith1fde8ec2012-09-07 02:06:42 +00005121 if ((*Param)->isTemplateParameterPack()) {
5122 assert(!getExpandedPackSize(*Param) &&
5123 "Should have dealt with this already");
5124
5125 // A non-expanded parameter pack before the end of the parameter list
5126 // only occurs for an ill-formed template parameter list, unless we've
5127 // got a partial argument list for a function template, so just bail out.
5128 if (Param + 1 != ParamEnd)
5129 return true;
5130
Benjamin Kramercce63472015-08-05 09:40:22 +00005131 Converted.push_back(
5132 TemplateArgument::CreatePackCopy(Context, ArgumentPack));
Eli Friedmanb826a002012-09-26 02:36:12 +00005133 ArgumentPack.clear();
Richard Smith1fde8ec2012-09-07 02:06:42 +00005134
5135 ++Param;
5136 continue;
5137 }
5138
Douglas Gregor8e072612012-02-03 07:34:46 +00005139 // Check whether we have a default argument.
Douglas Gregor84d49a22009-11-11 21:54:23 +00005140 TemplateArgumentLoc Arg;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005141
Douglas Gregor84d49a22009-11-11 21:54:23 +00005142 // Retrieve the default template argument from the template
5143 // parameter. For each kind of template parameter, we substitute the
5144 // template arguments provided thus far and any "outer" template arguments
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005145 // (when the template parameter was part of a nested template) into
Douglas Gregor84d49a22009-11-11 21:54:23 +00005146 // the default argument.
5147 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
Richard Smith95d83952015-06-10 20:36:34 +00005148 if (!hasVisibleDefaultArgument(TTP))
Richard Smith35c1df52015-06-17 20:16:32 +00005149 return diagnoseMissingArgument(*this, TemplateLoc, Template, TTP,
5150 NewArgs);
Douglas Gregor84d49a22009-11-11 21:54:23 +00005151
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005152 TypeSourceInfo *ArgType = SubstDefaultTemplateArgument(*this,
Douglas Gregor84d49a22009-11-11 21:54:23 +00005153 Template,
5154 TemplateLoc,
5155 RAngleLoc,
5156 TTP,
5157 Converted);
5158 if (!ArgType)
5159 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005160
Douglas Gregor84d49a22009-11-11 21:54:23 +00005161 Arg = TemplateArgumentLoc(TemplateArgument(ArgType->getType()),
5162 ArgType);
5163 } else if (NonTypeTemplateParmDecl *NTTP
5164 = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
Richard Smith95d83952015-06-10 20:36:34 +00005165 if (!hasVisibleDefaultArgument(NTTP))
Richard Smith35c1df52015-06-17 20:16:32 +00005166 return diagnoseMissingArgument(*this, TemplateLoc, Template, NTTP,
5167 NewArgs);
Douglas Gregor84d49a22009-11-11 21:54:23 +00005168
John McCalldadc5752010-08-24 06:29:42 +00005169 ExprResult E = SubstDefaultTemplateArgument(*this, Template,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005170 TemplateLoc,
5171 RAngleLoc,
5172 NTTP,
Douglas Gregor84d49a22009-11-11 21:54:23 +00005173 Converted);
5174 if (E.isInvalid())
5175 return true;
5176
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005177 Expr *Ex = E.getAs<Expr>();
Douglas Gregor84d49a22009-11-11 21:54:23 +00005178 Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex);
5179 } else {
5180 TemplateTemplateParmDecl *TempParm
5181 = cast<TemplateTemplateParmDecl>(*Param);
5182
Richard Smith95d83952015-06-10 20:36:34 +00005183 if (!hasVisibleDefaultArgument(TempParm))
Richard Smith35c1df52015-06-17 20:16:32 +00005184 return diagnoseMissingArgument(*this, TemplateLoc, Template, TempParm,
5185 NewArgs);
Douglas Gregor84d49a22009-11-11 21:54:23 +00005186
Douglas Gregordf846d12011-03-02 18:46:51 +00005187 NestedNameSpecifierLoc QualifierLoc;
Douglas Gregor84d49a22009-11-11 21:54:23 +00005188 TemplateName Name = SubstDefaultTemplateArgument(*this, Template,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005189 TemplateLoc,
5190 RAngleLoc,
Douglas Gregor84d49a22009-11-11 21:54:23 +00005191 TempParm,
Douglas Gregor9d802122011-03-02 17:09:35 +00005192 Converted,
5193 QualifierLoc);
Douglas Gregor84d49a22009-11-11 21:54:23 +00005194 if (Name.isNull())
5195 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005196
Douglas Gregor9d802122011-03-02 17:09:35 +00005197 Arg = TemplateArgumentLoc(TemplateArgument(Name), QualifierLoc,
5198 TempParm->getDefaultArgument().getTemplateNameLoc());
Douglas Gregor84d49a22009-11-11 21:54:23 +00005199 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005200
Douglas Gregor84d49a22009-11-11 21:54:23 +00005201 // Introduce an instantiation record that describes where we are using
Richard Smith54f18e82016-08-31 02:15:21 +00005202 // the default template argument. We're not actually instantiating a
5203 // template here, we just create this object to put a note into the
5204 // context stack.
Alp Tokerd4a72d52013-10-08 08:09:04 +00005205 InstantiatingTemplate Inst(*this, RAngleLoc, Template, *Param, Converted,
5206 SourceRange(TemplateLoc, RAngleLoc));
5207 if (Inst.isInvalid())
Richard Smith8a874c92012-07-08 02:38:24 +00005208 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005209
Douglas Gregor84d49a22009-11-11 21:54:23 +00005210 // Check the default template argument.
Douglas Gregoreebed722009-11-11 19:41:09 +00005211 if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc,
Douglas Gregor0231d8d2011-01-19 20:10:05 +00005212 RAngleLoc, 0, Converted))
Douglas Gregorda0fb532009-11-11 19:31:23 +00005213 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005214
Richard Trieu15b66532015-01-24 02:48:32 +00005215 // Core issue 150 (assumed resolution): if this is a template template
5216 // parameter, keep track of the default template arguments from the
Douglas Gregor739b107a2011-03-03 02:41:12 +00005217 // template definition.
5218 if (isTemplateTemplateParameter)
Richard Trieu15b66532015-01-24 02:48:32 +00005219 NewArgs.addArgument(Arg);
5220
Douglas Gregor9abeaf52010-12-20 16:57:52 +00005221 // Move to the next template parameter and argument.
5222 ++Param;
5223 ++ArgIdx;
Douglas Gregord32e0282009-02-09 23:23:08 +00005224 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005225
Richard Smith07f79912014-06-06 16:00:50 +00005226 // If we're performing a partial argument substitution, allow any trailing
5227 // pack expansions; they might be empty. This can happen even if
5228 // PartialTemplateArgs is false (the list of arguments is complete but
5229 // still dependent).
5230 if (ArgIdx < NumArgs && CurrentInstantiationScope &&
5231 CurrentInstantiationScope->getPartiallySubstitutedPack()) {
Richard Trieu15b66532015-01-24 02:48:32 +00005232 while (ArgIdx < NumArgs && NewArgs[ArgIdx].getArgument().isPackExpansion())
5233 Converted.push_back(NewArgs[ArgIdx++].getArgument());
Richard Smith07f79912014-06-06 16:00:50 +00005234 }
5235
Douglas Gregor8e072612012-02-03 07:34:46 +00005236 // If we have any leftover arguments, then there were too many arguments.
5237 // Complain and fail.
5238 if (ArgIdx < NumArgs)
Richard Trieu15b66532015-01-24 02:48:32 +00005239 return diagnoseArityMismatch(*this, Template, TemplateLoc, NewArgs);
5240
5241 // No problems found with the new argument list, propagate changes back
5242 // to caller.
Richard Smith11255ec2017-01-18 19:19:22 +00005243 if (UpdateArgsWithConversions)
5244 TemplateArgs = std::move(NewArgs);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005245
Richard Smith1fde8ec2012-09-07 02:06:42 +00005246 return false;
Douglas Gregord32e0282009-02-09 23:23:08 +00005247}
5248
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005249namespace {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005250 class UnnamedLocalNoLinkageFinder
5251 : public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005252 {
5253 Sema &S;
5254 SourceRange SR;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005255
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005256 typedef TypeVisitor<UnnamedLocalNoLinkageFinder, bool> inherited;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005257
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005258 public:
5259 UnnamedLocalNoLinkageFinder(Sema &S, SourceRange SR) : S(S), SR(SR) { }
5260
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005261 bool Visit(QualType T) {
Daniel Jasper5cad6852017-01-02 22:55:45 +00005262 return T.isNull() ? false : inherited::Visit(T.getTypePtr());
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005263 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005264
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005265#define TYPE(Class, Parent) \
5266 bool Visit##Class##Type(const Class##Type *);
5267#define ABSTRACT_TYPE(Class, Parent) \
5268 bool Visit##Class##Type(const Class##Type *) { return false; }
5269#define NON_CANONICAL_TYPE(Class, Parent) \
5270 bool Visit##Class##Type(const Class##Type *) { return false; }
5271#include "clang/AST/TypeNodes.def"
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005272
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005273 bool VisitTagDecl(const TagDecl *Tag);
5274 bool VisitNestedNameSpecifier(NestedNameSpecifier *NNS);
5275 };
Eugene Zelenko1ced5092016-02-12 22:53:10 +00005276} // end anonymous namespace
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005277
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005278bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(const BuiltinType*) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005279 return false;
5280}
5281
5282bool UnnamedLocalNoLinkageFinder::VisitComplexType(const ComplexType* T) {
5283 return Visit(T->getElementType());
5284}
5285
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005286bool UnnamedLocalNoLinkageFinder::VisitPointerType(const PointerType* T) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005287 return Visit(T->getPointeeType());
5288}
5289
5290bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005291 const BlockPointerType* T) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005292 return Visit(T->getPointeeType());
5293}
5294
5295bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005296 const LValueReferenceType* T) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005297 return Visit(T->getPointeeType());
5298}
5299
5300bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005301 const RValueReferenceType* T) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005302 return Visit(T->getPointeeType());
5303}
5304
5305bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005306 const MemberPointerType* T) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005307 return Visit(T->getPointeeType()) || Visit(QualType(T->getClass(), 0));
5308}
5309
5310bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005311 const ConstantArrayType* T) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005312 return Visit(T->getElementType());
5313}
5314
5315bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005316 const IncompleteArrayType* T) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005317 return Visit(T->getElementType());
5318}
5319
5320bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005321 const VariableArrayType* T) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005322 return Visit(T->getElementType());
5323}
5324
5325bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005326 const DependentSizedArrayType* T) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005327 return Visit(T->getElementType());
5328}
5329
5330bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005331 const DependentSizedExtVectorType* T) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005332 return Visit(T->getElementType());
5333}
5334
Andrew Gozillon572bbb02017-10-02 06:25:51 +00005335bool UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(
5336 const DependentAddressSpaceType *T) {
5337 return Visit(T->getPointeeType());
5338}
5339
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005340bool UnnamedLocalNoLinkageFinder::VisitVectorType(const VectorType* T) {
5341 return Visit(T->getElementType());
5342}
5343
5344bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(const ExtVectorType* T) {
5345 return Visit(T->getElementType());
5346}
5347
5348bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
5349 const FunctionProtoType* T) {
Aaron Ballman40bd0aa2014-03-17 15:23:01 +00005350 for (const auto &A : T->param_types()) {
5351 if (Visit(A))
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005352 return true;
5353 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005354
Alp Toker314cc812014-01-25 16:55:45 +00005355 return Visit(T->getReturnType());
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005356}
5357
5358bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
5359 const FunctionNoProtoType* T) {
Alp Toker314cc812014-01-25 16:55:45 +00005360 return Visit(T->getReturnType());
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005361}
5362
5363bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
5364 const UnresolvedUsingType*) {
5365 return false;
5366}
5367
5368bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(const TypeOfExprType*) {
5369 return false;
5370}
5371
5372bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(const TypeOfType* T) {
5373 return Visit(T->getUnderlyingType());
5374}
5375
5376bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType*) {
5377 return false;
5378}
5379
Alexis Hunte852b102011-05-24 22:41:36 +00005380bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
5381 const UnaryTransformType*) {
5382 return false;
5383}
5384
Richard Smith30482bc2011-02-20 03:19:35 +00005385bool UnnamedLocalNoLinkageFinder::VisitAutoType(const AutoType *T) {
5386 return Visit(T->getDeducedType());
5387}
5388
Richard Smith600b5262017-01-26 20:40:47 +00005389bool UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(
5390 const DeducedTemplateSpecializationType *T) {
5391 return Visit(T->getDeducedType());
5392}
5393
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005394bool UnnamedLocalNoLinkageFinder::VisitRecordType(const RecordType* T) {
5395 return VisitTagDecl(T->getDecl());
5396}
5397
5398bool UnnamedLocalNoLinkageFinder::VisitEnumType(const EnumType* T) {
5399 return VisitTagDecl(T->getDecl());
5400}
5401
5402bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
5403 const TemplateTypeParmType*) {
5404 return false;
5405}
5406
Douglas Gregorada4b792011-01-14 02:55:32 +00005407bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
5408 const SubstTemplateTypeParmPackType *) {
5409 return false;
5410}
5411
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005412bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
5413 const TemplateSpecializationType*) {
5414 return false;
5415}
5416
5417bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
5418 const InjectedClassNameType* T) {
5419 return VisitTagDecl(T->getDecl());
5420}
5421
5422bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
5423 const DependentNameType* T) {
5424 return VisitNestedNameSpecifier(T->getQualifier());
5425}
5426
5427bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
5428 const DependentTemplateSpecializationType* T) {
5429 return VisitNestedNameSpecifier(T->getQualifier());
5430}
5431
Douglas Gregord2fa7662010-12-20 02:24:11 +00005432bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
5433 const PackExpansionType* T) {
5434 return Visit(T->getPattern());
5435}
5436
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005437bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType *) {
5438 return false;
5439}
5440
5441bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
5442 const ObjCInterfaceType *) {
5443 return false;
5444}
5445
5446bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
5447 const ObjCObjectPointerType *) {
5448 return false;
5449}
5450
Eli Friedman0dfb8892011-10-06 23:00:33 +00005451bool UnnamedLocalNoLinkageFinder::VisitAtomicType(const AtomicType* T) {
5452 return Visit(T->getValueType());
5453}
5454
Xiuli Pan9c14e282016-01-09 12:53:17 +00005455bool UnnamedLocalNoLinkageFinder::VisitPipeType(const PipeType* T) {
5456 return false;
5457}
5458
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005459bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl *Tag) {
5460 if (Tag->getDeclContext()->isFunctionOrMethod()) {
Richard Smith0bf8a4922011-10-18 20:49:44 +00005461 S.Diag(SR.getBegin(),
Richard Smith2bf7fdb2013-01-02 11:42:31 +00005462 S.getLangOpts().CPlusPlus11 ?
Richard Smith0bf8a4922011-10-18 20:49:44 +00005463 diag::warn_cxx98_compat_template_arg_local_type :
5464 diag::ext_template_arg_local_type)
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005465 << S.Context.getTypeDeclType(Tag) << SR;
5466 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005467 }
5468
John McCall5ea95772013-03-09 00:54:27 +00005469 if (!Tag->hasNameForLinkage()) {
Richard Smith0bf8a4922011-10-18 20:49:44 +00005470 S.Diag(SR.getBegin(),
Richard Smith2bf7fdb2013-01-02 11:42:31 +00005471 S.getLangOpts().CPlusPlus11 ?
Richard Smith0bf8a4922011-10-18 20:49:44 +00005472 diag::warn_cxx98_compat_template_arg_unnamed_type :
5473 diag::ext_template_arg_unnamed_type) << SR;
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005474 S.Diag(Tag->getLocation(), diag::note_template_unnamed_type_here);
5475 return true;
5476 }
5477
5478 return false;
5479}
5480
5481bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
5482 NestedNameSpecifier *NNS) {
5483 if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix()))
5484 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005485
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005486 switch (NNS->getKind()) {
5487 case NestedNameSpecifier::Identifier:
5488 case NestedNameSpecifier::Namespace:
Douglas Gregor7b26ff92011-02-24 02:36:08 +00005489 case NestedNameSpecifier::NamespaceAlias:
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005490 case NestedNameSpecifier::Global:
Nikola Smiljanic67860242014-09-26 00:28:20 +00005491 case NestedNameSpecifier::Super:
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005492 return false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005493
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005494 case NestedNameSpecifier::TypeSpec:
5495 case NestedNameSpecifier::TypeSpecWithTemplate:
5496 return Visit(QualType(NNS->getAsType(), 0));
5497 }
David Blaikie8a40f702012-01-17 06:56:22 +00005498 llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005499}
5500
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00005501/// Check a template argument against its corresponding
Douglas Gregord32e0282009-02-09 23:23:08 +00005502/// template type parameter.
5503///
5504/// This routine implements the semantics of C++ [temp.arg.type]. It
5505/// returns true if an error occurred, and false otherwise.
Mike Stump11289f42009-09-09 15:08:12 +00005506bool Sema::CheckTemplateArgument(TemplateTypeParmDecl *Param,
John McCallbcd03502009-12-07 02:54:59 +00005507 TypeSourceInfo *ArgInfo) {
5508 assert(ArgInfo && "invalid TypeSourceInfo");
John McCall0ad16662009-10-29 08:12:44 +00005509 QualType Arg = ArgInfo->getType();
Douglas Gregor959d5a02010-05-22 16:17:30 +00005510 SourceRange SR = ArgInfo->getTypeLoc().getSourceRange();
Chandler Carruth9bb67f42010-09-03 21:12:34 +00005511
5512 if (Arg->isVariablyModifiedType()) {
5513 return Diag(SR.getBegin(), diag::err_variably_modified_template_arg) << Arg;
Douglas Gregor8364e6b2009-12-21 23:17:24 +00005514 } else if (Context.hasSameUnqualifiedType(Arg, Context.OverloadTy)) {
Douglas Gregor8364e6b2009-12-21 23:17:24 +00005515 return Diag(SR.getBegin(), diag::err_template_arg_overload_type) << SR;
Douglas Gregord32e0282009-02-09 23:23:08 +00005516 }
5517
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005518 // C++03 [temp.arg.type]p2:
5519 // A local type, a type with no linkage, an unnamed type or a type
5520 // compounded from any of these types shall not be used as a
5521 // template-argument for a template type-parameter.
5522 //
Richard Smith0bf8a4922011-10-18 20:49:44 +00005523 // C++11 allows these, and even in C++03 we allow them as an extension with
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005524 // a warning.
Daniel Jasper5cad6852017-01-02 22:55:45 +00005525 if (LangOpts.CPlusPlus11 || Arg->hasUnnamedOrLocalType()) {
Douglas Gregor7731d3f2010-10-13 00:27:52 +00005526 UnnamedLocalNoLinkageFinder Finder(*this, SR);
5527 (void)Finder.Visit(Context.getCanonicalType(Arg));
5528 }
5529
Douglas Gregord32e0282009-02-09 23:23:08 +00005530 return false;
5531}
5532
Douglas Gregor20fdef32012-04-10 17:08:25 +00005533enum NullPointerValueKind {
5534 NPV_NotNullPointer,
5535 NPV_NullPointer,
5536 NPV_Error
5537};
5538
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00005539/// Determine whether the given template argument is a null pointer
Douglas Gregor20fdef32012-04-10 17:08:25 +00005540/// value of the appropriate type.
5541static NullPointerValueKind
5542isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param,
Reid Klecknercd016d82017-07-07 22:04:29 +00005543 QualType ParamType, Expr *Arg,
5544 Decl *Entity = nullptr) {
Douglas Gregor20fdef32012-04-10 17:08:25 +00005545 if (Arg->isValueDependent() || Arg->isTypeDependent())
5546 return NPV_NotNullPointer;
David Majnemer69c3ddc2015-09-11 20:18:09 +00005547
Reid Klecknercd016d82017-07-07 22:04:29 +00005548 // dllimport'd entities aren't constant but are available inside of template
5549 // arguments.
5550 if (Entity && Entity->hasAttr<DLLImportAttr>())
5551 return NPV_NotNullPointer;
5552
Richard Smithdb0ac552015-12-18 22:40:25 +00005553 if (!S.isCompleteType(Arg->getExprLoc(), ParamType))
David Majnemerb54368c2015-09-11 20:55:29 +00005554 llvm_unreachable(
5555 "Incomplete parameter type in isNullPointerValueTemplateArgument!");
David Majnemer69c3ddc2015-09-11 20:18:09 +00005556
David Majnemer5c734ad2014-08-14 00:49:23 +00005557 if (!S.getLangOpts().CPlusPlus11)
Douglas Gregor20fdef32012-04-10 17:08:25 +00005558 return NPV_NotNullPointer;
Simon Pilgrim6905d222016-12-30 22:55:33 +00005559
Douglas Gregor20fdef32012-04-10 17:08:25 +00005560 // Determine whether we have a constant expression.
Douglas Gregor350880c2012-04-10 19:03:30 +00005561 ExprResult ArgRV = S.DefaultFunctionArrayConversion(Arg);
5562 if (ArgRV.isInvalid())
5563 return NPV_Error;
Nikola Smiljanic01a75982014-05-29 10:55:11 +00005564 Arg = ArgRV.get();
Simon Pilgrim6905d222016-12-30 22:55:33 +00005565
Douglas Gregor20fdef32012-04-10 17:08:25 +00005566 Expr::EvalResult EvalResult;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00005567 SmallVector<PartialDiagnosticAt, 8> Notes;
Douglas Gregor350880c2012-04-10 19:03:30 +00005568 EvalResult.Diag = &Notes;
Douglas Gregor20fdef32012-04-10 17:08:25 +00005569 if (!Arg->EvaluateAsRValue(EvalResult, S.Context) ||
Douglas Gregor350880c2012-04-10 19:03:30 +00005570 EvalResult.HasSideEffects) {
5571 SourceLocation DiagLoc = Arg->getExprLoc();
Simon Pilgrim6905d222016-12-30 22:55:33 +00005572
Douglas Gregor350880c2012-04-10 19:03:30 +00005573 // If our only note is the usual "invalid subexpression" note, just point
5574 // the caret at its location rather than producing an essentially
5575 // redundant note.
5576 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
5577 diag::note_invalid_subexpr_in_const_expr) {
5578 DiagLoc = Notes[0].first;
5579 Notes.clear();
5580 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00005581
Douglas Gregor350880c2012-04-10 19:03:30 +00005582 S.Diag(DiagLoc, diag::err_template_arg_not_address_constant)
5583 << Arg->getType() << Arg->getSourceRange();
5584 for (unsigned I = 0, N = Notes.size(); I != N; ++I)
5585 S.Diag(Notes[I].first, Notes[I].second);
Simon Pilgrim6905d222016-12-30 22:55:33 +00005586
Douglas Gregor350880c2012-04-10 19:03:30 +00005587 S.Diag(Param->getLocation(), diag::note_template_param_here);
5588 return NPV_Error;
5589 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00005590
Douglas Gregor20fdef32012-04-10 17:08:25 +00005591 // C++11 [temp.arg.nontype]p1:
5592 // - an address constant expression of type std::nullptr_t
5593 if (Arg->getType()->isNullPtrType())
5594 return NPV_NullPointer;
Simon Pilgrim6905d222016-12-30 22:55:33 +00005595
Douglas Gregor20fdef32012-04-10 17:08:25 +00005596 // - a constant expression that evaluates to a null pointer value (4.10); or
5597 // - a constant expression that evaluates to a null member pointer value
5598 // (4.11); or
5599 if ((EvalResult.Val.isLValue() && !EvalResult.Val.getLValueBase()) ||
5600 (EvalResult.Val.isMemberPointer() &&
5601 !EvalResult.Val.getMemberPointerDecl())) {
5602 // If our expression has an appropriate type, we've succeeded.
5603 bool ObjCLifetimeConversion;
5604 if (S.Context.hasSameUnqualifiedType(Arg->getType(), ParamType) ||
5605 S.IsQualificationConversion(Arg->getType(), ParamType, false,
5606 ObjCLifetimeConversion))
5607 return NPV_NullPointer;
Simon Pilgrim6905d222016-12-30 22:55:33 +00005608
Douglas Gregor20fdef32012-04-10 17:08:25 +00005609 // The types didn't match, but we know we got a null pointer; complain,
5610 // then recover as if the types were correct.
5611 S.Diag(Arg->getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
5612 << Arg->getType() << ParamType << Arg->getSourceRange();
5613 S.Diag(Param->getLocation(), diag::note_template_param_here);
5614 return NPV_NullPointer;
5615 }
5616
5617 // If we don't have a null pointer value, but we do have a NULL pointer
5618 // constant, suggest a cast to the appropriate type.
5619 if (Arg->isNullPointerConstant(S.Context, Expr::NPC_NeverValueDependent)) {
5620 std::string Code = "static_cast<" + ParamType.getAsString() + ">(";
5621 S.Diag(Arg->getExprLoc(), diag::err_template_arg_untyped_null_constant)
Alp Tokerb6cc5922014-05-03 03:45:55 +00005622 << ParamType << FixItHint::CreateInsertion(Arg->getLocStart(), Code)
5623 << FixItHint::CreateInsertion(S.getLocForEndOfToken(Arg->getLocEnd()),
5624 ")");
Douglas Gregor20fdef32012-04-10 17:08:25 +00005625 S.Diag(Param->getLocation(), diag::note_template_param_here);
5626 return NPV_NullPointer;
5627 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00005628
Douglas Gregor20fdef32012-04-10 17:08:25 +00005629 // FIXME: If we ever want to support general, address-constant expressions
5630 // as non-type template arguments, we should return the ExprResult here to
5631 // be interpreted by the caller.
5632 return NPV_NotNullPointer;
5633}
5634
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00005635/// Checks whether the given template argument is compatible with its
David Majnemer61c39a12013-08-23 05:39:39 +00005636/// template parameter.
5637static bool CheckTemplateArgumentIsCompatibleWithParameter(
5638 Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
5639 Expr *Arg, QualType ArgType) {
5640 bool ObjCLifetimeConversion;
5641 if (ParamType->isPointerType() &&
5642 !ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType() &&
5643 S.IsQualificationConversion(ArgType, ParamType, false,
5644 ObjCLifetimeConversion)) {
5645 // For pointer-to-object types, qualification conversions are
5646 // permitted.
5647 } else {
5648 if (const ReferenceType *ParamRef = ParamType->getAs<ReferenceType>()) {
5649 if (!ParamRef->getPointeeType()->isFunctionType()) {
5650 // C++ [temp.arg.nontype]p5b3:
5651 // For a non-type template-parameter of type reference to
5652 // object, no conversions apply. The type referred to by the
5653 // reference may be more cv-qualified than the (otherwise
5654 // identical) type of the template- argument. The
5655 // template-parameter is bound directly to the
5656 // template-argument, which shall be an lvalue.
5657
5658 // FIXME: Other qualifiers?
5659 unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
5660 unsigned ArgQuals = ArgType.getCVRQualifiers();
5661
5662 if ((ParamQuals | ArgQuals) != ParamQuals) {
5663 S.Diag(Arg->getLocStart(),
5664 diag::err_template_arg_ref_bind_ignores_quals)
5665 << ParamType << Arg->getType() << Arg->getSourceRange();
5666 S.Diag(Param->getLocation(), diag::note_template_param_here);
5667 return true;
5668 }
5669 }
5670 }
5671
5672 // At this point, the template argument refers to an object or
5673 // function with external linkage. We now need to check whether the
5674 // argument and parameter types are compatible.
5675 if (!S.Context.hasSameUnqualifiedType(ArgType,
5676 ParamType.getNonReferenceType())) {
5677 // We can't perform this conversion or binding.
5678 if (ParamType->isReferenceType())
5679 S.Diag(Arg->getLocStart(), diag::err_template_arg_no_ref_bind)
5680 << ParamType << ArgIn->getType() << Arg->getSourceRange();
5681 else
5682 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_convertible)
5683 << ArgIn->getType() << ParamType << Arg->getSourceRange();
5684 S.Diag(Param->getLocation(), diag::note_template_param_here);
5685 return true;
5686 }
5687 }
5688
5689 return false;
5690}
5691
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00005692/// Checks whether the given template argument is the address
Douglas Gregorccb07762009-02-11 19:52:55 +00005693/// of an object or function according to C++ [temp.arg.nontype]p1.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00005694static bool
Douglas Gregorb242683d2010-04-01 18:32:35 +00005695CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S,
5696 NonTypeTemplateParmDecl *Param,
5697 QualType ParamType,
5698 Expr *ArgIn,
5699 TemplateArgument &Converted) {
Douglas Gregorccb07762009-02-11 19:52:55 +00005700 bool Invalid = false;
Douglas Gregorb242683d2010-04-01 18:32:35 +00005701 Expr *Arg = ArgIn;
5702 QualType ArgType = Arg->getType();
Douglas Gregorccb07762009-02-11 19:52:55 +00005703
Douglas Gregorb242683d2010-04-01 18:32:35 +00005704 bool AddressTaken = false;
5705 SourceLocation AddrOpLoc;
David Majnemer61c39a12013-08-23 05:39:39 +00005706 if (S.getLangOpts().MicrosoftExt) {
5707 // Microsoft Visual C++ strips all casts, allows an arbitrary number of
5708 // dereference and address-of operators.
5709 Arg = Arg->IgnoreParenCasts();
5710
5711 bool ExtWarnMSTemplateArg = false;
5712 UnaryOperatorKind FirstOpKind;
5713 SourceLocation FirstOpLoc;
5714 while (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
5715 UnaryOperatorKind UnOpKind = UnOp->getOpcode();
5716 if (UnOpKind == UO_Deref)
5717 ExtWarnMSTemplateArg = true;
5718 if (UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {
5719 Arg = UnOp->getSubExpr()->IgnoreParenCasts();
5720 if (!AddrOpLoc.isValid()) {
5721 FirstOpKind = UnOpKind;
5722 FirstOpLoc = UnOp->getOperatorLoc();
5723 }
5724 } else
5725 break;
Douglas Gregorb242683d2010-04-01 18:32:35 +00005726 }
David Majnemer61c39a12013-08-23 05:39:39 +00005727 if (FirstOpLoc.isValid()) {
5728 if (ExtWarnMSTemplateArg)
5729 S.Diag(ArgIn->getLocStart(), diag::ext_ms_deref_template_argument)
5730 << ArgIn->getSourceRange();
John McCall7c454bb2011-07-15 05:09:51 +00005731
David Majnemer61c39a12013-08-23 05:39:39 +00005732 if (FirstOpKind == UO_AddrOf)
5733 AddressTaken = true;
5734 else if (Arg->getType()->isPointerType()) {
5735 // We cannot let pointers get dereferenced here, that is obviously not a
5736 // constant expression.
5737 assert(FirstOpKind == UO_Deref);
5738 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
5739 << Arg->getSourceRange();
5740 }
5741 }
5742 } else {
5743 // See through any implicit casts we added to fix the type.
5744 Arg = Arg->IgnoreImpCasts();
John McCall7c454bb2011-07-15 05:09:51 +00005745
David Majnemer61c39a12013-08-23 05:39:39 +00005746 // C++ [temp.arg.nontype]p1:
5747 //
5748 // A template-argument for a non-type, non-template
5749 // template-parameter shall be one of: [...]
5750 //
5751 // -- the address of an object or function with external
5752 // linkage, including function templates and function
5753 // template-ids but excluding non-static class members,
5754 // expressed as & id-expression where the & is optional if
5755 // the name refers to a function or array, or if the
5756 // corresponding template-parameter is a reference; or
5757
5758 // In C++98/03 mode, give an extension warning on any extra parentheses.
5759 // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
5760 bool ExtraParens = false;
5761 while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
5762 if (!Invalid && !ExtraParens) {
5763 S.Diag(Arg->getLocStart(),
5764 S.getLangOpts().CPlusPlus11
5765 ? diag::warn_cxx98_compat_template_arg_extra_parens
5766 : diag::ext_template_arg_extra_parens)
5767 << Arg->getSourceRange();
5768 ExtraParens = true;
5769 }
5770
5771 Arg = Parens->getSubExpr();
5772 }
5773
5774 while (SubstNonTypeTemplateParmExpr *subst =
5775 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
5776 Arg = subst->getReplacement()->IgnoreImpCasts();
5777
5778 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
5779 if (UnOp->getOpcode() == UO_AddrOf) {
5780 Arg = UnOp->getSubExpr();
5781 AddressTaken = true;
5782 AddrOpLoc = UnOp->getOperatorLoc();
5783 }
5784 }
5785
5786 while (SubstNonTypeTemplateParmExpr *subst =
5787 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
5788 Arg = subst->getReplacement()->IgnoreImpCasts();
5789 }
John McCall7c454bb2011-07-15 05:09:51 +00005790
David Majnemer07910d62014-06-26 07:48:46 +00005791 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg);
5792 ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;
5793
5794 // If our parameter has pointer type, check for a null template value.
5795 if (ParamType->isPointerType() || ParamType->isNullPtrType()) {
Reid Klecknercd016d82017-07-07 22:04:29 +00005796 switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ArgIn,
5797 Entity)) {
David Majnemer07910d62014-06-26 07:48:46 +00005798 case NPV_NullPointer:
5799 S.Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
Richard Smith78bb36f2014-07-24 02:27:39 +00005800 Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
5801 /*isNullPtr=*/true);
David Majnemer07910d62014-06-26 07:48:46 +00005802 return false;
5803
5804 case NPV_Error:
5805 return true;
5806
5807 case NPV_NotNullPointer:
5808 break;
5809 }
5810 }
5811
Chandler Carruth724a8a12010-01-31 10:01:20 +00005812 // Stop checking the precise nature of the argument if it is value dependent,
5813 // it should be checked when instantiated.
Douglas Gregorb242683d2010-04-01 18:32:35 +00005814 if (Arg->isValueDependent()) {
John McCallc3007a22010-10-26 07:05:15 +00005815 Converted = TemplateArgument(ArgIn);
Chandler Carruth724a8a12010-01-31 10:01:20 +00005816 return false;
Douglas Gregorb242683d2010-04-01 18:32:35 +00005817 }
David Majnemer61c39a12013-08-23 05:39:39 +00005818
5819 if (isa<CXXUuidofExpr>(Arg)) {
5820 if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType,
5821 ArgIn, Arg, ArgType))
5822 return true;
5823
5824 Converted = TemplateArgument(ArgIn);
5825 return false;
5826 }
5827
Douglas Gregor31f55dc2012-04-06 22:40:38 +00005828 if (!DRE) {
5829 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
5830 << Arg->getSourceRange();
5831 S.Diag(Param->getLocation(), diag::note_template_param_here);
5832 return true;
5833 }
Chandler Carruth724a8a12010-01-31 10:01:20 +00005834
Douglas Gregorccb07762009-02-11 19:52:55 +00005835 // Cannot refer to non-static data members
David Majnemer6bedcfa2013-10-26 06:12:44 +00005836 if (isa<FieldDecl>(Entity) || isa<IndirectFieldDecl>(Entity)) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00005837 S.Diag(Arg->getLocStart(), diag::err_template_arg_field)
David Majnemer6bedcfa2013-10-26 06:12:44 +00005838 << Entity << Arg->getSourceRange();
Douglas Gregorb242683d2010-04-01 18:32:35 +00005839 S.Diag(Param->getLocation(), diag::note_template_param_here);
5840 return true;
5841 }
Douglas Gregorccb07762009-02-11 19:52:55 +00005842
5843 // Cannot refer to non-static member functions
Richard Smith9380e0e2012-04-04 21:11:30 +00005844 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) {
Douglas Gregorb242683d2010-04-01 18:32:35 +00005845 if (!Method->isStatic()) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00005846 S.Diag(Arg->getLocStart(), diag::err_template_arg_method)
Douglas Gregorccb07762009-02-11 19:52:55 +00005847 << Method << Arg->getSourceRange();
Douglas Gregorb242683d2010-04-01 18:32:35 +00005848 S.Diag(Param->getLocation(), diag::note_template_param_here);
5849 return true;
5850 }
Richard Smith9380e0e2012-04-04 21:11:30 +00005851 }
Mike Stump11289f42009-09-09 15:08:12 +00005852
Richard Smith9380e0e2012-04-04 21:11:30 +00005853 FunctionDecl *Func = dyn_cast<FunctionDecl>(Entity);
5854 VarDecl *Var = dyn_cast<VarDecl>(Entity);
Douglas Gregorccb07762009-02-11 19:52:55 +00005855
Richard Smith9380e0e2012-04-04 21:11:30 +00005856 // A non-type template argument must refer to an object or function.
5857 if (!Func && !Var) {
5858 // We found something, but we don't know specifically what it is.
5859 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_object_or_func)
5860 << Arg->getSourceRange();
5861 S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
5862 return true;
5863 }
Douglas Gregorccb07762009-02-11 19:52:55 +00005864
Richard Smith9380e0e2012-04-04 21:11:30 +00005865 // Address / reference template args must have external linkage in C++98.
Rafael Espindola3ae00052013-05-13 00:12:11 +00005866 if (Entity->getFormalLinkage() == InternalLinkage) {
Richard Smith2bf7fdb2013-01-02 11:42:31 +00005867 S.Diag(Arg->getLocStart(), S.getLangOpts().CPlusPlus11 ?
Richard Smith9380e0e2012-04-04 21:11:30 +00005868 diag::warn_cxx98_compat_template_arg_object_internal :
5869 diag::ext_template_arg_object_internal)
5870 << !Func << Entity << Arg->getSourceRange();
5871 S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
5872 << !Func;
Rafael Espindola3ae00052013-05-13 00:12:11 +00005873 } else if (!Entity->hasLinkage()) {
Richard Smith9380e0e2012-04-04 21:11:30 +00005874 S.Diag(Arg->getLocStart(), diag::err_template_arg_object_no_linkage)
5875 << !Func << Entity << Arg->getSourceRange();
5876 S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
5877 << !Func;
5878 return true;
5879 }
5880
5881 if (Func) {
Douglas Gregorb242683d2010-04-01 18:32:35 +00005882 // If the template parameter has pointer type, the function decays.
5883 if (ParamType->isPointerType() && !AddressTaken)
5884 ArgType = S.Context.getPointerType(Func->getType());
5885 else if (AddressTaken && ParamType->isReferenceType()) {
5886 // If we originally had an address-of operator, but the
5887 // parameter has reference type, complain and (if things look
5888 // like they will work) drop the address-of operator.
5889 if (!S.Context.hasSameUnqualifiedType(Func->getType(),
5890 ParamType.getNonReferenceType())) {
5891 S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5892 << ParamType;
5893 S.Diag(Param->getLocation(), diag::note_template_param_here);
5894 return true;
5895 }
5896
5897 S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5898 << ParamType
5899 << FixItHint::CreateRemoval(AddrOpLoc);
5900 S.Diag(Param->getLocation(), diag::note_template_param_here);
5901
5902 ArgType = Func->getType();
5903 }
Richard Smith9380e0e2012-04-04 21:11:30 +00005904 } else {
Douglas Gregorb242683d2010-04-01 18:32:35 +00005905 // A value of reference type is not an object.
5906 if (Var->getType()->isReferenceType()) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00005907 S.Diag(Arg->getLocStart(),
Douglas Gregorb242683d2010-04-01 18:32:35 +00005908 diag::err_template_arg_reference_var)
5909 << Var->getType() << Arg->getSourceRange();
5910 S.Diag(Param->getLocation(), diag::note_template_param_here);
5911 return true;
5912 }
5913
Richard Smith9380e0e2012-04-04 21:11:30 +00005914 // A template argument must have static storage duration.
Richard Smithfd3834f2013-04-13 02:43:54 +00005915 if (Var->getTLSKind()) {
Richard Smith9380e0e2012-04-04 21:11:30 +00005916 S.Diag(Arg->getLocStart(), diag::err_template_arg_thread_local)
5917 << Arg->getSourceRange();
5918 S.Diag(Var->getLocation(), diag::note_template_arg_refers_here);
5919 return true;
5920 }
Douglas Gregorb242683d2010-04-01 18:32:35 +00005921
5922 // If the template parameter has pointer type, we must have taken
5923 // the address of this object.
5924 if (ParamType->isReferenceType()) {
5925 if (AddressTaken) {
5926 // If we originally had an address-of operator, but the
5927 // parameter has reference type, complain and (if things look
5928 // like they will work) drop the address-of operator.
5929 if (!S.Context.hasSameUnqualifiedType(Var->getType(),
5930 ParamType.getNonReferenceType())) {
5931 S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5932 << ParamType;
5933 S.Diag(Param->getLocation(), diag::note_template_param_here);
5934 return true;
5935 }
5936
5937 S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5938 << ParamType
5939 << FixItHint::CreateRemoval(AddrOpLoc);
5940 S.Diag(Param->getLocation(), diag::note_template_param_here);
5941
5942 ArgType = Var->getType();
5943 }
5944 } else if (!AddressTaken && ParamType->isPointerType()) {
5945 if (Var->getType()->isArrayType()) {
5946 // Array-to-pointer decay.
5947 ArgType = S.Context.getArrayDecayedType(Var->getType());
5948 } else {
5949 // If the template parameter has pointer type but the address of
5950 // this object was not taken, complain and (possibly) recover by
5951 // taking the address of the entity.
5952 ArgType = S.Context.getPointerType(Var->getType());
5953 if (!S.Context.hasSameUnqualifiedType(ArgType, ParamType)) {
5954 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
5955 << ParamType;
5956 S.Diag(Param->getLocation(), diag::note_template_param_here);
5957 return true;
5958 }
5959
5960 S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
5961 << ParamType
5962 << FixItHint::CreateInsertion(Arg->getLocStart(), "&");
5963
5964 S.Diag(Param->getLocation(), diag::note_template_param_here);
5965 }
5966 }
Douglas Gregorccb07762009-02-11 19:52:55 +00005967 }
Mike Stump11289f42009-09-09 15:08:12 +00005968
David Majnemer61c39a12013-08-23 05:39:39 +00005969 if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType, ArgIn,
5970 Arg, ArgType))
5971 return true;
Douglas Gregorb242683d2010-04-01 18:32:35 +00005972
5973 // Create the template argument.
David Blaikie0f62c8d2014-10-16 04:21:25 +00005974 Converted =
5975 TemplateArgument(cast<ValueDecl>(Entity->getCanonicalDecl()), ParamType);
Nick Lewycky45b50522013-02-02 00:25:55 +00005976 S.MarkAnyDeclReferenced(Arg->getLocStart(), Entity, false);
Douglas Gregorb242683d2010-04-01 18:32:35 +00005977 return false;
Douglas Gregorccb07762009-02-11 19:52:55 +00005978}
5979
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00005980/// Checks whether the given template argument is a pointer to
Douglas Gregorccb07762009-02-11 19:52:55 +00005981/// member constant according to C++ [temp.arg.nontype]p1.
Douglas Gregor20fdef32012-04-10 17:08:25 +00005982static bool CheckTemplateArgumentPointerToMember(Sema &S,
5983 NonTypeTemplateParmDecl *Param,
5984 QualType ParamType,
5985 Expr *&ResultArg,
5986 TemplateArgument &Converted) {
Douglas Gregorccb07762009-02-11 19:52:55 +00005987 bool Invalid = false;
5988
Douglas Gregor20fdef32012-04-10 17:08:25 +00005989 Expr *Arg = ResultArg;
Douglas Gregor20fdef32012-04-10 17:08:25 +00005990 bool ObjCLifetimeConversion;
Douglas Gregorccb07762009-02-11 19:52:55 +00005991
5992 // C++ [temp.arg.nontype]p1:
Mike Stump11289f42009-09-09 15:08:12 +00005993 //
Douglas Gregorccb07762009-02-11 19:52:55 +00005994 // A template-argument for a non-type, non-template
5995 // template-parameter shall be one of: [...]
5996 //
5997 // -- a pointer to member expressed as described in 5.3.1.
Craig Topperc3ec1492014-05-26 06:22:03 +00005998 DeclRefExpr *DRE = nullptr;
Douglas Gregorccb07762009-02-11 19:52:55 +00005999
Abramo Bagnara6a0c4092010-09-13 06:06:58 +00006000 // In C++98/03 mode, give an extension warning on any extra parentheses.
6001 // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
6002 bool ExtraParens = false;
Douglas Gregorccb07762009-02-11 19:52:55 +00006003 while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
Richard Smith0bf8a4922011-10-18 20:49:44 +00006004 if (!Invalid && !ExtraParens) {
Douglas Gregor20fdef32012-04-10 17:08:25 +00006005 S.Diag(Arg->getLocStart(),
Richard Smith2bf7fdb2013-01-02 11:42:31 +00006006 S.getLangOpts().CPlusPlus11 ?
Douglas Gregor20fdef32012-04-10 17:08:25 +00006007 diag::warn_cxx98_compat_template_arg_extra_parens :
6008 diag::ext_template_arg_extra_parens)
Douglas Gregorccb07762009-02-11 19:52:55 +00006009 << Arg->getSourceRange();
Abramo Bagnara6a0c4092010-09-13 06:06:58 +00006010 ExtraParens = true;
Douglas Gregorccb07762009-02-11 19:52:55 +00006011 }
6012
6013 Arg = Parens->getSubExpr();
6014 }
6015
John McCall7c454bb2011-07-15 05:09:51 +00006016 while (SubstNonTypeTemplateParmExpr *subst =
6017 dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
6018 Arg = subst->getReplacement()->IgnoreImpCasts();
6019
Douglas Gregor49ba3ca2009-11-12 18:38:13 +00006020 // A pointer-to-member constant written &Class::member.
6021 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
John McCalle3027922010-08-25 11:45:40 +00006022 if (UnOp->getOpcode() == UO_AddrOf) {
Douglas Gregor4bd90e52009-10-23 18:54:35 +00006023 DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
6024 if (DRE && !DRE->getQualifier())
Craig Topperc3ec1492014-05-26 06:22:03 +00006025 DRE = nullptr;
Douglas Gregor4bd90e52009-10-23 18:54:35 +00006026 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006027 }
Douglas Gregor49ba3ca2009-11-12 18:38:13 +00006028 // A constant of pointer-to-member type.
6029 else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
George Burgess IV00f70bd2018-03-01 05:43:23 +00006030 ValueDecl *VD = DRE->getDecl();
6031 if (VD->getType()->isMemberPointerType()) {
6032 if (isa<NonTypeTemplateParmDecl>(VD)) {
6033 if (Arg->isTypeDependent() || Arg->isValueDependent()) {
6034 Converted = TemplateArgument(Arg);
6035 } else {
6036 VD = cast<ValueDecl>(VD->getCanonicalDecl());
6037 Converted = TemplateArgument(VD, ParamType);
Douglas Gregor49ba3ca2009-11-12 18:38:13 +00006038 }
George Burgess IV00f70bd2018-03-01 05:43:23 +00006039 return Invalid;
Douglas Gregor49ba3ca2009-11-12 18:38:13 +00006040 }
6041 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006042
Craig Topperc3ec1492014-05-26 06:22:03 +00006043 DRE = nullptr;
Douglas Gregor49ba3ca2009-11-12 18:38:13 +00006044 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006045
Reid Klecknercd016d82017-07-07 22:04:29 +00006046 ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;
6047
6048 // Check for a null pointer value.
6049 switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ResultArg,
6050 Entity)) {
6051 case NPV_Error:
6052 return true;
6053 case NPV_NullPointer:
6054 S.Diag(ResultArg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
6055 Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
6056 /*isNullPtr*/true);
6057 return false;
6058 case NPV_NotNullPointer:
6059 break;
6060 }
6061
6062 if (S.IsQualificationConversion(ResultArg->getType(),
6063 ParamType.getNonReferenceType(), false,
6064 ObjCLifetimeConversion)) {
6065 ResultArg = S.ImpCastExprToType(ResultArg, ParamType, CK_NoOp,
6066 ResultArg->getValueKind())
6067 .get();
6068 } else if (!S.Context.hasSameUnqualifiedType(
6069 ResultArg->getType(), ParamType.getNonReferenceType())) {
6070 // We can't perform this conversion.
6071 S.Diag(ResultArg->getLocStart(), diag::err_template_arg_not_convertible)
6072 << ResultArg->getType() << ParamType << ResultArg->getSourceRange();
6073 S.Diag(Param->getLocation(), diag::note_template_param_here);
6074 return true;
6075 }
6076
Douglas Gregorccb07762009-02-11 19:52:55 +00006077 if (!DRE)
Douglas Gregor20fdef32012-04-10 17:08:25 +00006078 return S.Diag(Arg->getLocStart(),
6079 diag::err_template_arg_not_pointer_to_member_form)
Douglas Gregorccb07762009-02-11 19:52:55 +00006080 << Arg->getSourceRange();
6081
David Majnemer3ac84e62013-10-22 21:56:38 +00006082 if (isa<FieldDecl>(DRE->getDecl()) ||
6083 isa<IndirectFieldDecl>(DRE->getDecl()) ||
6084 isa<CXXMethodDecl>(DRE->getDecl())) {
Douglas Gregorccb07762009-02-11 19:52:55 +00006085 assert((isa<FieldDecl>(DRE->getDecl()) ||
David Majnemer3ac84e62013-10-22 21:56:38 +00006086 isa<IndirectFieldDecl>(DRE->getDecl()) ||
Douglas Gregorccb07762009-02-11 19:52:55 +00006087 !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&
6088 "Only non-static member pointers can make it here");
6089
6090 // Okay: this is the address of a non-static member, and therefore
6091 // a member pointer constant.
Eli Friedmanb826a002012-09-26 02:36:12 +00006092 if (Arg->isTypeDependent() || Arg->isValueDependent()) {
John McCallc3007a22010-10-26 07:05:15 +00006093 Converted = TemplateArgument(Arg);
Eli Friedmanb826a002012-09-26 02:36:12 +00006094 } else {
6095 ValueDecl *D = cast<ValueDecl>(DRE->getDecl()->getCanonicalDecl());
David Blaikie0f62c8d2014-10-16 04:21:25 +00006096 Converted = TemplateArgument(D, ParamType);
Eli Friedmanb826a002012-09-26 02:36:12 +00006097 }
Douglas Gregorccb07762009-02-11 19:52:55 +00006098 return Invalid;
6099 }
6100
6101 // We found something else, but we don't know specifically what it is.
Douglas Gregor20fdef32012-04-10 17:08:25 +00006102 S.Diag(Arg->getLocStart(),
6103 diag::err_template_arg_not_pointer_to_member_form)
6104 << Arg->getSourceRange();
6105 S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
Douglas Gregorccb07762009-02-11 19:52:55 +00006106 return true;
6107}
6108
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00006109/// Check a template argument against its corresponding
Douglas Gregord32e0282009-02-09 23:23:08 +00006110/// non-type template parameter.
6111///
Douglas Gregor463421d2009-03-03 04:44:36 +00006112/// This routine implements the semantics of C++ [temp.arg.nontype].
John Wiegley01296292011-04-08 18:41:53 +00006113/// If an error occurred, it returns ExprError(); otherwise, it
Richard Smithd663fdd2014-12-17 20:42:37 +00006114/// returns the converted template argument. \p ParamType is the
6115/// type of the non-type template parameter after it has been instantiated.
John Wiegley01296292011-04-08 18:41:53 +00006116ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
Richard Smithd663fdd2014-12-17 20:42:37 +00006117 QualType ParamType, Expr *Arg,
John Wiegley01296292011-04-08 18:41:53 +00006118 TemplateArgument &Converted,
6119 CheckTemplateArgumentKind CTAK) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006120 SourceLocation StartLoc = Arg->getLocStart();
Douglas Gregorc40290e2009-03-09 23:48:35 +00006121
Richard Smith5f274382016-09-28 23:55:27 +00006122 // If the parameter type somehow involves auto, deduce the type now.
Aaron Ballmanc351fba2017-12-04 20:27:34 +00006123 if (getLangOpts().CPlusPlus17 && ParamType->isUndeducedType()) {
Richard Smith4ae5ec82017-02-22 20:01:55 +00006124 // During template argument deduction, we allow 'decltype(auto)' to
6125 // match an arbitrary dependent argument.
6126 // FIXME: The language rules don't say what happens in this case.
6127 // FIXME: We get an opaque dependent type out of decltype(auto) if the
6128 // expression is merely instantiation-dependent; is this enough?
6129 if (CTAK == CTAK_Deduced && Arg->isTypeDependent()) {
6130 auto *AT = dyn_cast<AutoType>(ParamType);
6131 if (AT && AT->isDecltypeAuto()) {
6132 Converted = TemplateArgument(Arg);
6133 return Arg;
6134 }
6135 }
6136
Richard Smith87d263e2016-12-25 08:05:23 +00006137 // When checking a deduced template argument, deduce from its type even if
6138 // the type is dependent, in order to check the types of non-type template
6139 // arguments line up properly in partial ordering.
6140 Optional<unsigned> Depth;
6141 if (CTAK != CTAK_Specified)
6142 Depth = Param->getDepth() + 1;
Richard Smith5f274382016-09-28 23:55:27 +00006143 if (DeduceAutoType(
6144 Context.getTrivialTypeSourceInfo(ParamType, Param->getLocation()),
Richard Smith87d263e2016-12-25 08:05:23 +00006145 Arg, ParamType, Depth) == DAR_Failed) {
Richard Smith5f274382016-09-28 23:55:27 +00006146 Diag(Arg->getExprLoc(),
6147 diag::err_non_type_template_parm_type_deduction_failure)
6148 << Param->getDeclName() << Param->getType() << Arg->getType()
6149 << Arg->getSourceRange();
6150 Diag(Param->getLocation(), diag::note_template_param_here);
6151 return ExprError();
6152 }
6153 // CheckNonTypeTemplateParameterType will produce a diagnostic if there's
6154 // an error. The error message normally references the parameter
6155 // declaration, but here we'll pass the argument location because that's
6156 // where the parameter type is deduced.
6157 ParamType = CheckNonTypeTemplateParameterType(ParamType, Arg->getExprLoc());
6158 if (ParamType.isNull()) {
6159 Diag(Param->getLocation(), diag::note_template_param_here);
6160 return ExprError();
6161 }
6162 }
6163
Richard Smithd663fdd2014-12-17 20:42:37 +00006164 // We should have already dropped all cv-qualifiers by now.
6165 assert(!ParamType.hasQualifiers() &&
6166 "non-type template parameter type cannot be qualified");
6167
6168 if (CTAK == CTAK_Deduced &&
Richard Smithd92eddf2016-12-27 06:14:37 +00006169 !Context.hasSameType(ParamType.getNonLValueExprType(Context),
Richard Smith0e617ec2016-12-27 07:56:27 +00006170 Arg->getType())) {
Richard Smith957fbf12017-01-17 02:14:37 +00006171 // FIXME: If either type is dependent, we skip the check. This isn't
6172 // correct, since during deduction we're supposed to have replaced each
6173 // template parameter with some unique (non-dependent) placeholder.
6174 // FIXME: If the argument type contains 'auto', we carry on and fail the
6175 // type check in order to force specific types to be more specialized than
6176 // 'auto'. It's not clear how partial ordering with 'auto' is supposed to
6177 // work.
6178 if ((ParamType->isDependentType() || Arg->isTypeDependent()) &&
6179 !Arg->getType()->getContainedAutoType()) {
6180 Converted = TemplateArgument(Arg);
6181 return Arg;
6182 }
6183 // FIXME: This attempts to implement C++ [temp.deduct.type]p17. Per DR1770,
6184 // we should actually be checking the type of the template argument in P,
6185 // not the type of the template argument deduced from A, against the
6186 // template parameter type.
Richard Smithd663fdd2014-12-17 20:42:37 +00006187 Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
Richard Smith0e617ec2016-12-27 07:56:27 +00006188 << Arg->getType()
Richard Smithd663fdd2014-12-17 20:42:37 +00006189 << ParamType.getUnqualifiedType();
6190 Diag(Param->getLocation(), diag::note_template_param_here);
6191 return ExprError();
6192 }
6193
Richard Smith87d263e2016-12-25 08:05:23 +00006194 // If either the parameter has a dependent type or the argument is
6195 // type-dependent, there's nothing we can check now.
6196 if (ParamType->isDependentType() || Arg->isTypeDependent()) {
6197 // FIXME: Produce a cloned, canonical expression?
6198 Converted = TemplateArgument(Arg);
6199 return Arg;
6200 }
6201
Richard Smithe5945872017-01-06 22:52:53 +00006202 // The initialization of the parameter from the argument is
6203 // a constant-evaluated context.
Faisal Valid143a0c2017-04-01 21:30:49 +00006204 EnterExpressionEvaluationContext ConstantEvaluated(
6205 *this, Sema::ExpressionEvaluationContext::ConstantEvaluated);
Richard Smithe5945872017-01-06 22:52:53 +00006206
Aaron Ballmanc351fba2017-12-04 20:27:34 +00006207 if (getLangOpts().CPlusPlus17) {
6208 // C++17 [temp.arg.nontype]p1:
Richard Smith410cc892014-11-26 03:26:53 +00006209 // A template-argument for a non-type template parameter shall be
6210 // a converted constant expression of the type of the template-parameter.
6211 APValue Value;
6212 ExprResult ArgResult = CheckConvertedConstantExpression(
6213 Arg, ParamType, Value, CCEK_TemplateArg);
6214 if (ArgResult.isInvalid())
6215 return ExprError();
6216
Richard Smith52e624f2016-12-21 21:42:57 +00006217 // For a value-dependent argument, CheckConvertedConstantExpression is
6218 // permitted (and expected) to be unable to determine a value.
6219 if (ArgResult.get()->isValueDependent()) {
Richard Smith01bfa682016-12-27 02:02:09 +00006220 Converted = TemplateArgument(ArgResult.get());
6221 return ArgResult;
Richard Smith52e624f2016-12-21 21:42:57 +00006222 }
6223
Richard Smithd663fdd2014-12-17 20:42:37 +00006224 QualType CanonParamType = Context.getCanonicalType(ParamType);
6225
Richard Smith410cc892014-11-26 03:26:53 +00006226 // Convert the APValue to a TemplateArgument.
6227 switch (Value.getKind()) {
6228 case APValue::Uninitialized:
6229 assert(ParamType->isNullPtrType());
Richard Smithd663fdd2014-12-17 20:42:37 +00006230 Converted = TemplateArgument(CanonParamType, /*isNullPtr*/true);
Richard Smith410cc892014-11-26 03:26:53 +00006231 break;
6232 case APValue::Int:
6233 assert(ParamType->isIntegralOrEnumerationType());
Richard Smithd663fdd2014-12-17 20:42:37 +00006234 Converted = TemplateArgument(Context, Value.getInt(), CanonParamType);
Richard Smith410cc892014-11-26 03:26:53 +00006235 break;
6236 case APValue::MemberPointer: {
6237 assert(ParamType->isMemberPointerType());
6238
6239 // FIXME: We need TemplateArgument representation and mangling for these.
6240 if (!Value.getMemberPointerPath().empty()) {
6241 Diag(Arg->getLocStart(),
6242 diag::err_template_arg_member_ptr_base_derived_not_supported)
6243 << Value.getMemberPointerDecl() << ParamType
6244 << Arg->getSourceRange();
6245 return ExprError();
6246 }
6247
6248 auto *VD = const_cast<ValueDecl*>(Value.getMemberPointerDecl());
Richard Smithd663fdd2014-12-17 20:42:37 +00006249 Converted = VD ? TemplateArgument(VD, CanonParamType)
6250 : TemplateArgument(CanonParamType, /*isNullPtr*/true);
Richard Smith410cc892014-11-26 03:26:53 +00006251 break;
6252 }
6253 case APValue::LValue: {
6254 // For a non-type template-parameter of pointer or reference type,
6255 // the value of the constant expression shall not refer to
Richard Smithd663fdd2014-12-17 20:42:37 +00006256 assert(ParamType->isPointerType() || ParamType->isReferenceType() ||
6257 ParamType->isNullPtrType());
Richard Smith410cc892014-11-26 03:26:53 +00006258 // -- a temporary object
6259 // -- a string literal
6260 // -- the result of a typeid expression, or
Eric Christopher0d2c56a2017-03-31 01:45:39 +00006261 // -- a predefined __func__ variable
Richard Smith410cc892014-11-26 03:26:53 +00006262 if (auto *E = Value.getLValueBase().dyn_cast<const Expr*>()) {
6263 if (isa<CXXUuidofExpr>(E)) {
Nico Weberd60bbce2018-05-17 15:26:37 +00006264 Converted = TemplateArgument(ArgResult.get());
Richard Smith410cc892014-11-26 03:26:53 +00006265 break;
6266 }
6267 Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
6268 << Arg->getSourceRange();
6269 return ExprError();
6270 }
6271 auto *VD = const_cast<ValueDecl *>(
6272 Value.getLValueBase().dyn_cast<const ValueDecl *>());
6273 // -- a subobject
6274 if (Value.hasLValuePath() && Value.getLValuePath().size() == 1 &&
6275 VD && VD->getType()->isArrayType() &&
6276 Value.getLValuePath()[0].ArrayIndex == 0 &&
6277 !Value.isLValueOnePastTheEnd() && ParamType->isPointerType()) {
6278 // Per defect report (no number yet):
6279 // ... other than a pointer to the first element of a complete array
6280 // object.
6281 } else if (!Value.hasLValuePath() || Value.getLValuePath().size() ||
6282 Value.isLValueOnePastTheEnd()) {
6283 Diag(StartLoc, diag::err_non_type_template_arg_subobject)
6284 << Value.getAsString(Context, ParamType);
6285 return ExprError();
6286 }
Richard Smithd663fdd2014-12-17 20:42:37 +00006287 assert((VD || !ParamType->isReferenceType()) &&
Richard Smith410cc892014-11-26 03:26:53 +00006288 "null reference should not be a constant expression");
Richard Smithd663fdd2014-12-17 20:42:37 +00006289 assert((!VD || !ParamType->isNullPtrType()) &&
6290 "non-null value of type nullptr_t?");
6291 Converted = VD ? TemplateArgument(VD, CanonParamType)
6292 : TemplateArgument(CanonParamType, /*isNullPtr*/true);
Richard Smith410cc892014-11-26 03:26:53 +00006293 break;
6294 }
6295 case APValue::AddrLabelDiff:
6296 return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
6297 case APValue::Float:
6298 case APValue::ComplexInt:
6299 case APValue::ComplexFloat:
6300 case APValue::Vector:
6301 case APValue::Array:
6302 case APValue::Struct:
6303 case APValue::Union:
6304 llvm_unreachable("invalid kind for template argument");
6305 }
6306
6307 return ArgResult.get();
6308 }
6309
Douglas Gregor86560402009-02-10 23:36:10 +00006310 // C++ [temp.arg.nontype]p5:
6311 // The following conversions are performed on each expression used
6312 // as a non-type template-argument. If a non-type
6313 // template-argument cannot be converted to the type of the
6314 // corresponding template-parameter then the program is
6315 // ill-formed.
Douglas Gregorb90df602010-06-16 00:17:44 +00006316 if (ParamType->isIntegralOrEnumerationType()) {
Richard Smithf8379a02012-01-18 23:55:52 +00006317 // C++11:
6318 // -- for a non-type template-parameter of integral or
6319 // enumeration type, conversions permitted in a converted
6320 // constant expression are applied.
6321 //
6322 // C++98:
6323 // -- for a non-type template-parameter of integral or
6324 // enumeration type, integral promotions (4.5) and integral
6325 // conversions (4.7) are applied.
6326
Richard Smith2bf7fdb2013-01-02 11:42:31 +00006327 if (getLangOpts().CPlusPlus11) {
Richard Smithf8379a02012-01-18 23:55:52 +00006328 // C++ [temp.arg.nontype]p1:
6329 // A template-argument for a non-type, non-template template-parameter
6330 // shall be one of:
6331 //
6332 // -- for a non-type template-parameter of integral or enumeration
6333 // type, a converted constant expression of the type of the
6334 // template-parameter; or
6335 llvm::APSInt Value;
6336 ExprResult ArgResult =
6337 CheckConvertedConstantExpression(Arg, ParamType, Value,
6338 CCEK_TemplateArg);
6339 if (ArgResult.isInvalid())
6340 return ExprError();
6341
Richard Smith01bfa682016-12-27 02:02:09 +00006342 // We can't check arbitrary value-dependent arguments.
6343 if (ArgResult.get()->isValueDependent()) {
6344 Converted = TemplateArgument(ArgResult.get());
6345 return ArgResult;
6346 }
6347
Richard Smithf8379a02012-01-18 23:55:52 +00006348 // Widen the argument value to sizeof(parameter type). This is almost
6349 // always a no-op, except when the parameter type is bool. In
6350 // that case, this may extend the argument from 1 bit to 8 bits.
6351 QualType IntegerType = ParamType;
6352 if (const EnumType *Enum = IntegerType->getAs<EnumType>())
6353 IntegerType = Enum->getDecl()->getIntegerType();
6354 Value = Value.extOrTrunc(Context.getTypeSize(IntegerType));
6355
Benjamin Kramer6003ad52012-06-07 15:09:51 +00006356 Converted = TemplateArgument(Context, Value,
6357 Context.getCanonicalType(ParamType));
Richard Smithf8379a02012-01-18 23:55:52 +00006358 return ArgResult;
6359 }
6360
Richard Smith08b12f12011-10-27 22:11:44 +00006361 ExprResult ArgResult = DefaultLvalueConversion(Arg);
6362 if (ArgResult.isInvalid())
6363 return ExprError();
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006364 Arg = ArgResult.get();
Richard Smith08b12f12011-10-27 22:11:44 +00006365
6366 QualType ArgType = Arg->getType();
6367
Douglas Gregor86560402009-02-10 23:36:10 +00006368 // C++ [temp.arg.nontype]p1:
6369 // A template-argument for a non-type, non-template
6370 // template-parameter shall be one of:
6371 //
6372 // -- an integral constant-expression of integral or enumeration
6373 // type; or
6374 // -- the name of a non-type template-parameter; or
Douglas Gregor264ec4f2009-02-17 01:05:43 +00006375 llvm::APSInt Value;
Douglas Gregorb90df602010-06-16 00:17:44 +00006376 if (!ArgType->isIntegralOrEnumerationType()) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006377 Diag(Arg->getLocStart(),
Douglas Gregor86560402009-02-10 23:36:10 +00006378 diag::err_template_arg_not_integral_or_enumeral)
6379 << ArgType << Arg->getSourceRange();
6380 Diag(Param->getLocation(), diag::note_template_param_here);
John Wiegley01296292011-04-08 18:41:53 +00006381 return ExprError();
Richard Smithf4c51d92012-02-04 09:53:13 +00006382 } else if (!Arg->isValueDependent()) {
Douglas Gregore2b37442012-05-04 22:38:52 +00006383 class TmplArgICEDiagnoser : public VerifyICEDiagnoser {
6384 QualType T;
Simon Pilgrim6905d222016-12-30 22:55:33 +00006385
Douglas Gregore2b37442012-05-04 22:38:52 +00006386 public:
6387 TmplArgICEDiagnoser(QualType T) : T(T) { }
Craig Toppere14c0f82014-03-12 04:55:44 +00006388
6389 void diagnoseNotICE(Sema &S, SourceLocation Loc,
6390 SourceRange SR) override {
Douglas Gregore2b37442012-05-04 22:38:52 +00006391 S.Diag(Loc, diag::err_template_arg_not_ice) << T << SR;
6392 }
6393 } Diagnoser(ArgType);
6394
6395 Arg = VerifyIntegerConstantExpression(Arg, &Value, Diagnoser,
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006396 false).get();
Richard Smithf4c51d92012-02-04 09:53:13 +00006397 if (!Arg)
6398 return ExprError();
Douglas Gregor86560402009-02-10 23:36:10 +00006399 }
6400
Richard Smithd663fdd2014-12-17 20:42:37 +00006401 // From here on out, all we care about is the unqualified form
6402 // of the argument type.
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006403 ArgType = ArgType.getUnqualifiedType();
Douglas Gregor86560402009-02-10 23:36:10 +00006404
6405 // Try to convert the argument to the parameter's type.
Douglas Gregor4d0c38a2009-11-04 21:50:46 +00006406 if (Context.hasSameType(ParamType, ArgType)) {
Douglas Gregor86560402009-02-10 23:36:10 +00006407 // Okay: no conversion necessary
John McCall8cb679e2010-11-15 09:13:47 +00006408 } else if (ParamType->isBooleanType()) {
6409 // This is an integral-to-boolean conversion.
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006410 Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralToBoolean).get();
Douglas Gregor86560402009-02-10 23:36:10 +00006411 } else if (IsIntegralPromotion(Arg, ArgType, ParamType) ||
6412 !ParamType->isEnumeralType()) {
6413 // This is an integral promotion or conversion.
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006414 Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralCast).get();
Douglas Gregor86560402009-02-10 23:36:10 +00006415 } else {
6416 // We can't perform this conversion.
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006417 Diag(Arg->getLocStart(),
Douglas Gregor86560402009-02-10 23:36:10 +00006418 diag::err_template_arg_not_convertible)
Richard Smithd663fdd2014-12-17 20:42:37 +00006419 << Arg->getType() << ParamType << Arg->getSourceRange();
Douglas Gregor86560402009-02-10 23:36:10 +00006420 Diag(Param->getLocation(), diag::note_template_param_here);
John Wiegley01296292011-04-08 18:41:53 +00006421 return ExprError();
Douglas Gregor86560402009-02-10 23:36:10 +00006422 }
6423
Douglas Gregorb4f4d512011-05-04 21:55:00 +00006424 // Add the value of this argument to the list of converted
6425 // arguments. We use the bitwidth and signedness of the template
6426 // parameter.
6427 if (Arg->isValueDependent()) {
6428 // The argument is value-dependent. Create a new
6429 // TemplateArgument with the converted expression.
6430 Converted = TemplateArgument(Arg);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006431 return Arg;
Douglas Gregorb4f4d512011-05-04 21:55:00 +00006432 }
6433
Douglas Gregor52aba872009-03-14 00:20:21 +00006434 QualType IntegerType = Context.getCanonicalType(ParamType);
John McCall9dd450b2009-09-21 23:43:11 +00006435 if (const EnumType *Enum = IntegerType->getAs<EnumType>())
Douglas Gregor74eba0b2009-06-11 18:10:32 +00006436 IntegerType = Context.getCanonicalType(Enum->getDecl()->getIntegerType());
Douglas Gregor52aba872009-03-14 00:20:21 +00006437
Douglas Gregorb4f4d512011-05-04 21:55:00 +00006438 if (ParamType->isBooleanType()) {
6439 // Value must be zero or one.
6440 Value = Value != 0;
6441 unsigned AllowedBits = Context.getTypeSize(IntegerType);
6442 if (Value.getBitWidth() != AllowedBits)
6443 Value = Value.extOrTrunc(AllowedBits);
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00006444 Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
Douglas Gregorb4f4d512011-05-04 21:55:00 +00006445 } else {
Douglas Gregorbb3d7862010-03-26 02:38:37 +00006446 llvm::APSInt OldValue = Value;
Simon Pilgrim6905d222016-12-30 22:55:33 +00006447
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006448 // Coerce the template argument's value to the value it will have
Douglas Gregorbb3d7862010-03-26 02:38:37 +00006449 // based on the template parameter's type.
Douglas Gregora14cb9f2010-03-26 00:39:40 +00006450 unsigned AllowedBits = Context.getTypeSize(IntegerType);
Douglas Gregora14cb9f2010-03-26 00:39:40 +00006451 if (Value.getBitWidth() != AllowedBits)
Jay Foad6d4db0c2010-12-07 08:25:34 +00006452 Value = Value.extOrTrunc(AllowedBits);
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00006453 Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
Simon Pilgrim6905d222016-12-30 22:55:33 +00006454
Douglas Gregorbb3d7862010-03-26 02:38:37 +00006455 // Complain if an unsigned parameter received a negative value.
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00006456 if (IntegerType->isUnsignedIntegerOrEnumerationType()
Douglas Gregorb4f4d512011-05-04 21:55:00 +00006457 && (OldValue.isSigned() && OldValue.isNegative())) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006458 Diag(Arg->getLocStart(), diag::warn_template_arg_negative)
Douglas Gregorbb3d7862010-03-26 02:38:37 +00006459 << OldValue.toString(10) << Value.toString(10) << Param->getType()
6460 << Arg->getSourceRange();
6461 Diag(Param->getLocation(), diag::note_template_param_here);
6462 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00006463
Douglas Gregorbb3d7862010-03-26 02:38:37 +00006464 // Complain if we overflowed the template parameter's type.
6465 unsigned RequiredBits;
Douglas Gregor6ab2fa82011-05-20 16:38:50 +00006466 if (IntegerType->isUnsignedIntegerOrEnumerationType())
Douglas Gregorbb3d7862010-03-26 02:38:37 +00006467 RequiredBits = OldValue.getActiveBits();
6468 else if (OldValue.isUnsigned())
6469 RequiredBits = OldValue.getActiveBits() + 1;
6470 else
6471 RequiredBits = OldValue.getMinSignedBits();
6472 if (RequiredBits > AllowedBits) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006473 Diag(Arg->getLocStart(),
Douglas Gregorbb3d7862010-03-26 02:38:37 +00006474 diag::warn_template_arg_too_large)
6475 << OldValue.toString(10) << Value.toString(10) << Param->getType()
6476 << Arg->getSourceRange();
6477 Diag(Param->getLocation(), diag::note_template_param_here);
6478 }
Douglas Gregor52aba872009-03-14 00:20:21 +00006479 }
Douglas Gregor264ec4f2009-02-17 01:05:43 +00006480
Benjamin Kramer6003ad52012-06-07 15:09:51 +00006481 Converted = TemplateArgument(Context, Value,
Simon Pilgrim6905d222016-12-30 22:55:33 +00006482 ParamType->isEnumeralType()
Douglas Gregor3d63a9e2011-08-09 01:55:14 +00006483 ? Context.getCanonicalType(ParamType)
6484 : IntegerType);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006485 return Arg;
Douglas Gregor86560402009-02-10 23:36:10 +00006486 }
Douglas Gregor3a7796b2009-02-11 00:19:33 +00006487
Richard Smith08b12f12011-10-27 22:11:44 +00006488 QualType ArgType = Arg->getType();
John McCall16df1e52010-03-30 21:47:33 +00006489 DeclAccessPair FoundResult; // temporary for ResolveOverloadedFunction
6490
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006491 // Handle pointer-to-function, reference-to-function, and
6492 // pointer-to-member-function all in (roughly) the same way.
6493 if (// -- For a non-type template-parameter of type pointer to
6494 // function, only the function-to-pointer conversion (4.3) is
6495 // applied. If the template-argument represents a set of
6496 // overloaded functions (or a pointer to such), the matching
6497 // function is selected from the set (13.4).
6498 (ParamType->isPointerType() &&
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006499 ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType()) ||
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006500 // -- For a non-type template-parameter of type reference to
6501 // function, no conversions apply. If the template-argument
6502 // represents a set of overloaded functions, the matching
6503 // function is selected from the set (13.4).
6504 (ParamType->isReferenceType() &&
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006505 ParamType->getAs<ReferenceType>()->getPointeeType()->isFunctionType()) ||
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006506 // -- For a non-type template-parameter of type pointer to
6507 // member function, no conversions apply. If the
6508 // template-argument represents a set of overloaded member
6509 // functions, the matching member function is selected from
6510 // the set (13.4).
6511 (ParamType->isMemberPointerType() &&
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006512 ParamType->getAs<MemberPointerType>()->getPointeeType()
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006513 ->isFunctionType())) {
Douglas Gregorb242683d2010-04-01 18:32:35 +00006514
Douglas Gregor064fdb22010-04-14 23:11:21 +00006515 if (Arg->getType() == Context.OverloadTy) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006516 if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType,
Douglas Gregor064fdb22010-04-14 23:11:21 +00006517 true,
6518 FoundResult)) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006519 if (DiagnoseUseOfDecl(Fn, Arg->getLocStart()))
John Wiegley01296292011-04-08 18:41:53 +00006520 return ExprError();
Douglas Gregor064fdb22010-04-14 23:11:21 +00006521
6522 Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
6523 ArgType = Arg->getType();
6524 } else
John Wiegley01296292011-04-08 18:41:53 +00006525 return ExprError();
Douglas Gregor3a7796b2009-02-11 00:19:33 +00006526 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006527
John Wiegley01296292011-04-08 18:41:53 +00006528 if (!ParamType->isMemberPointerType()) {
6529 if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
6530 ParamType,
6531 Arg, Converted))
6532 return ExprError();
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006533 return Arg;
John Wiegley01296292011-04-08 18:41:53 +00006534 }
Douglas Gregorb242683d2010-04-01 18:32:35 +00006535
Douglas Gregor20fdef32012-04-10 17:08:25 +00006536 if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
6537 Converted))
John Wiegley01296292011-04-08 18:41:53 +00006538 return ExprError();
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006539 return Arg;
Douglas Gregor3a7796b2009-02-11 00:19:33 +00006540 }
6541
Chris Lattner696197c2009-02-20 21:37:53 +00006542 if (ParamType->isPointerType()) {
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006543 // -- for a non-type template-parameter of type pointer to
6544 // object, qualification conversions (4.4) and the
6545 // array-to-pointer conversion (4.2) are applied.
Sebastian Redl576fd422009-05-10 18:38:11 +00006546 // C++0x also allows a value of std::nullptr_t.
Eli Friedmana170cd62010-08-05 02:49:48 +00006547 assert(ParamType->getPointeeType()->isIncompleteOrObjectType() &&
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006548 "Only object pointers allowed here");
Douglas Gregora9faa442009-02-11 00:44:29 +00006549
John Wiegley01296292011-04-08 18:41:53 +00006550 if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
6551 ParamType,
6552 Arg, Converted))
6553 return ExprError();
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006554 return Arg;
Douglas Gregora9faa442009-02-11 00:44:29 +00006555 }
Mike Stump11289f42009-09-09 15:08:12 +00006556
Ted Kremenekc23c7e62009-07-29 21:53:49 +00006557 if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006558 // -- For a non-type template-parameter of type reference to
6559 // object, no conversions apply. The type referred to by the
6560 // reference may be more cv-qualified than the (otherwise
6561 // identical) type of the template-argument. The
6562 // template-parameter is bound directly to the
6563 // template-argument, which must be an lvalue.
Eli Friedmana170cd62010-08-05 02:49:48 +00006564 assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006565 "Only object references allowed here");
Douglas Gregora9faa442009-02-11 00:44:29 +00006566
Douglas Gregor064fdb22010-04-14 23:11:21 +00006567 if (Arg->getType() == Context.OverloadTy) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006568 if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg,
6569 ParamRefType->getPointeeType(),
Douglas Gregor064fdb22010-04-14 23:11:21 +00006570 true,
6571 FoundResult)) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +00006572 if (DiagnoseUseOfDecl(Fn, Arg->getLocStart()))
John Wiegley01296292011-04-08 18:41:53 +00006573 return ExprError();
Douglas Gregor064fdb22010-04-14 23:11:21 +00006574
6575 Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
6576 ArgType = Arg->getType();
6577 } else
John Wiegley01296292011-04-08 18:41:53 +00006578 return ExprError();
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006579 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006580
John Wiegley01296292011-04-08 18:41:53 +00006581 if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
6582 ParamType,
6583 Arg, Converted))
6584 return ExprError();
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006585 return Arg;
Douglas Gregor6f233ef2009-02-11 01:18:59 +00006586 }
Douglas Gregor0e558532009-02-11 16:16:59 +00006587
Douglas Gregor20fdef32012-04-10 17:08:25 +00006588 // Deal with parameters of type std::nullptr_t.
6589 if (ParamType->isNullPtrType()) {
6590 if (Arg->isTypeDependent() || Arg->isValueDependent()) {
6591 Converted = TemplateArgument(Arg);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006592 return Arg;
Douglas Gregor20fdef32012-04-10 17:08:25 +00006593 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00006594
Douglas Gregor20fdef32012-04-10 17:08:25 +00006595 switch (isNullPointerValueTemplateArgument(*this, Param, ParamType, Arg)) {
6596 case NPV_NotNullPointer:
6597 Diag(Arg->getExprLoc(), diag::err_template_arg_not_convertible)
6598 << Arg->getType() << ParamType;
6599 Diag(Param->getLocation(), diag::note_template_param_here);
6600 return ExprError();
Simon Pilgrim6905d222016-12-30 22:55:33 +00006601
Douglas Gregor20fdef32012-04-10 17:08:25 +00006602 case NPV_Error:
6603 return ExprError();
Simon Pilgrim6905d222016-12-30 22:55:33 +00006604
Douglas Gregor20fdef32012-04-10 17:08:25 +00006605 case NPV_NullPointer:
Richard Smithbc8c5b52012-04-26 01:51:03 +00006606 Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
Richard Smith78bb36f2014-07-24 02:27:39 +00006607 Converted = TemplateArgument(Context.getCanonicalType(ParamType),
6608 /*isNullPtr*/true);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006609 return Arg;
Douglas Gregor20fdef32012-04-10 17:08:25 +00006610 }
6611 }
6612
Douglas Gregor0e558532009-02-11 16:16:59 +00006613 // -- For a non-type template-parameter of type pointer to data
6614 // member, qualification conversions (4.4) are applied.
6615 assert(ParamType->isMemberPointerType() && "Only pointers to members remain");
6616
Douglas Gregor20fdef32012-04-10 17:08:25 +00006617 if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
6618 Converted))
John Wiegley01296292011-04-08 18:41:53 +00006619 return ExprError();
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006620 return Arg;
Douglas Gregord32e0282009-02-09 23:23:08 +00006621}
6622
Richard Smith26b86ea2016-12-31 21:41:23 +00006623static void DiagnoseTemplateParameterListArityMismatch(
6624 Sema &S, TemplateParameterList *New, TemplateParameterList *Old,
6625 Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc);
6626
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00006627/// Check a template argument against its corresponding
Douglas Gregord32e0282009-02-09 23:23:08 +00006628/// template template parameter.
6629///
6630/// This routine implements the semantics of C++ [temp.arg.template].
6631/// It returns true if an error occurred, and false otherwise.
Richard Smith5d331022018-03-08 01:07:33 +00006632bool Sema::CheckTemplateTemplateArgument(TemplateParameterList *Params,
6633 TemplateArgumentLoc &Arg) {
Eli Friedmanb826a002012-09-26 02:36:12 +00006634 TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
Douglas Gregor9167f8b2009-11-11 01:00:40 +00006635 TemplateDecl *Template = Name.getAsTemplateDecl();
6636 if (!Template) {
6637 // Any dependent template name is fine.
6638 assert(Name.isDependent() && "Non-dependent template isn't a declaration?");
6639 return false;
6640 }
Douglas Gregor85e0f662009-02-10 00:24:35 +00006641
Richard Smith26b86ea2016-12-31 21:41:23 +00006642 if (Template->isInvalidDecl())
6643 return true;
6644
Richard Smith3f1b5d02011-05-05 21:57:07 +00006645 // C++0x [temp.arg.template]p1:
Douglas Gregor85e0f662009-02-10 00:24:35 +00006646 // A template-argument for a template template-parameter shall be
Richard Smith3f1b5d02011-05-05 21:57:07 +00006647 // the name of a class template or an alias template, expressed as an
6648 // id-expression. When the template-argument names a class template, only
Douglas Gregor85e0f662009-02-10 00:24:35 +00006649 // primary class templates are considered when matching the
6650 // template template argument with the corresponding parameter;
6651 // partial specializations are not considered even if their
6652 // parameter lists match that of the template template parameter.
Douglas Gregord5222052009-06-12 19:43:02 +00006653 //
6654 // Note that we also allow template template parameters here, which
6655 // will happen when we are dealing with, e.g., class template
6656 // partial specializations.
Mike Stump11289f42009-09-09 15:08:12 +00006657 if (!isa<ClassTemplateDecl>(Template) &&
Richard Smith3f1b5d02011-05-05 21:57:07 +00006658 !isa<TemplateTemplateParmDecl>(Template) &&
David Majnemerc2406d42016-07-11 17:09:56 +00006659 !isa<TypeAliasTemplateDecl>(Template) &&
6660 !isa<BuiltinTemplateDecl>(Template)) {
6661 assert(isa<FunctionTemplateDecl>(Template) &&
6662 "Only function templates are possible here");
Faisal Valib8b04f82016-03-26 20:46:45 +00006663 Diag(Arg.getLocation(), diag::err_template_arg_not_valid_template);
David Majnemerc2406d42016-07-11 17:09:56 +00006664 Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
6665 << Template;
Douglas Gregor85e0f662009-02-10 00:24:35 +00006666 }
6667
Richard Smith26b86ea2016-12-31 21:41:23 +00006668 // C++1z [temp.arg.template]p3: (DR 150)
6669 // A template-argument matches a template template-parameter P when P
6670 // is at least as specialized as the template-argument A.
6671 if (getLangOpts().RelaxedTemplateTemplateArgs) {
6672 // Quick check for the common case:
6673 // If P contains a parameter pack, then A [...] matches P if each of A's
6674 // template parameters matches the corresponding template parameter in
6675 // the template-parameter-list of P.
6676 if (TemplateParameterListsAreEqual(
6677 Template->getTemplateParameters(), Params, false,
6678 TPL_TemplateTemplateArgumentMatch, Arg.getLocation()))
6679 return false;
6680
6681 if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template,
6682 Arg.getLocation()))
6683 return false;
6684 // FIXME: Produce better diagnostics for deduction failures.
6685 }
6686
Douglas Gregor85e0f662009-02-10 00:24:35 +00006687 return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),
Richard Smith1fde8ec2012-09-07 02:06:42 +00006688 Params,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006689 true,
Douglas Gregor19ac2d62009-11-12 16:20:59 +00006690 TPL_TemplateTemplateArgumentMatch,
Douglas Gregor9167f8b2009-11-11 01:00:40 +00006691 Arg.getLocation());
Douglas Gregord32e0282009-02-09 23:23:08 +00006692}
6693
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00006694/// Given a non-type template argument that refers to a
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006695/// declaration and the type of its corresponding non-type template
6696/// parameter, produce an expression that properly refers to that
6697/// declaration.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006698ExprResult
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006699Sema::BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
6700 QualType ParamType,
6701 SourceLocation Loc) {
David Blaikiedc601e32013-02-27 22:10:40 +00006702 // C++ [temp.param]p8:
6703 //
6704 // A non-type template-parameter of type "array of T" or
6705 // "function returning T" is adjusted to be of type "pointer to
6706 // T" or "pointer to function returning T", respectively.
6707 if (ParamType->isArrayType())
6708 ParamType = Context.getArrayDecayedType(ParamType);
6709 else if (ParamType->isFunctionType())
6710 ParamType = Context.getPointerType(ParamType);
6711
Douglas Gregor31f55dc2012-04-06 22:40:38 +00006712 // For a NULL non-type template argument, return nullptr casted to the
6713 // parameter's type.
Eli Friedmanb826a002012-09-26 02:36:12 +00006714 if (Arg.getKind() == TemplateArgument::NullPtr) {
Douglas Gregor31f55dc2012-04-06 22:40:38 +00006715 return ImpCastExprToType(
6716 new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc),
6717 ParamType,
6718 ParamType->getAs<MemberPointerType>()
6719 ? CK_NullToMemberPointer
6720 : CK_NullToPointer);
6721 }
Eli Friedmanb826a002012-09-26 02:36:12 +00006722 assert(Arg.getKind() == TemplateArgument::Declaration &&
6723 "Only declaration template arguments permitted here");
6724
George Burgess IV00f70bd2018-03-01 05:43:23 +00006725 ValueDecl *VD = Arg.getAsDecl();
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006726
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006727 if (VD->getDeclContext()->isRecord() &&
David Majnemer3ae0bfa2013-10-26 05:02:13 +00006728 (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||
6729 isa<IndirectFieldDecl>(VD))) {
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006730 // If the value is a class member, we might have a pointer-to-member.
6731 // Determine whether the non-type template template parameter is of
6732 // pointer-to-member type. If so, we need to build an appropriate
6733 // expression for a pointer-to-member, since a "normal" DeclRefExpr
6734 // would refer to the member itself.
6735 if (ParamType->isMemberPointerType()) {
6736 QualType ClassType
6737 = Context.getTypeDeclType(cast<RecordDecl>(VD->getDeclContext()));
6738 NestedNameSpecifier *Qualifier
Craig Topperc3ec1492014-05-26 06:22:03 +00006739 = NestedNameSpecifier::Create(Context, nullptr, false,
John McCallb268a282010-08-23 23:25:46 +00006740 ClassType.getTypePtr());
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006741 CXXScopeSpec SS;
Douglas Gregor869ad452011-02-24 17:54:50 +00006742 SS.MakeTrivial(Context, Qualifier, Loc);
John McCallfeb624a2010-11-23 20:48:44 +00006743
6744 // The actual value-ness of this is unimportant, but for
6745 // internal consistency's sake, references to instance methods
6746 // are r-values.
6747 ExprValueKind VK = VK_LValue;
6748 if (isa<CXXMethodDecl>(VD) && cast<CXXMethodDecl>(VD)->isInstance())
6749 VK = VK_RValue;
6750
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006751 ExprResult RefExpr = BuildDeclRefExpr(VD,
John McCall7decc9e2010-11-18 06:31:45 +00006752 VD->getType().getNonReferenceType(),
John McCallfeb624a2010-11-23 20:48:44 +00006753 VK,
John McCall7decc9e2010-11-18 06:31:45 +00006754 Loc,
6755 &SS);
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006756 if (RefExpr.isInvalid())
6757 return ExprError();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006758
John McCalle3027922010-08-25 11:45:40 +00006759 RefExpr = CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006760
Douglas Gregorfabf95d2010-04-30 21:46:38 +00006761 // We might need to perform a trailing qualification conversion, since
6762 // the element type on the parameter could be more qualified than the
6763 // element type in the expression we constructed.
John McCall31168b02011-06-15 23:02:42 +00006764 bool ObjCLifetimeConversion;
Douglas Gregorfabf95d2010-04-30 21:46:38 +00006765 if (IsQualificationConversion(((Expr*) RefExpr.get())->getType(),
John McCall31168b02011-06-15 23:02:42 +00006766 ParamType.getUnqualifiedType(), false,
6767 ObjCLifetimeConversion))
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006768 RefExpr = ImpCastExprToType(RefExpr.get(), ParamType.getUnqualifiedType(), CK_NoOp);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006769
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006770 assert(!RefExpr.isInvalid() &&
6771 Context.hasSameType(((Expr*) RefExpr.get())->getType(),
Douglas Gregorfabf95d2010-04-30 21:46:38 +00006772 ParamType.getUnqualifiedType()));
Benjamin Kramer62b95d82012-08-23 21:35:17 +00006773 return RefExpr;
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006774 }
6775 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006776
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006777 QualType T = VD->getType().getNonReferenceType();
Douglas Gregoreffe2a12013-01-16 00:52:15 +00006778
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006779 if (ParamType->isPointerType()) {
Douglas Gregorb242683d2010-04-01 18:32:35 +00006780 // When the non-type template parameter is a pointer, take the
6781 // address of the declaration.
John McCall7decc9e2010-11-18 06:31:45 +00006782 ExprResult RefExpr = BuildDeclRefExpr(VD, T, VK_LValue, Loc);
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006783 if (RefExpr.isInvalid())
6784 return ExprError();
Douglas Gregorb242683d2010-04-01 18:32:35 +00006785
Richard Smithfc6fca12017-01-28 00:38:35 +00006786 if (!Context.hasSameUnqualifiedType(ParamType->getPointeeType(), T) &&
6787 (T->isFunctionType() || T->isArrayType())) {
6788 // Decay functions and arrays unless we're forming a pointer to array.
Nikola Smiljanic01a75982014-05-29 10:55:11 +00006789 RefExpr = DefaultFunctionArrayConversion(RefExpr.get());
John Wiegley01296292011-04-08 18:41:53 +00006790 if (RefExpr.isInvalid())
6791 return ExprError();
Douglas Gregorb242683d2010-04-01 18:32:35 +00006792
Benjamin Kramer62b95d82012-08-23 21:35:17 +00006793 return RefExpr;
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006794 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006795
Douglas Gregorb242683d2010-04-01 18:32:35 +00006796 // Take the address of everything else
John McCalle3027922010-08-25 11:45:40 +00006797 return CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006798 }
6799
John McCall7decc9e2010-11-18 06:31:45 +00006800 ExprValueKind VK = VK_RValue;
6801
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006802 // If the non-type template parameter has reference type, qualify the
6803 // resulting declaration reference with the extra qualifiers on the
6804 // type that the reference refers to.
John McCall7decc9e2010-11-18 06:31:45 +00006805 if (const ReferenceType *TargetRef = ParamType->getAs<ReferenceType>()) {
6806 VK = VK_LValue;
6807 T = Context.getQualifiedType(T,
6808 TargetRef->getPointeeType().getQualifiers());
Douglas Gregoreffe2a12013-01-16 00:52:15 +00006809 } else if (isa<FunctionDecl>(VD)) {
6810 // References to functions are always lvalues.
6811 VK = VK_LValue;
John McCall7decc9e2010-11-18 06:31:45 +00006812 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006813
John McCall7decc9e2010-11-18 06:31:45 +00006814 return BuildDeclRefExpr(VD, T, VK, Loc);
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006815}
6816
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00006817/// Construct a new expression that refers to the given
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006818/// integral template argument with the given source-location
6819/// information.
6820///
6821/// This routine takes care of the mapping from an integral template
6822/// argument (which may have any integral type) to the appropriate
6823/// literal value.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006824ExprResult
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006825Sema::BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
6826 SourceLocation Loc) {
6827 assert(Arg.getKind() == TemplateArgument::Integral &&
Douglas Gregora8bac7f2011-01-10 07:32:04 +00006828 "Operation is only valid for integral template arguments");
Benjamin Kramer3d3ddce2012-11-21 17:42:47 +00006829 QualType OrigT = Arg.getIntegralType();
6830
6831 // If this is an enum type that we're instantiating, we need to use an integer
6832 // type the same size as the enumerator. We don't want to build an
6833 // IntegerLiteral with enum type. The integer type of an enum type can be of
6834 // any integral type with C++11 enum classes, make sure we create the right
6835 // type of literal for it.
6836 QualType T = OrigT;
6837 if (const EnumType *ET = OrigT->getAs<EnumType>())
6838 T = ET->getDecl()->getIntegerType();
6839
6840 Expr *E;
Douglas Gregorfb65e592011-07-27 05:40:30 +00006841 if (T->isAnyCharacterType()) {
6842 CharacterLiteral::CharacterKind Kind;
6843 if (T->isWideCharType())
6844 Kind = CharacterLiteral::Wide;
Richard Smith3a8244d2018-05-01 05:02:45 +00006845 else if (T->isChar8Type() && getLangOpts().Char8)
6846 Kind = CharacterLiteral::UTF8;
Douglas Gregorfb65e592011-07-27 05:40:30 +00006847 else if (T->isChar16Type())
6848 Kind = CharacterLiteral::UTF16;
6849 else if (T->isChar32Type())
6850 Kind = CharacterLiteral::UTF32;
6851 else
6852 Kind = CharacterLiteral::Ascii;
6853
Benjamin Kramer3d3ddce2012-11-21 17:42:47 +00006854 E = new (Context) CharacterLiteral(Arg.getAsIntegral().getZExtValue(),
6855 Kind, T, Loc);
6856 } else if (T->isBooleanType()) {
6857 E = new (Context) CXXBoolLiteralExpr(Arg.getAsIntegral().getBoolValue(),
6858 T, Loc);
6859 } else if (T->isNullPtrType()) {
6860 E = new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
6861 } else {
6862 E = IntegerLiteral::Create(Context, Arg.getAsIntegral(), T, Loc);
Douglas Gregorfb65e592011-07-27 05:40:30 +00006863 }
6864
Benjamin Kramer3d3ddce2012-11-21 17:42:47 +00006865 if (OrigT->isEnumeralType()) {
John McCall6730e4d2011-07-15 07:47:58 +00006866 // FIXME: This is a hack. We need a better way to handle substituted
6867 // non-type template parameters.
Craig Topperc3ec1492014-05-26 06:22:03 +00006868 E = CStyleCastExpr::Create(Context, OrigT, VK_RValue, CK_IntegralCast, E,
6869 nullptr,
Benjamin Kramer3d3ddce2012-11-21 17:42:47 +00006870 Context.getTrivialTypeSourceInfo(OrigT, Loc),
John McCall6730e4d2011-07-15 07:47:58 +00006871 Loc, Loc);
6872 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00006873
Nikola Smiljanic03ff2592014-05-29 14:05:12 +00006874 return E;
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006875}
6876
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00006877/// Match two template parameters within template parameter lists.
Douglas Gregor641040a2011-01-12 23:45:44 +00006878static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old,
6879 bool Complain,
6880 Sema::TemplateParameterListEqualKind Kind,
6881 SourceLocation TemplateArgLoc) {
6882 // Check the actual kind (type, non-type, template).
6883 if (Old->getKind() != New->getKind()) {
6884 if (Complain) {
6885 unsigned NextDiag = diag::err_template_param_different_kind;
6886 if (TemplateArgLoc.isValid()) {
6887 S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
6888 NextDiag = diag::note_template_param_different_kind;
6889 }
6890 S.Diag(New->getLocation(), NextDiag)
6891 << (Kind != Sema::TPL_TemplateMatch);
6892 S.Diag(Old->getLocation(), diag::note_template_prev_declaration)
6893 << (Kind != Sema::TPL_TemplateMatch);
6894 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006895
Douglas Gregor641040a2011-01-12 23:45:44 +00006896 return false;
6897 }
6898
Richard Smith26b86ea2016-12-31 21:41:23 +00006899 // Check that both are parameter packs or neither are parameter packs.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006900 // However, if we are matching a template template argument to a
Douglas Gregorfd4344b2011-01-13 00:08:50 +00006901 // template template parameter, the template template parameter can have
6902 // a parameter pack where the template template argument does not.
6903 if (Old->isTemplateParameterPack() != New->isTemplateParameterPack() &&
6904 !(Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
6905 Old->isTemplateParameterPack())) {
Douglas Gregor641040a2011-01-12 23:45:44 +00006906 if (Complain) {
6907 unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
6908 if (TemplateArgLoc.isValid()) {
6909 S.Diag(TemplateArgLoc,
6910 diag::err_template_arg_template_params_mismatch);
6911 NextDiag = diag::note_template_parameter_pack_non_pack;
6912 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006913
Douglas Gregor641040a2011-01-12 23:45:44 +00006914 unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
6915 : isa<NonTypeTemplateParmDecl>(New)? 1
6916 : 2;
6917 S.Diag(New->getLocation(), NextDiag)
6918 << ParamKind << New->isParameterPack();
6919 S.Diag(Old->getLocation(), diag::note_template_parameter_pack_here)
6920 << ParamKind << Old->isParameterPack();
6921 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006922
Douglas Gregor641040a2011-01-12 23:45:44 +00006923 return false;
6924 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006925
Douglas Gregor641040a2011-01-12 23:45:44 +00006926 // For non-type template parameters, check the type of the parameter.
6927 if (NonTypeTemplateParmDecl *OldNTTP
6928 = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
6929 NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006930
Douglas Gregor641040a2011-01-12 23:45:44 +00006931 // If we are matching a template template argument to a template
6932 // template parameter and one of the non-type template parameter types
Richard Smith13894182017-04-13 21:37:24 +00006933 // is dependent, then we must wait until template instantiation time
6934 // to actually compare the arguments.
Douglas Gregor641040a2011-01-12 23:45:44 +00006935 if (Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
Richard Smith13894182017-04-13 21:37:24 +00006936 (OldNTTP->getType()->isDependentType() ||
6937 NewNTTP->getType()->isDependentType()))
Douglas Gregor641040a2011-01-12 23:45:44 +00006938 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006939
Douglas Gregor641040a2011-01-12 23:45:44 +00006940 if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
6941 if (Complain) {
6942 unsigned NextDiag = diag::err_template_nontype_parm_different_type;
6943 if (TemplateArgLoc.isValid()) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006944 S.Diag(TemplateArgLoc,
Douglas Gregor641040a2011-01-12 23:45:44 +00006945 diag::err_template_arg_template_params_mismatch);
6946 NextDiag = diag::note_template_nontype_parm_different_type;
6947 }
6948 S.Diag(NewNTTP->getLocation(), NextDiag)
6949 << NewNTTP->getType()
6950 << (Kind != Sema::TPL_TemplateMatch);
6951 S.Diag(OldNTTP->getLocation(),
6952 diag::note_template_nontype_parm_prev_declaration)
6953 << OldNTTP->getType();
6954 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006955
Douglas Gregor641040a2011-01-12 23:45:44 +00006956 return false;
6957 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006958
Douglas Gregor641040a2011-01-12 23:45:44 +00006959 return true;
6960 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006961
Douglas Gregor641040a2011-01-12 23:45:44 +00006962 // For template template parameters, check the template parameter types.
6963 // The template parameter lists of template template
6964 // parameters must agree.
6965 if (TemplateTemplateParmDecl *OldTTP
6966 = dyn_cast<TemplateTemplateParmDecl>(Old)) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006967 TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
Douglas Gregor641040a2011-01-12 23:45:44 +00006968 return S.TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(),
6969 OldTTP->getTemplateParameters(),
6970 Complain,
6971 (Kind == Sema::TPL_TemplateMatch
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006972 ? Sema::TPL_TemplateTemplateParmMatch
Douglas Gregor641040a2011-01-12 23:45:44 +00006973 : Kind),
6974 TemplateArgLoc);
6975 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006976
Douglas Gregor641040a2011-01-12 23:45:44 +00006977 return true;
6978}
Douglas Gregord5cb1dd2010-03-28 02:42:43 +00006979
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00006980/// Diagnose a known arity mismatch when comparing template argument
Douglas Gregorfd4344b2011-01-13 00:08:50 +00006981/// lists.
6982static
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00006983void DiagnoseTemplateParameterListArityMismatch(Sema &S,
Douglas Gregorfd4344b2011-01-13 00:08:50 +00006984 TemplateParameterList *New,
6985 TemplateParameterList *Old,
6986 Sema::TemplateParameterListEqualKind Kind,
6987 SourceLocation TemplateArgLoc) {
6988 unsigned NextDiag = diag::err_template_param_list_different_arity;
6989 if (TemplateArgLoc.isValid()) {
6990 S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
6991 NextDiag = diag::note_template_param_list_different_arity;
6992 }
6993 S.Diag(New->getTemplateLoc(), NextDiag)
6994 << (New->size() > Old->size())
6995 << (Kind != Sema::TPL_TemplateMatch)
6996 << SourceRange(New->getTemplateLoc(), New->getRAngleLoc());
6997 S.Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration)
6998 << (Kind != Sema::TPL_TemplateMatch)
6999 << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc());
7000}
7001
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00007002/// Determine whether the given template parameter lists are
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007003/// equivalent.
7004///
Mike Stump11289f42009-09-09 15:08:12 +00007005/// \param New The new template parameter list, typically written in the
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007006/// source code as part of a new template declaration.
7007///
7008/// \param Old The old template parameter list, typically found via
7009/// name lookup of the template declared with this template parameter
7010/// list.
7011///
7012/// \param Complain If true, this routine will produce a diagnostic if
7013/// the template parameter lists are not equivalent.
7014///
Douglas Gregor19ac2d62009-11-12 16:20:59 +00007015/// \param Kind describes how we are to match the template parameter lists.
Douglas Gregor85e0f662009-02-10 00:24:35 +00007016///
7017/// \param TemplateArgLoc If this source location is valid, then we
7018/// are actually checking the template parameter list of a template
7019/// argument (New) against the template parameter list of its
7020/// corresponding template template parameter (Old). We produce
7021/// slightly different diagnostics in this scenario.
7022///
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007023/// \returns True if the template parameter lists are equal, false
7024/// otherwise.
Mike Stump11289f42009-09-09 15:08:12 +00007025bool
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007026Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
7027 TemplateParameterList *Old,
7028 bool Complain,
Douglas Gregor19ac2d62009-11-12 16:20:59 +00007029 TemplateParameterListEqualKind Kind,
Douglas Gregor85e0f662009-02-10 00:24:35 +00007030 SourceLocation TemplateArgLoc) {
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007031 if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) {
7032 if (Complain)
7033 DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
7034 TemplateArgLoc);
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007035
7036 return false;
7037 }
7038
Douglas Gregor641040a2011-01-12 23:45:44 +00007039 // C++0x [temp.arg.template]p3:
7040 // A template-argument matches a template template-parameter (call it P)
NAKAMURA Takumi7c288862011-01-27 07:09:49 +00007041 // when each of the template parameters in the template-parameter-list of
Richard Smith3f1b5d02011-05-05 21:57:07 +00007042 // the template-argument's corresponding class template or alias template
NAKAMURA Takumi7c288862011-01-27 07:09:49 +00007043 // (call it A) matches the corresponding template parameter in the
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007044 // template-parameter-list of P. [...]
7045 TemplateParameterList::iterator NewParm = New->begin();
7046 TemplateParameterList::iterator NewParmEnd = New->end();
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007047 for (TemplateParameterList::iterator OldParm = Old->begin(),
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007048 OldParmEnd = Old->end();
7049 OldParm != OldParmEnd; ++OldParm) {
Douglas Gregor018778a2011-01-13 18:47:47 +00007050 if (Kind != TPL_TemplateTemplateArgumentMatch ||
7051 !(*OldParm)->isTemplateParameterPack()) {
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007052 if (NewParm == NewParmEnd) {
7053 if (Complain)
7054 DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
7055 TemplateArgLoc);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007056
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007057 return false;
7058 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007059
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007060 if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
7061 Kind, TemplateArgLoc))
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007062 return false;
7063
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007064 ++NewParm;
7065 continue;
7066 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007067
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007068 // C++0x [temp.arg.template]p3:
NAKAMURA Takumi7c288862011-01-27 07:09:49 +00007069 // [...] When P's template- parameter-list contains a template parameter
7070 // pack (14.5.3), the template parameter pack will match zero or more
7071 // template parameters or template parameter packs in the
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007072 // template-parameter-list of A with the same type and form as the
7073 // template parameter pack in P (ignoring whether those template
7074 // parameters are template parameter packs).
7075 for (; NewParm != NewParmEnd; ++NewParm) {
7076 if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
7077 Kind, TemplateArgLoc))
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007078 return false;
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007079 }
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007080 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007081
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007082 // Make sure we exhausted all of the arguments.
7083 if (NewParm != NewParmEnd) {
7084 if (Complain)
7085 DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
7086 TemplateArgLoc);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007087
Douglas Gregorfd4344b2011-01-13 00:08:50 +00007088 return false;
7089 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007090
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007091 return true;
7092}
7093
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00007094/// Check whether a template can be declared within this scope.
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007095///
7096/// If the template declaration is valid in this scope, returns
7097/// false. Otherwise, issues a diagnostic and returns true.
Mike Stump11289f42009-09-09 15:08:12 +00007098bool
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00007099Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) {
Douglas Gregordd847ba2011-11-03 16:37:14 +00007100 if (!S)
7101 return false;
7102
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007103 // Find the nearest enclosing declaration scope.
7104 while ((S->getFlags() & Scope::DeclScope) == 0 ||
7105 (S->getFlags() & Scope::TemplateParamScope) != 0)
7106 S = S->getParent();
Mike Stump11289f42009-09-09 15:08:12 +00007107
Benjamin Kramer35e6fee2014-02-02 16:35:43 +00007108 // C++ [temp]p4:
7109 // A template [...] shall not have C linkage.
Ted Kremenekc37877d2013-10-08 17:08:03 +00007110 DeclContext *Ctx = S->getEntity();
Alex Lorenz560ae562016-11-02 15:46:34 +00007111 if (Ctx && Ctx->isExternCContext()) {
7112 Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
7113 << TemplateParams->getSourceRange();
7114 if (const LinkageSpecDecl *LSD = Ctx->getExternCContext())
7115 Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
7116 return true;
7117 }
Richard Smith8df390f2016-09-08 23:14:54 +00007118 Ctx = Ctx->getRedeclContext();
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007119
Benjamin Kramer35e6fee2014-02-02 16:35:43 +00007120 // C++ [temp]p2:
7121 // A template-declaration can appear only as a namespace scope or
7122 // class scope declaration.
David Majnemer766e2592013-10-22 04:14:18 +00007123 if (Ctx) {
7124 if (Ctx->isFileContext())
7125 return false;
7126 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Ctx)) {
7127 // C++ [temp.mem]p2:
7128 // A local class shall not have member templates.
7129 if (RD->isLocalClass())
7130 return Diag(TemplateParams->getTemplateLoc(),
7131 diag::err_template_inside_local_class)
7132 << TemplateParams->getSourceRange();
7133 else
7134 return false;
7135 }
7136 }
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007137
Mike Stump11289f42009-09-09 15:08:12 +00007138 return Diag(TemplateParams->getTemplateLoc(),
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00007139 diag::err_template_outside_namespace_or_class_scope)
7140 << TemplateParams->getSourceRange();
Douglas Gregorcd72ba92009-02-06 22:42:48 +00007141}
Douglas Gregor67a65642009-02-17 23:15:12 +00007142
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00007143/// Determine what kind of template specialization the given declaration
Douglas Gregor54888652009-10-07 00:13:32 +00007144/// is.
Douglas Gregor0bc8a212012-01-14 15:55:47 +00007145static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D) {
Douglas Gregor54888652009-10-07 00:13:32 +00007146 if (!D)
7147 return TSK_Undeclared;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007148
Douglas Gregorbbe8f462009-10-08 15:14:33 +00007149 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D))
7150 return Record->getTemplateSpecializationKind();
Douglas Gregor54888652009-10-07 00:13:32 +00007151 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D))
7152 return Function->getTemplateSpecializationKind();
Douglas Gregor86d142a2009-10-08 07:24:58 +00007153 if (VarDecl *Var = dyn_cast<VarDecl>(D))
7154 return Var->getTemplateSpecializationKind();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007155
Douglas Gregor54888652009-10-07 00:13:32 +00007156 return TSK_Undeclared;
7157}
7158
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00007159/// Check whether a specialization is well-formed in the current
Douglas Gregorba8e1ac2009-10-14 23:50:59 +00007160/// context.
Douglas Gregorf47b9112009-02-25 22:02:03 +00007161///
Douglas Gregorba8e1ac2009-10-14 23:50:59 +00007162/// This routine determines whether a template specialization can be declared
7163/// in the current context (C++ [temp.expl.spec]p2).
Douglas Gregor54888652009-10-07 00:13:32 +00007164///
7165/// \param S the semantic analysis object for which this check is being
7166/// performed.
7167///
7168/// \param Specialized the entity being specialized or instantiated, which
7169/// may be a kind of template (class template, function template, etc.) or
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007170/// a member of a class template (member function, static data member,
Douglas Gregor54888652009-10-07 00:13:32 +00007171/// member class).
7172///
7173/// \param PrevDecl the previous declaration of this entity, if any.
7174///
7175/// \param Loc the location of the explicit specialization or instantiation of
7176/// this entity.
7177///
7178/// \param IsPartialSpecialization whether this is a partial specialization of
7179/// a class template.
7180///
Douglas Gregor54888652009-10-07 00:13:32 +00007181/// \returns true if there was an error that we cannot recover from, false
7182/// otherwise.
7183static bool CheckTemplateSpecializationScope(Sema &S,
7184 NamedDecl *Specialized,
7185 NamedDecl *PrevDecl,
7186 SourceLocation Loc,
Douglas Gregorba8e1ac2009-10-14 23:50:59 +00007187 bool IsPartialSpecialization) {
Douglas Gregor54888652009-10-07 00:13:32 +00007188 // Keep these "kind" numbers in sync with the %select statements in the
7189 // various diagnostics emitted by this routine.
7190 int EntityKind = 0;
Ted Kremenek7f1f3f62011-01-14 22:31:36 +00007191 if (isa<ClassTemplateDecl>(Specialized))
Douglas Gregor54888652009-10-07 00:13:32 +00007192 EntityKind = IsPartialSpecialization? 1 : 0;
Larisse Voufo39a1e502013-08-06 01:03:05 +00007193 else if (isa<VarTemplateDecl>(Specialized))
7194 EntityKind = IsPartialSpecialization ? 3 : 2;
Ted Kremenek7f1f3f62011-01-14 22:31:36 +00007195 else if (isa<FunctionTemplateDecl>(Specialized))
Douglas Gregor54888652009-10-07 00:13:32 +00007196 EntityKind = 4;
Larisse Voufo39a1e502013-08-06 01:03:05 +00007197 else if (isa<CXXMethodDecl>(Specialized))
Douglas Gregor54888652009-10-07 00:13:32 +00007198 EntityKind = 5;
Larisse Voufo39a1e502013-08-06 01:03:05 +00007199 else if (isa<VarDecl>(Specialized))
Richard Smith7d137e32012-03-23 03:33:32 +00007200 EntityKind = 6;
Larisse Voufo39a1e502013-08-06 01:03:05 +00007201 else if (isa<RecordDecl>(Specialized))
7202 EntityKind = 7;
7203 else if (isa<EnumDecl>(Specialized) && S.getLangOpts().CPlusPlus11)
7204 EntityKind = 8;
Douglas Gregor54888652009-10-07 00:13:32 +00007205 else {
Richard Smith7d137e32012-03-23 03:33:32 +00007206 S.Diag(Loc, diag::err_template_spec_unknown_kind)
Richard Smith2bf7fdb2013-01-02 11:42:31 +00007207 << S.getLangOpts().CPlusPlus11;
Douglas Gregorba8e1ac2009-10-14 23:50:59 +00007208 S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
Douglas Gregor54888652009-10-07 00:13:32 +00007209 return true;
7210 }
7211
Douglas Gregorf47b9112009-02-25 22:02:03 +00007212 // C++ [temp.expl.spec]p2:
Richard Smithc660c8f2018-03-16 13:36:56 +00007213 // An explicit specialization may be declared in any scope in which
7214 // the corresponding primary template may be defined.
Sebastian Redl50c68252010-08-31 00:36:30 +00007215 if (S.CurContext->getRedeclContext()->isFunctionOrMethod()) {
Douglas Gregor54888652009-10-07 00:13:32 +00007216 S.Diag(Loc, diag::err_template_spec_decl_function_scope)
Douglas Gregorba8e1ac2009-10-14 23:50:59 +00007217 << Specialized;
Douglas Gregorf47b9112009-02-25 22:02:03 +00007218 return true;
7219 }
Douglas Gregore4b05162009-10-07 17:21:34 +00007220
7221 // C++ [temp.class.spec]p6:
Richard Smithc660c8f2018-03-16 13:36:56 +00007222 // A class template partial specialization may be declared in any
7223 // scope in which the primary template may be defined.
7224 DeclContext *SpecializedContext =
7225 Specialized->getDeclContext()->getRedeclContext();
7226 DeclContext *DC = S.CurContext->getRedeclContext();
Richard Smitha98f8fc2013-12-07 05:09:50 +00007227
Richard Smithc660c8f2018-03-16 13:36:56 +00007228 // Make sure that this redeclaration (or definition) occurs in the same
7229 // scope or an enclosing namespace.
7230 if (!(DC->isFileContext() ? DC->Encloses(SpecializedContext)
7231 : DC->Equals(SpecializedContext))) {
Richard Smitha98f8fc2013-12-07 05:09:50 +00007232 if (isa<TranslationUnitDecl>(SpecializedContext))
7233 S.Diag(Loc, diag::err_template_spec_redecl_global_scope)
7234 << EntityKind << Specialized;
Richard Smithc660c8f2018-03-16 13:36:56 +00007235 else {
7236 auto *ND = cast<NamedDecl>(SpecializedContext);
Alexey Bataev0068cb22015-03-20 07:21:46 +00007237 int Diag = diag::err_template_spec_redecl_out_of_scope;
Richard Smithc660c8f2018-03-16 13:36:56 +00007238 if (S.getLangOpts().MicrosoftExt && !DC->isRecord())
Alexey Bataev0068cb22015-03-20 07:21:46 +00007239 Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
7240 S.Diag(Loc, Diag) << EntityKind << Specialized
Richard Smithc660c8f2018-03-16 13:36:56 +00007241 << ND << isa<CXXRecordDecl>(ND);
7242 }
Richard Smitha98f8fc2013-12-07 05:09:50 +00007243
7244 S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007245
Richard Smithc660c8f2018-03-16 13:36:56 +00007246 // Don't allow specializing in the wrong class during error recovery.
7247 // Otherwise, things can go horribly wrong.
7248 if (DC->isRecord())
7249 return true;
Douglas Gregorf47b9112009-02-25 22:02:03 +00007250 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007251
Douglas Gregorf47b9112009-02-25 22:02:03 +00007252 return false;
7253}
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007254
Richard Smith57aae072016-12-28 02:37:25 +00007255static SourceRange findTemplateParameterInType(unsigned Depth, Expr *E) {
7256 if (!E->isTypeDependent())
Richard Smith6056d5e2014-02-09 00:54:43 +00007257 return SourceLocation();
Richard Smith57aae072016-12-28 02:37:25 +00007258 DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
Richard Smith6056d5e2014-02-09 00:54:43 +00007259 Checker.TraverseStmt(E);
Richard Smith57aae072016-12-28 02:37:25 +00007260 if (Checker.MatchLoc.isInvalid())
Richard Smith6056d5e2014-02-09 00:54:43 +00007261 return E->getSourceRange();
7262 return Checker.MatchLoc;
7263}
7264
7265static SourceRange findTemplateParameter(unsigned Depth, TypeLoc TL) {
7266 if (!TL.getType()->isDependentType())
7267 return SourceLocation();
Richard Smith57aae072016-12-28 02:37:25 +00007268 DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
Richard Smith6056d5e2014-02-09 00:54:43 +00007269 Checker.TraverseTypeLoc(TL);
Richard Smith57aae072016-12-28 02:37:25 +00007270 if (Checker.MatchLoc.isInvalid())
Richard Smith6056d5e2014-02-09 00:54:43 +00007271 return TL.getSourceRange();
7272 return Checker.MatchLoc;
7273}
7274
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00007275/// Subroutine of Sema::CheckTemplatePartialSpecializationArgs
Douglas Gregor875b6fe2011-01-03 21:13:47 +00007276/// that checks non-type template partial specialization arguments.
Larisse Voufo39a1e502013-08-06 01:03:05 +00007277static bool CheckNonTypeTemplatePartialSpecializationArgs(
Richard Smith6056d5e2014-02-09 00:54:43 +00007278 Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param,
7279 const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument) {
Douglas Gregor875b6fe2011-01-03 21:13:47 +00007280 for (unsigned I = 0; I != NumArgs; ++I) {
7281 if (Args[I].getKind() == TemplateArgument::Pack) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00007282 if (CheckNonTypeTemplatePartialSpecializationArgs(
Richard Smith6056d5e2014-02-09 00:54:43 +00007283 S, TemplateNameLoc, Param, Args[I].pack_begin(),
7284 Args[I].pack_size(), IsDefaultArgument))
Douglas Gregor875b6fe2011-01-03 21:13:47 +00007285 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007286
Douglas Gregor8cfd2ba2009-06-12 21:21:02 +00007287 continue;
Douglas Gregor875b6fe2011-01-03 21:13:47 +00007288 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007289
Eli Friedmanb826a002012-09-26 02:36:12 +00007290 if (Args[I].getKind() != TemplateArgument::Expression)
Douglas Gregor8cfd2ba2009-06-12 21:21:02 +00007291 continue;
Eli Friedmanb826a002012-09-26 02:36:12 +00007292
7293 Expr *ArgExpr = Args[I].getAsExpr();
Douglas Gregor8cfd2ba2009-06-12 21:21:02 +00007294
Douglas Gregor98318c22011-01-03 21:37:45 +00007295 // We can have a pack expansion of any of the bullets below.
Douglas Gregor875b6fe2011-01-03 21:13:47 +00007296 if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(ArgExpr))
7297 ArgExpr = Expansion->getPattern();
Douglas Gregorca4686d2011-01-04 23:35:54 +00007298
7299 // Strip off any implicit casts we added as part of type checking.
7300 while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
7301 ArgExpr = ICE->getSubExpr();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007302
Douglas Gregor8cfd2ba2009-06-12 21:21:02 +00007303 // C++ [temp.class.spec]p8:
7304 // A non-type argument is non-specialized if it is the name of a
7305 // non-type parameter. All other non-type arguments are
7306 // specialized.
7307 //
7308 // Below, we check the two conditions that only apply to
7309 // specialized non-type arguments, so skip any non-specialized
7310 // arguments.
7311 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
Douglas Gregorca4686d2011-01-04 23:35:54 +00007312 if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
Douglas Gregor8cfd2ba2009-06-12 21:21:02 +00007313 continue;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007314
Douglas Gregor8cfd2ba2009-06-12 21:21:02 +00007315 // C++ [temp.class.spec]p9:
7316 // Within the argument list of a class template partial
7317 // specialization, the following restrictions apply:
7318 // -- A partially specialized non-type argument expression
7319 // shall not involve a template parameter of the partial
7320 // specialization except when the argument expression is a
7321 // simple identifier.
Richard Smith57aae072016-12-28 02:37:25 +00007322 // -- The type of a template parameter corresponding to a
7323 // specialized non-type argument shall not be dependent on a
7324 // parameter of the specialization.
7325 // DR1315 removes the first bullet, leaving an incoherent set of rules.
7326 // We implement a compromise between the original rules and DR1315:
7327 // -- A specialized non-type template argument shall not be
7328 // type-dependent and the corresponding template parameter
7329 // shall have a non-dependent type.
Richard Smith6056d5e2014-02-09 00:54:43 +00007330 SourceRange ParamUseRange =
Richard Smith57aae072016-12-28 02:37:25 +00007331 findTemplateParameterInType(Param->getDepth(), ArgExpr);
Richard Smith6056d5e2014-02-09 00:54:43 +00007332 if (ParamUseRange.isValid()) {
7333 if (IsDefaultArgument) {
7334 S.Diag(TemplateNameLoc,
7335 diag::err_dependent_non_type_arg_in_partial_spec);
7336 S.Diag(ParamUseRange.getBegin(),
7337 diag::note_dependent_non_type_default_arg_in_partial_spec)
7338 << ParamUseRange;
7339 } else {
7340 S.Diag(ParamUseRange.getBegin(),
7341 diag::err_dependent_non_type_arg_in_partial_spec)
7342 << ParamUseRange;
7343 }
Douglas Gregor8cfd2ba2009-06-12 21:21:02 +00007344 return true;
7345 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007346
Richard Smith6056d5e2014-02-09 00:54:43 +00007347 ParamUseRange = findTemplateParameter(
Richard Smith57aae072016-12-28 02:37:25 +00007348 Param->getDepth(), Param->getTypeSourceInfo()->getTypeLoc());
Richard Smith6056d5e2014-02-09 00:54:43 +00007349 if (ParamUseRange.isValid()) {
7350 S.Diag(IsDefaultArgument ? TemplateNameLoc : ArgExpr->getLocStart(),
7351 diag::err_dependent_typed_non_type_arg_in_partial_spec)
Richard Smith57aae072016-12-28 02:37:25 +00007352 << Param->getType();
Richard Smith6056d5e2014-02-09 00:54:43 +00007353 S.Diag(Param->getLocation(), diag::note_template_param_here)
Richard Smith57aae072016-12-28 02:37:25 +00007354 << (IsDefaultArgument ? ParamUseRange : SourceRange())
7355 << ParamUseRange;
Douglas Gregor8cfd2ba2009-06-12 21:21:02 +00007356 return true;
7357 }
7358 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007359
Douglas Gregor875b6fe2011-01-03 21:13:47 +00007360 return false;
7361}
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007362
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00007363/// Check the non-type template arguments of a class template
Douglas Gregor875b6fe2011-01-03 21:13:47 +00007364/// partial specialization according to C++ [temp.class.spec]p9.
7365///
Richard Smith6056d5e2014-02-09 00:54:43 +00007366/// \param TemplateNameLoc the location of the template name.
Simon Pilgrim6905d222016-12-30 22:55:33 +00007367/// \param PrimaryTemplate the template parameters of the primary class
Richard Smith6056d5e2014-02-09 00:54:43 +00007368/// template.
7369/// \param NumExplicit the number of explicitly-specified template arguments.
James Dennett634962f2012-06-14 21:40:34 +00007370/// \param TemplateArgs the template arguments of the class template
Richard Smith6056d5e2014-02-09 00:54:43 +00007371/// partial specialization.
Douglas Gregor875b6fe2011-01-03 21:13:47 +00007372///
Richard Smith6056d5e2014-02-09 00:54:43 +00007373/// \returns \c true if there was an error, \c false otherwise.
Richard Smith57aae072016-12-28 02:37:25 +00007374bool Sema::CheckTemplatePartialSpecializationArgs(
7375 SourceLocation TemplateNameLoc, TemplateDecl *PrimaryTemplate,
7376 unsigned NumExplicit, ArrayRef<TemplateArgument> TemplateArgs) {
7377 // We have to be conservative when checking a template in a dependent
7378 // context.
7379 if (PrimaryTemplate->getDeclContext()->isDependentContext())
7380 return false;
Douglas Gregor875b6fe2011-01-03 21:13:47 +00007381
Richard Smith57aae072016-12-28 02:37:25 +00007382 TemplateParameterList *TemplateParams =
7383 PrimaryTemplate->getTemplateParameters();
Douglas Gregor875b6fe2011-01-03 21:13:47 +00007384 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
7385 NonTypeTemplateParmDecl *Param
7386 = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I));
7387 if (!Param)
7388 continue;
7389
Richard Smith57aae072016-12-28 02:37:25 +00007390 if (CheckNonTypeTemplatePartialSpecializationArgs(*this, TemplateNameLoc,
7391 Param, &TemplateArgs[I],
7392 1, I >= NumExplicit))
Douglas Gregor875b6fe2011-01-03 21:13:47 +00007393 return true;
7394 }
Douglas Gregor8cfd2ba2009-06-12 21:21:02 +00007395
7396 return false;
7397}
7398
Erich Keanec480f302018-07-12 21:09:05 +00007399DeclResult Sema::ActOnClassTemplateSpecialization(
7400 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
7401 SourceLocation ModulePrivateLoc, TemplateIdAnnotation &TemplateId,
7402 const ParsedAttributesView &Attr,
7403 MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody) {
Douglas Gregor2208a292009-09-26 20:57:03 +00007404 assert(TUK != TUK_Reference && "References are not specializations");
John McCall06f6fe8d2009-09-04 01:14:41 +00007405
Richard Smith4b55a9c2014-04-17 03:29:33 +00007406 CXXScopeSpec &SS = TemplateId.SS;
7407
Abramo Bagnara60804e12011-03-18 15:16:37 +00007408 // NOTE: KWLoc is the location of the tag keyword. This will instead
7409 // store the location of the outermost template keyword in the declaration.
7410 SourceLocation TemplateKWLoc = TemplateParameterLists.size() > 0
Richard Smith4b55a9c2014-04-17 03:29:33 +00007411 ? TemplateParameterLists[0]->getTemplateLoc() : KWLoc;
7412 SourceLocation TemplateNameLoc = TemplateId.TemplateNameLoc;
7413 SourceLocation LAngleLoc = TemplateId.LAngleLoc;
7414 SourceLocation RAngleLoc = TemplateId.RAngleLoc;
Abramo Bagnara60804e12011-03-18 15:16:37 +00007415
Douglas Gregor67a65642009-02-17 23:15:12 +00007416 // Find the class template we're specializing
Richard Smith4b55a9c2014-04-17 03:29:33 +00007417 TemplateName Name = TemplateId.Template.get();
Mike Stump11289f42009-09-09 15:08:12 +00007418 ClassTemplateDecl *ClassTemplate
Douglas Gregordd6c0352009-11-12 00:46:20 +00007419 = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());
7420
7421 if (!ClassTemplate) {
7422 Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007423 << (Name.getAsTemplateDecl() &&
Douglas Gregordd6c0352009-11-12 00:46:20 +00007424 isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
7425 return true;
7426 }
Douglas Gregor67a65642009-02-17 23:15:12 +00007427
Richard Smithf445f192017-02-09 21:04:43 +00007428 bool isMemberSpecialization = false;
Douglas Gregor2373c592009-05-31 09:31:02 +00007429 bool isPartialSpecialization = false;
7430
Douglas Gregorf47b9112009-02-25 22:02:03 +00007431 // Check the validity of the template headers that introduce this
7432 // template.
Douglas Gregor2208a292009-09-26 20:57:03 +00007433 // FIXME: We probably shouldn't complain about these headers for
7434 // friend declarations.
Douglas Gregor5f0e2522010-07-14 23:14:12 +00007435 bool Invalid = false;
Robert Wilhelmf2d2e8f2013-07-21 15:20:44 +00007436 TemplateParameterList *TemplateParams =
7437 MatchTemplateParametersToScopeSpecifier(
Richard Smith4b55a9c2014-04-17 03:29:33 +00007438 KWLoc, TemplateNameLoc, SS, &TemplateId,
Richard Smithf445f192017-02-09 21:04:43 +00007439 TemplateParameterLists, TUK == TUK_Friend, isMemberSpecialization,
Richard Smith4b55a9c2014-04-17 03:29:33 +00007440 Invalid);
Douglas Gregor5f0e2522010-07-14 23:14:12 +00007441 if (Invalid)
7442 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007443
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00007444 if (TemplateParams && TemplateParams->size() > 0) {
7445 isPartialSpecialization = true;
Douglas Gregorf47b9112009-02-25 22:02:03 +00007446
Douglas Gregorec9518b2010-12-21 08:14:57 +00007447 if (TUK == TUK_Friend) {
7448 Diag(KWLoc, diag::err_partial_specialization_friend)
7449 << SourceRange(LAngleLoc, RAngleLoc);
7450 return true;
7451 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007452
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00007453 // C++ [temp.class.spec]p10:
7454 // The template parameter list of a specialization shall not
7455 // contain default template argument values.
7456 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
7457 Decl *Param = TemplateParams->getParam(I);
7458 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
7459 if (TTP->hasDefaultArgument()) {
Mike Stump11289f42009-09-09 15:08:12 +00007460 Diag(TTP->getDefaultArgumentLoc(),
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00007461 diag::err_default_arg_in_partial_spec);
John McCall0ad16662009-10-29 08:12:44 +00007462 TTP->removeDefaultArgument();
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00007463 }
7464 } else if (NonTypeTemplateParmDecl *NTTP
7465 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
7466 if (Expr *DefArg = NTTP->getDefaultArgument()) {
Mike Stump11289f42009-09-09 15:08:12 +00007467 Diag(NTTP->getDefaultArgumentLoc(),
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00007468 diag::err_default_arg_in_partial_spec)
7469 << DefArg->getSourceRange();
Abramo Bagnara656e3002010-06-09 09:26:05 +00007470 NTTP->removeDefaultArgument();
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00007471 }
7472 } else {
7473 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param);
Douglas Gregor9167f8b2009-11-11 01:00:40 +00007474 if (TTP->hasDefaultArgument()) {
7475 Diag(TTP->getDefaultArgument().getLocation(),
Douglas Gregor1d5e9f92009-08-25 17:23:04 +00007476 diag::err_default_arg_in_partial_spec)
Douglas Gregor9167f8b2009-11-11 01:00:40 +00007477 << TTP->getDefaultArgument().getSourceRange();
Abramo Bagnara656e3002010-06-09 09:26:05 +00007478 TTP->removeDefaultArgument();
Douglas Gregord5222052009-06-12 19:43:02 +00007479 }
7480 }
7481 }
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00007482 } else if (TemplateParams) {
7483 if (TUK == TUK_Friend)
7484 Diag(KWLoc, diag::err_template_spec_friend)
Douglas Gregora771f462010-03-31 17:46:05 +00007485 << FixItHint::CreateRemoval(
Douglas Gregor3a88c1d2009-10-13 14:39:41 +00007486 SourceRange(TemplateParams->getTemplateLoc(),
7487 TemplateParams->getRAngleLoc()))
7488 << SourceRange(LAngleLoc, RAngleLoc);
Richard Smith4b55a9c2014-04-17 03:29:33 +00007489 } else {
7490 assert(TUK == TUK_Friend && "should have a 'template<>' for this decl");
Douglas Gregor5c0405d2009-10-07 22:35:40 +00007491 }
Douglas Gregorf47b9112009-02-25 22:02:03 +00007492
Douglas Gregor67a65642009-02-17 23:15:12 +00007493 // Check that the specialization uses the same tag kind as the
7494 // original template.
Abramo Bagnara6150c882010-05-11 21:36:43 +00007495 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
7496 assert(Kind != TTK_Enum && "Invalid enum tag in class template spec!");
Douglas Gregord9034f02009-05-14 16:41:31 +00007497 if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
Richard Trieucaa33d32011-06-10 03:11:26 +00007498 Kind, TUK == TUK_Definition, KWLoc,
Justin Bognerc6ecb7c2015-07-10 23:05:47 +00007499 ClassTemplate->getIdentifier())) {
Mike Stump11289f42009-09-09 15:08:12 +00007500 Diag(KWLoc, diag::err_use_with_wrong_tag)
Douglas Gregor170512f2009-04-01 23:51:29 +00007501 << ClassTemplate
Douglas Gregora771f462010-03-31 17:46:05 +00007502 << FixItHint::CreateReplacement(KWLoc,
Douglas Gregor170512f2009-04-01 23:51:29 +00007503 ClassTemplate->getTemplatedDecl()->getKindName());
Mike Stump11289f42009-09-09 15:08:12 +00007504 Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
Douglas Gregor67a65642009-02-17 23:15:12 +00007505 diag::note_previous_use);
7506 Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
7507 }
7508
Douglas Gregorc40290e2009-03-09 23:48:35 +00007509 // Translate the parser's template argument list in our AST format.
Richard Smith4b55a9c2014-04-17 03:29:33 +00007510 TemplateArgumentListInfo TemplateArgs =
7511 makeTemplateArgumentListInfo(*this, TemplateId);
Douglas Gregorc40290e2009-03-09 23:48:35 +00007512
Douglas Gregor14406932011-01-03 20:35:03 +00007513 // Check for unexpanded parameter packs in any of the template arguments.
7514 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007515 if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
Douglas Gregor14406932011-01-03 20:35:03 +00007516 UPPC_PartialSpecialization))
7517 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007518
Douglas Gregor67a65642009-02-17 23:15:12 +00007519 // Check that the template argument list is well-formed for this
7520 // template.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007521 SmallVector<TemplateArgument, 4> Converted;
John McCall6b51f282009-11-23 01:53:49 +00007522 if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
7523 TemplateArgs, false, Converted))
Douglas Gregorc08f4892009-03-25 00:13:59 +00007524 return true;
Douglas Gregor67a65642009-02-17 23:15:12 +00007525
Douglas Gregor2373c592009-05-31 09:31:02 +00007526 // Find the class template (partial) specialization declaration that
Douglas Gregor67a65642009-02-17 23:15:12 +00007527 // corresponds to these arguments.
Douglas Gregord5222052009-06-12 19:43:02 +00007528 if (isPartialSpecialization) {
Richard Smith57aae072016-12-28 02:37:25 +00007529 if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, ClassTemplate,
7530 TemplateArgs.size(), Converted))
Douglas Gregor8cfd2ba2009-06-12 21:21:02 +00007531 return true;
7532
Richard Smith57aae072016-12-28 02:37:25 +00007533 // FIXME: Move this to CheckTemplatePartialSpecializationArgs so we
7534 // also do it during instantiation.
Douglas Gregor678d76c2011-07-01 01:22:09 +00007535 bool InstantiationDependent;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007536 if (!Name.isDependent() &&
Douglas Gregor92354b62010-02-09 00:37:32 +00007537 !TemplateSpecializationType::anyDependentTemplateArguments(
David Majnemer6fbeee32016-07-07 04:43:07 +00007538 TemplateArgs.arguments(), InstantiationDependent)) {
Douglas Gregor92354b62010-02-09 00:37:32 +00007539 Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
7540 << ClassTemplate->getDeclName();
7541 isPartialSpecialization = false;
Douglas Gregor92354b62010-02-09 00:37:32 +00007542 }
7543 }
Argyrios Kyrtzidis47470f22010-07-20 13:59:28 +00007544
Craig Topperc3ec1492014-05-26 06:22:03 +00007545 void *InsertPos = nullptr;
7546 ClassTemplateSpecializationDecl *PrevDecl = nullptr;
Douglas Gregor2373c592009-05-31 09:31:02 +00007547
7548 if (isPartialSpecialization)
Argyrios Kyrtzidis47470f22010-07-20 13:59:28 +00007549 // FIXME: Template parameter list matters, too
Craig Topper7e0daca2014-06-26 04:58:53 +00007550 PrevDecl = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
Douglas Gregor2373c592009-05-31 09:31:02 +00007551 else
Craig Topper7e0daca2014-06-26 04:58:53 +00007552 PrevDecl = ClassTemplate->findSpecialization(Converted, InsertPos);
Douglas Gregor67a65642009-02-17 23:15:12 +00007553
Craig Topperc3ec1492014-05-26 06:22:03 +00007554 ClassTemplateSpecializationDecl *Specialization = nullptr;
Douglas Gregor67a65642009-02-17 23:15:12 +00007555
Douglas Gregorf47b9112009-02-25 22:02:03 +00007556 // Check whether we can declare a class template specialization in
7557 // the current scope.
Douglas Gregor2208a292009-09-26 20:57:03 +00007558 if (TUK != TUK_Friend &&
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007559 CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl,
7560 TemplateNameLoc,
Douglas Gregorba8e1ac2009-10-14 23:50:59 +00007561 isPartialSpecialization))
Douglas Gregorc08f4892009-03-25 00:13:59 +00007562 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007563
Douglas Gregor15301382009-07-30 17:40:51 +00007564 // The canonical type
7565 QualType CanonType;
Richard Smith871cd4c2014-05-23 21:00:28 +00007566 if (isPartialSpecialization) {
Douglas Gregor15301382009-07-30 17:40:51 +00007567 // Build the canonical type that describes the converted template
7568 // arguments of the class template partial specialization.
Douglas Gregor92354b62010-02-09 00:37:32 +00007569 TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
7570 CanonType = Context.getTemplateSpecializationType(CanonTemplate,
David Majnemer6fbeee32016-07-07 04:43:07 +00007571 Converted);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007572
7573 if (Context.hasSameType(CanonType,
Douglas Gregordd7ec4632010-12-23 17:13:55 +00007574 ClassTemplate->getInjectedClassNameSpecialization())) {
7575 // C++ [temp.class.spec]p9b3:
7576 //
7577 // -- The argument list of the specialization shall not be identical
7578 // to the implicit argument list of the primary template.
Richard Smith0e617ec2016-12-27 07:56:27 +00007579 //
7580 // This rule has since been removed, because it's redundant given DR1495,
7581 // but we keep it because it produces better diagnostics and recovery.
Douglas Gregordd7ec4632010-12-23 17:13:55 +00007582 Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
Richard Smith300e0c32013-09-24 04:49:23 +00007583 << /*class template*/0 << (TUK == TUK_Definition)
Douglas Gregor26701a42011-09-09 02:06:17 +00007584 << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
Douglas Gregordd7ec4632010-12-23 17:13:55 +00007585 return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
7586 ClassTemplate->getIdentifier(),
7587 TemplateNameLoc,
7588 Attr,
7589 TemplateParams,
Douglas Gregor2820e692011-09-09 19:05:14 +00007590 AS_none, /*ModulePrivateLoc=*/SourceLocation(),
Nikola Smiljanic4fc91532014-07-17 01:59:34 +00007591 /*FriendLoc*/SourceLocation(),
Abramo Bagnara60804e12011-03-18 15:16:37 +00007592 TemplateParameterLists.size() - 1,
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00007593 TemplateParameterLists.data());
Douglas Gregordd7ec4632010-12-23 17:13:55 +00007594 }
Douglas Gregor15301382009-07-30 17:40:51 +00007595
Douglas Gregor2373c592009-05-31 09:31:02 +00007596 // Create a new class template partial specialization declaration node.
Douglas Gregor2373c592009-05-31 09:31:02 +00007597 ClassTemplatePartialSpecializationDecl *PrevPartial
7598 = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
Mike Stump11289f42009-09-09 15:08:12 +00007599 ClassTemplatePartialSpecializationDecl *Partial
Douglas Gregore9029562010-05-06 00:28:52 +00007600 = ClassTemplatePartialSpecializationDecl::Create(Context, Kind,
Douglas Gregor2373c592009-05-31 09:31:02 +00007601 ClassTemplate->getDeclContext(),
Abramo Bagnara29c2d462011-03-09 14:09:51 +00007602 KWLoc, TemplateNameLoc,
Anders Carlsson1b28c3e2009-06-05 04:06:48 +00007603 TemplateParams,
7604 ClassTemplate,
David Majnemer8b622692016-07-03 21:17:51 +00007605 Converted,
John McCall6b51f282009-11-23 01:53:49 +00007606 TemplateArgs,
John McCalle78aac42010-03-10 03:28:59 +00007607 CanonType,
Richard Smithb2f61b42013-08-22 23:27:37 +00007608 PrevPartial);
John McCall3e11ebe2010-03-15 10:12:16 +00007609 SetNestedNameSpecifier(Partial, SS);
Abramo Bagnara60804e12011-03-18 15:16:37 +00007610 if (TemplateParameterLists.size() > 1 && SS.isSet()) {
Benjamin Kramer9cc210652015-08-05 09:40:49 +00007611 Partial->setTemplateParameterListsInfo(
7612 Context, TemplateParameterLists.drop_back(1));
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00007613 }
Douglas Gregor2373c592009-05-31 09:31:02 +00007614
Argyrios Kyrtzidis47470f22010-07-20 13:59:28 +00007615 if (!PrevPartial)
7616 ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
Douglas Gregor2373c592009-05-31 09:31:02 +00007617 Specialization = Partial;
Douglas Gregor91772d12009-06-13 00:26:55 +00007618
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007619 // If we are providing an explicit specialization of a member class
Douglas Gregor21610382009-10-29 00:04:11 +00007620 // template specialization, make a note of that.
7621 if (PrevPartial && PrevPartial->getInstantiatedFromMember())
7622 PrevPartial->setMemberSpecialization();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007623
Richard Smith57aae072016-12-28 02:37:25 +00007624 CheckTemplatePartialSpecialization(Partial);
Douglas Gregor67a65642009-02-17 23:15:12 +00007625 } else {
7626 // Create a new class template specialization declaration node for
Douglas Gregor2208a292009-09-26 20:57:03 +00007627 // this explicit specialization or friend declaration.
Douglas Gregor67a65642009-02-17 23:15:12 +00007628 Specialization
Douglas Gregore9029562010-05-06 00:28:52 +00007629 = ClassTemplateSpecializationDecl::Create(Context, Kind,
Douglas Gregor67a65642009-02-17 23:15:12 +00007630 ClassTemplate->getDeclContext(),
Abramo Bagnara29c2d462011-03-09 14:09:51 +00007631 KWLoc, TemplateNameLoc,
Mike Stump11289f42009-09-09 15:08:12 +00007632 ClassTemplate,
David Majnemer8b622692016-07-03 21:17:51 +00007633 Converted,
Douglas Gregor67a65642009-02-17 23:15:12 +00007634 PrevDecl);
John McCall3e11ebe2010-03-15 10:12:16 +00007635 SetNestedNameSpecifier(Specialization, SS);
Abramo Bagnara60804e12011-03-18 15:16:37 +00007636 if (TemplateParameterLists.size() > 0) {
Douglas Gregor20527e22010-06-15 17:44:38 +00007637 Specialization->setTemplateParameterListsInfo(Context,
Benjamin Kramer9cc210652015-08-05 09:40:49 +00007638 TemplateParameterLists);
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00007639 }
Douglas Gregor67a65642009-02-17 23:15:12 +00007640
Argyrios Kyrtzidis47470f22010-07-20 13:59:28 +00007641 if (!PrevDecl)
7642 ClassTemplate->AddSpecialization(Specialization, InsertPos);
Douglas Gregor15301382009-07-30 17:40:51 +00007643
David Majnemer678f50b2015-11-18 19:49:19 +00007644 if (CurContext->isDependentContext()) {
David Majnemer678f50b2015-11-18 19:49:19 +00007645 TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
7646 CanonType = Context.getTemplateSpecializationType(
David Majnemer6fbeee32016-07-07 04:43:07 +00007647 CanonTemplate, Converted);
David Majnemer678f50b2015-11-18 19:49:19 +00007648 } else {
7649 CanonType = Context.getTypeDeclType(Specialization);
7650 }
Douglas Gregor67a65642009-02-17 23:15:12 +00007651 }
7652
Douglas Gregor06db9f52009-10-12 20:18:28 +00007653 // C++ [temp.expl.spec]p6:
7654 // If a template, a member template or the member of a class template is
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007655 // explicitly specialized then that specialization shall be declared
Douglas Gregor06db9f52009-10-12 20:18:28 +00007656 // before the first use of that specialization that would cause an implicit
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007657 // instantiation to take place, in every translation unit in which such a
Douglas Gregor06db9f52009-10-12 20:18:28 +00007658 // use occurs; no diagnostic is required.
7659 if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
Douglas Gregorc854c662010-02-26 06:03:23 +00007660 bool Okay = false;
Douglas Gregor0bc8a212012-01-14 15:55:47 +00007661 for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
Douglas Gregorc854c662010-02-26 06:03:23 +00007662 // Is there any previous explicit specialization declaration?
7663 if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
7664 Okay = true;
7665 break;
7666 }
7667 }
Douglas Gregor06db9f52009-10-12 20:18:28 +00007668
Douglas Gregorc854c662010-02-26 06:03:23 +00007669 if (!Okay) {
7670 SourceRange Range(TemplateNameLoc, RAngleLoc);
7671 Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
7672 << Context.getTypeDeclType(Specialization) << Range;
7673
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007674 Diag(PrevDecl->getPointOfInstantiation(),
Douglas Gregorc854c662010-02-26 06:03:23 +00007675 diag::note_instantiation_required_here)
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007676 << (PrevDecl->getTemplateSpecializationKind()
Douglas Gregor06db9f52009-10-12 20:18:28 +00007677 != TSK_ImplicitInstantiation);
Douglas Gregorc854c662010-02-26 06:03:23 +00007678 return true;
7679 }
Douglas Gregor06db9f52009-10-12 20:18:28 +00007680 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007681
Douglas Gregor2208a292009-09-26 20:57:03 +00007682 // If this is not a friend, note that this is an explicit specialization.
7683 if (TUK != TUK_Friend)
7684 Specialization->setSpecializationKind(TSK_ExplicitSpecialization);
Douglas Gregor67a65642009-02-17 23:15:12 +00007685
7686 // Check that this isn't a redefinition of this specialization.
John McCall9bb74a52009-07-31 02:45:11 +00007687 if (TUK == TUK_Definition) {
Richard Smithc7e6ff02015-05-18 20:36:47 +00007688 RecordDecl *Def = Specialization->getDefinition();
7689 NamedDecl *Hidden = nullptr;
7690 if (Def && SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
7691 SkipBody->ShouldSkip = true;
Richard Smith858e0e02017-05-11 23:11:16 +00007692 makeMergedDefinitionVisible(Hidden);
Richard Smithc7e6ff02015-05-18 20:36:47 +00007693 // From here on out, treat this as just a redeclaration.
7694 TUK = TUK_Declaration;
7695 } else if (Def) {
Douglas Gregor67a65642009-02-17 23:15:12 +00007696 SourceRange Range(TemplateNameLoc, RAngleLoc);
Richard Smith792c22d2016-12-24 04:09:05 +00007697 Diag(TemplateNameLoc, diag::err_redefinition) << Specialization << Range;
Douglas Gregor67a65642009-02-17 23:15:12 +00007698 Diag(Def->getLocation(), diag::note_previous_definition);
7699 Specialization->setInvalidDecl();
Douglas Gregorc08f4892009-03-25 00:13:59 +00007700 return true;
Douglas Gregor67a65642009-02-17 23:15:12 +00007701 }
7702 }
7703
Erich Keanec480f302018-07-12 21:09:05 +00007704 ProcessDeclAttributeList(S, Specialization, Attr);
John McCall659a3372010-12-18 03:30:47 +00007705
Richard Smith034b94a2012-08-17 03:20:55 +00007706 // Add alignment attributes if necessary; these attributes are checked when
7707 // the ASTContext lays out the structure.
7708 if (TUK == TUK_Definition) {
7709 AddAlignmentAttributesForRecord(Specialization);
7710 AddMsStructLayoutForRecord(Specialization);
7711 }
7712
Douglas Gregor3c7cd6a2011-09-09 20:53:38 +00007713 if (ModulePrivateLoc.isValid())
7714 Diag(Specialization->getLocation(), diag::err_module_private_specialization)
7715 << (isPartialSpecialization? 1 : 0)
7716 << FixItHint::CreateRemoval(ModulePrivateLoc);
Simon Pilgrim6905d222016-12-30 22:55:33 +00007717
Douglas Gregord56a91e2009-02-26 22:19:44 +00007718 // Build the fully-sugared type for this class template
7719 // specialization as the user wrote in the specialization
7720 // itself. This means that we'll pretty-print the type retrieved
7721 // from the specialization's declaration the way that the user
7722 // actually wrote the specialization, rather than formatting the
7723 // name based on the "canonical" representation used to store the
7724 // template arguments in the specialization.
John McCalle78aac42010-03-10 03:28:59 +00007725 TypeSourceInfo *WrittenTy
7726 = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
7727 TemplateArgs, CanonType);
Abramo Bagnara8075c852010-06-12 07:44:57 +00007728 if (TUK != TUK_Friend) {
Douglas Gregor2208a292009-09-26 20:57:03 +00007729 Specialization->setTypeAsWritten(WrittenTy);
Abramo Bagnara60804e12011-03-18 15:16:37 +00007730 Specialization->setTemplateKeywordLoc(TemplateKWLoc);
Abramo Bagnara8075c852010-06-12 07:44:57 +00007731 }
Douglas Gregor67a65642009-02-17 23:15:12 +00007732
Douglas Gregor1e249f82009-02-25 22:18:32 +00007733 // C++ [temp.expl.spec]p9:
7734 // A template explicit specialization is in the scope of the
7735 // namespace in which the template was defined.
7736 //
7737 // We actually implement this paragraph where we set the semantic
7738 // context (in the creation of the ClassTemplateSpecializationDecl),
7739 // but we also maintain the lexical context where the actual
7740 // definition occurs.
Douglas Gregor67a65642009-02-17 23:15:12 +00007741 Specialization->setLexicalDeclContext(CurContext);
Mike Stump11289f42009-09-09 15:08:12 +00007742
Douglas Gregor67a65642009-02-17 23:15:12 +00007743 // We may be starting the definition of this specialization.
John McCall9bb74a52009-07-31 02:45:11 +00007744 if (TUK == TUK_Definition)
Douglas Gregor67a65642009-02-17 23:15:12 +00007745 Specialization->startDefinition();
7746
Douglas Gregor2208a292009-09-26 20:57:03 +00007747 if (TUK == TUK_Friend) {
7748 FriendDecl *Friend = FriendDecl::Create(Context, CurContext,
7749 TemplateNameLoc,
John McCall15ad0962010-03-25 18:04:51 +00007750 WrittenTy,
Douglas Gregor2208a292009-09-26 20:57:03 +00007751 /*FIXME:*/KWLoc);
7752 Friend->setAccess(AS_public);
7753 CurContext->addDecl(Friend);
7754 } else {
7755 // Add the specialization into its lexical context, so that it can
7756 // be seen when iterating through the list of declarations in that
7757 // context. However, specializations are not found by name lookup.
7758 CurContext->addDecl(Specialization);
7759 }
John McCall48871652010-08-21 09:40:31 +00007760 return Specialization;
Douglas Gregor67a65642009-02-17 23:15:12 +00007761}
Douglas Gregor333489b2009-03-27 23:10:48 +00007762
John McCall48871652010-08-21 09:40:31 +00007763Decl *Sema::ActOnTemplateDeclarator(Scope *S,
Douglas Gregorb52fabb2009-06-23 23:11:28 +00007764 MultiTemplateParamsArg TemplateParameterLists,
John McCall48871652010-08-21 09:40:31 +00007765 Declarator &D) {
Benjamin Kramer62b95d82012-08-23 21:35:17 +00007766 Decl *NewDecl = HandleDeclarator(S, D, TemplateParameterLists);
Dmitri Gribenko34df2202012-07-31 22:37:06 +00007767 ActOnDocumentableDecl(NewDecl);
7768 return NewDecl;
Douglas Gregorb52fabb2009-06-23 23:11:28 +00007769}
7770
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00007771/// Strips various properties off an implicit instantiation
John McCall4f7ced62010-02-11 01:33:53 +00007772/// that has just been explicitly specialized.
7773static void StripImplicitInstantiation(NamedDecl *D) {
Nico Webere4974382014-12-19 23:52:45 +00007774 D->dropAttr<DLLImportAttr>();
7775 D->dropAttr<DLLExportAttr>();
John McCall4f7ced62010-02-11 01:33:53 +00007776
Nico Webere4974382014-12-19 23:52:45 +00007777 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
John McCall4f7ced62010-02-11 01:33:53 +00007778 FD->setInlineSpecified(false);
John McCall4f7ced62010-02-11 01:33:53 +00007779}
7780
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00007781/// Compute the diagnostic location for an explicit instantiation
Nico Webera8f80b32012-01-09 19:52:25 +00007782// declaration or definition.
7783static SourceLocation DiagLocForExplicitInstantiation(
Douglas Gregor0bc8a212012-01-14 15:55:47 +00007784 NamedDecl* D, SourceLocation PointOfInstantiation) {
Nico Webera8f80b32012-01-09 19:52:25 +00007785 // Explicit instantiations following a specialization have no effect and
7786 // hence no PointOfInstantiation. In that case, walk decl backwards
7787 // until a valid name loc is found.
7788 SourceLocation PrevDiagLoc = PointOfInstantiation;
Douglas Gregor0bc8a212012-01-14 15:55:47 +00007789 for (Decl *Prev = D; Prev && !PrevDiagLoc.isValid();
7790 Prev = Prev->getPreviousDecl()) {
Nico Webera8f80b32012-01-09 19:52:25 +00007791 PrevDiagLoc = Prev->getLocation();
7792 }
7793 assert(PrevDiagLoc.isValid() &&
7794 "Explicit instantiation without point of instantiation?");
7795 return PrevDiagLoc;
7796}
7797
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00007798/// Diagnose cases where we have an explicit template specialization
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007799/// before/after an explicit template instantiation, producing diagnostics
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007800/// for those cases where they are required and determining whether the
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007801/// new specialization/instantiation will have any effect.
7802///
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007803/// \param NewLoc the location of the new explicit specialization or
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007804/// instantiation.
7805///
7806/// \param NewTSK the kind of the new explicit specialization or instantiation.
7807///
7808/// \param PrevDecl the previous declaration of the entity.
7809///
7810/// \param PrevTSK the kind of the old explicit specialization or instantiatin.
7811///
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007812/// \param PrevPointOfInstantiation if valid, indicates where the previus
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007813/// declaration was instantiated (either implicitly or explicitly).
7814///
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007815/// \param HasNoEffect will be set to true to indicate that the new
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007816/// specialization or instantiation has no effect and should be ignored.
7817///
7818/// \returns true if there was an error that should prevent the introduction of
7819/// the new declaration into the AST, false otherwise.
Douglas Gregor1d957a32009-10-27 18:42:08 +00007820bool
7821Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
7822 TemplateSpecializationKind NewTSK,
7823 NamedDecl *PrevDecl,
7824 TemplateSpecializationKind PrevTSK,
7825 SourceLocation PrevPointOfInstantiation,
Abramo Bagnara8075c852010-06-12 07:44:57 +00007826 bool &HasNoEffect) {
7827 HasNoEffect = false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007828
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007829 switch (NewTSK) {
7830 case TSK_Undeclared:
7831 case TSK_ImplicitInstantiation:
David Majnemer192d1792013-11-27 08:20:38 +00007832 assert(
7833 (PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) &&
7834 "previous declaration must be implicit!");
7835 return false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007836
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007837 case TSK_ExplicitSpecialization:
7838 switch (PrevTSK) {
7839 case TSK_Undeclared:
7840 case TSK_ExplicitSpecialization:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007841 // Okay, we're just specializing something that is either already
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007842 // explicitly specialized or has merely been mentioned without any
7843 // instantiation.
7844 return false;
7845
7846 case TSK_ImplicitInstantiation:
7847 if (PrevPointOfInstantiation.isInvalid()) {
7848 // The declaration itself has not actually been instantiated, so it is
7849 // still okay to specialize it.
John McCall4f7ced62010-02-11 01:33:53 +00007850 StripImplicitInstantiation(PrevDecl);
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007851 return false;
7852 }
7853 // Fall through
Galina Kistanova3779cb32017-06-07 06:25:05 +00007854 LLVM_FALLTHROUGH;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007855
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007856 case TSK_ExplicitInstantiationDeclaration:
7857 case TSK_ExplicitInstantiationDefinition:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007858 assert((PrevTSK == TSK_ImplicitInstantiation ||
7859 PrevPointOfInstantiation.isValid()) &&
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007860 "Explicit instantiation without point of instantiation?");
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007861
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007862 // C++ [temp.expl.spec]p6:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007863 // If a template, a member template or the member of a class template
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007864 // is explicitly specialized then that specialization shall be declared
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007865 // before the first use of that specialization that would cause an
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007866 // implicit instantiation to take place, in every translation unit in
7867 // which such a use occurs; no diagnostic is required.
Douglas Gregor0bc8a212012-01-14 15:55:47 +00007868 for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
Douglas Gregorc854c662010-02-26 06:03:23 +00007869 // Is there any previous explicit specialization declaration?
7870 if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization)
7871 return false;
7872 }
7873
Douglas Gregor1d957a32009-10-27 18:42:08 +00007874 Diag(NewLoc, diag::err_specialization_after_instantiation)
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007875 << PrevDecl;
Douglas Gregor1d957a32009-10-27 18:42:08 +00007876 Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007877 << (PrevTSK != TSK_ImplicitInstantiation);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007878
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007879 return true;
7880 }
Galina Kistanova1d36e832017-06-08 18:20:32 +00007881 llvm_unreachable("The switch over PrevTSK must be exhaustive.");
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007882
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007883 case TSK_ExplicitInstantiationDeclaration:
7884 switch (PrevTSK) {
7885 case TSK_ExplicitInstantiationDeclaration:
7886 // This explicit instantiation declaration is redundant (that's okay).
Abramo Bagnara8075c852010-06-12 07:44:57 +00007887 HasNoEffect = true;
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007888 return false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007889
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007890 case TSK_Undeclared:
7891 case TSK_ImplicitInstantiation:
7892 // We're explicitly instantiating something that may have already been
7893 // implicitly instantiated; that's fine.
7894 return false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007895
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007896 case TSK_ExplicitSpecialization:
7897 // C++0x [temp.explicit]p4:
7898 // For a given set of template parameters, if an explicit instantiation
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007899 // of a template appears after a declaration of an explicit
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007900 // specialization for that template, the explicit instantiation has no
7901 // effect.
Abramo Bagnara8075c852010-06-12 07:44:57 +00007902 HasNoEffect = true;
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007903 return false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007904
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007905 case TSK_ExplicitInstantiationDefinition:
7906 // C++0x [temp.explicit]p10:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007907 // If an entity is the subject of both an explicit instantiation
7908 // declaration and an explicit instantiation definition in the same
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007909 // translation unit, the definition shall follow the declaration.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007910 Diag(NewLoc,
Douglas Gregor1d957a32009-10-27 18:42:08 +00007911 diag::err_explicit_instantiation_declaration_after_definition);
Nico Weberd3bdadf2011-12-23 20:58:04 +00007912
7913 // Explicit instantiations following a specialization have no effect and
7914 // hence no PrevPointOfInstantiation. In that case, walk decl backwards
7915 // until a valid name loc is found.
Nico Webera8f80b32012-01-09 19:52:25 +00007916 Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
7917 diag::note_explicit_instantiation_definition_here);
Abramo Bagnara8075c852010-06-12 07:44:57 +00007918 HasNoEffect = true;
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007919 return false;
7920 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007921
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007922 case TSK_ExplicitInstantiationDefinition:
7923 switch (PrevTSK) {
7924 case TSK_Undeclared:
7925 case TSK_ImplicitInstantiation:
7926 // We're explicitly instantiating something that may have already been
7927 // implicitly instantiated; that's fine.
7928 return false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007929
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007930 case TSK_ExplicitSpecialization:
7931 // C++ DR 259, C++0x [temp.explicit]p4:
7932 // For a given set of template parameters, if an explicit
7933 // instantiation of a template appears after a declaration of
7934 // an explicit specialization for that template, the explicit
7935 // instantiation has no effect.
Richard Smithe4caa482016-08-31 23:23:25 +00007936 Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
Richard Smith0bf8a4922011-10-18 20:49:44 +00007937 << PrevDecl;
7938 Diag(PrevDecl->getLocation(),
7939 diag::note_previous_template_specialization);
Abramo Bagnara8075c852010-06-12 07:44:57 +00007940 HasNoEffect = true;
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007941 return false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007942
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007943 case TSK_ExplicitInstantiationDeclaration:
Alexander Kornienko2a8c18d2018-04-06 15:14:32 +00007944 // We're explicitly instantiating a definition for something for which we
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007945 // were previously asked to suppress instantiations. That's fine.
Nico Weberd3bdadf2011-12-23 20:58:04 +00007946
7947 // C++0x [temp.explicit]p4:
7948 // For a given set of template parameters, if an explicit instantiation
7949 // of a template appears after a declaration of an explicit
7950 // specialization for that template, the explicit instantiation has no
7951 // effect.
Douglas Gregor0bc8a212012-01-14 15:55:47 +00007952 for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
Nico Weberd3bdadf2011-12-23 20:58:04 +00007953 // Is there any previous explicit specialization declaration?
7954 if (getTemplateSpecializationKind(Prev) == TSK_ExplicitSpecialization) {
7955 HasNoEffect = true;
7956 break;
7957 }
7958 }
7959
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007960 return false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007961
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007962 case TSK_ExplicitInstantiationDefinition:
7963 // C++0x [temp.spec]p5:
7964 // For a given template and a given set of template-arguments,
7965 // - an explicit instantiation definition shall appear at most once
7966 // in a program,
Will Wilsoneadcdbb2014-05-09 09:52:13 +00007967
7968 // MSVCCompat: MSVC silently ignores duplicate explicit instantiations.
7969 Diag(NewLoc, (getLangOpts().MSVCCompat)
Richard Smith1b98ccc2014-07-19 01:39:17 +00007970 ? diag::ext_explicit_instantiation_duplicate
Will Wilsoneadcdbb2014-05-09 09:52:13 +00007971 : diag::err_explicit_instantiation_duplicate)
7972 << PrevDecl;
Nico Webera8f80b32012-01-09 19:52:25 +00007973 Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
Douglas Gregor1d957a32009-10-27 18:42:08 +00007974 diag::note_previous_explicit_instantiation);
Abramo Bagnara8075c852010-06-12 07:44:57 +00007975 HasNoEffect = true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007976 return false;
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007977 }
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007978 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00007979
David Blaikie83d382b2011-09-23 05:06:16 +00007980 llvm_unreachable("Missing specialization/instantiation case?");
Douglas Gregord6ba93d2009-10-15 15:54:05 +00007981}
7982
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00007983/// Perform semantic analysis for the given dependent function
James Dennettf14a6e52012-06-15 22:23:43 +00007984/// template specialization.
John McCallb9c78482010-04-08 09:05:18 +00007985///
James Dennettf14a6e52012-06-15 22:23:43 +00007986/// The only possible way to get a dependent function template specialization
7987/// is with a friend declaration, like so:
7988///
7989/// \code
7990/// template \<class T> void foo(T);
7991/// template \<class T> class A {
John McCallb9c78482010-04-08 09:05:18 +00007992/// friend void foo<>(T);
7993/// };
James Dennettf14a6e52012-06-15 22:23:43 +00007994/// \endcode
John McCallb9c78482010-04-08 09:05:18 +00007995///
7996/// There really isn't any useful analysis we can do here, so we
7997/// just store the information.
7998bool
7999Sema::CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
8000 const TemplateArgumentListInfo &ExplicitTemplateArgs,
8001 LookupResult &Previous) {
8002 // Remove anything from Previous that isn't a function template in
8003 // the correct context.
Sebastian Redl50c68252010-08-31 00:36:30 +00008004 DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
John McCallb9c78482010-04-08 09:05:18 +00008005 LookupResult::Filter F = Previous.makeFilter();
8006 while (F.hasNext()) {
8007 NamedDecl *D = F.next()->getUnderlyingDecl();
8008 if (!isa<FunctionTemplateDecl>(D) ||
Sebastian Redl50c68252010-08-31 00:36:30 +00008009 !FDLookupContext->InEnclosingNamespaceSetOf(
8010 D->getDeclContext()->getRedeclContext()))
John McCallb9c78482010-04-08 09:05:18 +00008011 F.erase();
8012 }
8013 F.done();
8014
8015 // Should this be diagnosed here?
8016 if (Previous.empty()) return true;
8017
8018 FD->setDependentTemplateSpecialization(Context, Previous.asUnresolvedSet(),
8019 ExplicitTemplateArgs);
8020 return false;
8021}
8022
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00008023/// Perform semantic analysis for the given function template
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008024/// specialization.
8025///
Abramo Bagnara02ccd282010-05-20 15:32:11 +00008026/// This routine performs all of the semantic analysis required for an
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008027/// explicit function template specialization. On successful completion,
8028/// the function declaration \p FD will become a function template
8029/// specialization.
8030///
8031/// \param FD the function declaration, which will be updated to become a
8032/// function template specialization.
8033///
Abramo Bagnara02ccd282010-05-20 15:32:11 +00008034/// \param ExplicitTemplateArgs the explicitly-provided template arguments,
8035/// if any. Note that this may be valid info even when 0 arguments are
8036/// explicitly provided as in, e.g., \c void sort<>(char*, char*);
8037/// as it anyway contains info on the angle brackets locations.
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008038///
Francois Pichet3a44e432011-07-08 06:21:47 +00008039/// \param Previous the set of declarations that may be specialized by
Abramo Bagnara02ccd282010-05-20 15:32:11 +00008040/// this function specialization.
Larisse Voufo98b20f12013-07-19 23:00:19 +00008041bool Sema::CheckFunctionTemplateSpecialization(
8042 FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
8043 LookupResult &Previous) {
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008044 // The set of function template specializations that could match this
8045 // explicit function template specialization.
John McCall58cc69d2010-01-27 01:50:18 +00008046 UnresolvedSet<8> Candidates;
George Burgess IV3e3bb95b2015-12-02 21:58:08 +00008047 TemplateSpecCandidateSet FailedCandidates(FD->getLocation(),
8048 /*ForTakingAddress=*/false);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008049
Richard Smith7d3c3ef2015-10-02 00:49:37 +00008050 llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
8051 ConvertedTemplateArgs;
8052
Sebastian Redl50c68252010-08-31 00:36:30 +00008053 DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
John McCall1f82f242009-11-18 22:49:29 +00008054 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
8055 I != E; ++I) {
8056 NamedDecl *Ovl = (*I)->getUnderlyingDecl();
8057 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008058 // Only consider templates found within the same semantic lookup scope as
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008059 // FD.
Sebastian Redl50c68252010-08-31 00:36:30 +00008060 if (!FDLookupContext->InEnclosingNamespaceSetOf(
8061 Ovl->getDeclContext()->getRedeclContext()))
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008062 continue;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008063
Richard Smith574f4f62013-01-14 05:37:29 +00008064 // When matching a constexpr member function template specialization
8065 // against the primary template, we don't yet know whether the
8066 // specialization has an implicit 'const' (because we don't know whether
8067 // it will be a static member function until we know which template it
8068 // specializes), so adjust it now assuming it specializes this template.
8069 QualType FT = FD->getType();
8070 if (FD->isConstexpr()) {
Rafael Espindola92045bc2013-11-19 21:07:04 +00008071 CXXMethodDecl *OldMD =
8072 dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
Richard Smith574f4f62013-01-14 05:37:29 +00008073 if (OldMD && OldMD->isConst()) {
Rafael Espindola92045bc2013-11-19 21:07:04 +00008074 const FunctionProtoType *FPT = FT->castAs<FunctionProtoType>();
Richard Smith574f4f62013-01-14 05:37:29 +00008075 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8076 EPI.TypeQuals |= Qualifiers::Const;
Alp Toker314cc812014-01-25 16:55:45 +00008077 FT = Context.getFunctionType(FPT->getReturnType(),
Alp Toker9cacbab2014-01-20 20:26:09 +00008078 FPT->getParamTypes(), EPI);
Richard Smith574f4f62013-01-14 05:37:29 +00008079 }
8080 }
8081
Richard Smith7d3c3ef2015-10-02 00:49:37 +00008082 TemplateArgumentListInfo Args;
8083 if (ExplicitTemplateArgs)
8084 Args = *ExplicitTemplateArgs;
8085
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008086 // C++ [temp.expl.spec]p11:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008087 // A trailing template-argument can be left unspecified in the
8088 // template-id naming an explicit function template specialization
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008089 // provided it can be deduced from the function argument type.
8090 // Perform template argument deduction to determine whether we may be
8091 // specializing this template.
8092 // FIXME: It is somewhat wasteful to build
Larisse Voufo98b20f12013-07-19 23:00:19 +00008093 TemplateDeductionInfo Info(FailedCandidates.getLocation());
Craig Topperc3ec1492014-05-26 06:22:03 +00008094 FunctionDecl *Specialization = nullptr;
Richard Smith32983682013-12-14 03:18:05 +00008095 if (TemplateDeductionResult TDK = DeduceTemplateArguments(
8096 cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
Richard Smithc2bebe92016-05-11 20:37:46 +00008097 ExplicitTemplateArgs ? &Args : nullptr, FT, Specialization,
8098 Info)) {
Larisse Voufo98b20f12013-07-19 23:00:19 +00008099 // Template argument deduction failed; record why it failed, so
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008100 // that we can provide nifty diagnostics.
Richard Smithc2bebe92016-05-11 20:37:46 +00008101 FailedCandidates.addCandidate().set(
8102 I.getPair(), FunTmpl->getTemplatedDecl(),
8103 MakeDeductionFailureInfo(Context, TDK, Info));
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008104 (void)TDK;
8105 continue;
8106 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008107
Artem Belevich64135c32016-12-08 19:38:13 +00008108 // Target attributes are part of the cuda function signature, so
8109 // the deduced template's cuda target must match that of the
8110 // specialization. Given that C++ template deduction does not
8111 // take target attributes into account, we reject candidates
8112 // here that have a different target.
Artem Belevich13e9b4d2016-12-07 19:27:16 +00008113 if (LangOpts.CUDA &&
Artem Belevich64135c32016-12-08 19:38:13 +00008114 IdentifyCUDATarget(Specialization,
8115 /* IgnoreImplicitHDAttributes = */ true) !=
8116 IdentifyCUDATarget(FD, /* IgnoreImplicitHDAttributes = */ true)) {
Artem Belevich13e9b4d2016-12-07 19:27:16 +00008117 FailedCandidates.addCandidate().set(
8118 I.getPair(), FunTmpl->getTemplatedDecl(),
8119 MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
8120 continue;
8121 }
8122
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008123 // Record this candidate.
Richard Smith7d3c3ef2015-10-02 00:49:37 +00008124 if (ExplicitTemplateArgs)
8125 ConvertedTemplateArgs[Specialization] = std::move(Args);
John McCall58cc69d2010-01-27 01:50:18 +00008126 Candidates.addDecl(Specialization, I.getAccess());
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008127 }
8128 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008129
Douglas Gregor5de279c2009-09-26 03:41:46 +00008130 // Find the most specialized function template.
Larisse Voufo98b20f12013-07-19 23:00:19 +00008131 UnresolvedSetIterator Result = getMostSpecialized(
Richard Smith35e1da22013-09-10 22:59:25 +00008132 Candidates.begin(), Candidates.end(), FailedCandidates,
Larisse Voufo98b20f12013-07-19 23:00:19 +00008133 FD->getLocation(),
8134 PDiag(diag::err_function_template_spec_no_match) << FD->getDeclName(),
8135 PDiag(diag::err_function_template_spec_ambiguous)
Craig Topperc3ec1492014-05-26 06:22:03 +00008136 << FD->getDeclName() << (ExplicitTemplateArgs != nullptr),
Larisse Voufo98b20f12013-07-19 23:00:19 +00008137 PDiag(diag::note_function_template_spec_matched));
8138
John McCall58cc69d2010-01-27 01:50:18 +00008139 if (Result == Candidates.end())
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008140 return true;
John McCall58cc69d2010-01-27 01:50:18 +00008141
8142 // Ignore access information; it doesn't figure into redeclaration checking.
8143 FunctionDecl *Specialization = cast<FunctionDecl>(*Result);
Abramo Bagnarab9893d62011-03-04 17:20:30 +00008144
8145 FunctionTemplateSpecializationInfo *SpecInfo
8146 = Specialization->getTemplateSpecializationInfo();
8147 assert(SpecInfo && "Function template specialization info missing?");
Francois Pichet3a44e432011-07-08 06:21:47 +00008148
8149 // Note: do not overwrite location info if previous template
8150 // specialization kind was explicit.
8151 TemplateSpecializationKind TSK = SpecInfo->getTemplateSpecializationKind();
Richard Smith5b8b3db2012-02-20 23:28:05 +00008152 if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation) {
Francois Pichet3a44e432011-07-08 06:21:47 +00008153 Specialization->setLocation(FD->getLocation());
Richard Smith54f04402017-05-18 02:29:20 +00008154 Specialization->setLexicalDeclContext(FD->getLexicalDeclContext());
Richard Smith5b8b3db2012-02-20 23:28:05 +00008155 // C++11 [dcl.constexpr]p1: An explicit specialization of a constexpr
8156 // function can differ from the template declaration with respect to
8157 // the constexpr specifier.
Richard Smith77e9e842017-05-09 23:02:10 +00008158 // FIXME: We need an update record for this AST mutation.
8159 // FIXME: What if there are multiple such prior declarations (for instance,
8160 // from different modules)?
Richard Smith5b8b3db2012-02-20 23:28:05 +00008161 Specialization->setConstexpr(FD->isConstexpr());
8162 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008163
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008164 // FIXME: Check if the prior specialization has a point of instantiation.
Douglas Gregor06db9f52009-10-12 20:18:28 +00008165 // If so, we have run afoul of .
John McCall816d75b2010-03-24 07:46:06 +00008166
8167 // If this is a friend declaration, then we're not really declaring
8168 // an explicit specialization.
8169 bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008170
Douglas Gregor54888652009-10-07 00:13:32 +00008171 // Check the scope of this explicit specialization.
John McCall816d75b2010-03-24 07:46:06 +00008172 if (!isFriend &&
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008173 CheckTemplateSpecializationScope(*this,
Douglas Gregor54888652009-10-07 00:13:32 +00008174 Specialization->getPrimaryTemplate(),
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008175 Specialization, FD->getLocation(),
Douglas Gregorba8e1ac2009-10-14 23:50:59 +00008176 false))
Douglas Gregor54888652009-10-07 00:13:32 +00008177 return true;
Douglas Gregor06db9f52009-10-12 20:18:28 +00008178
8179 // C++ [temp.expl.spec]p6:
8180 // If a template, a member template or the member of a class template is
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008181 // explicitly specialized then that specialization shall be declared
Douglas Gregor06db9f52009-10-12 20:18:28 +00008182 // before the first use of that specialization that would cause an implicit
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008183 // instantiation to take place, in every translation unit in which such a
Douglas Gregor06db9f52009-10-12 20:18:28 +00008184 // use occurs; no diagnostic is required.
Abramo Bagnara8075c852010-06-12 07:44:57 +00008185 bool HasNoEffect = false;
John McCall816d75b2010-03-24 07:46:06 +00008186 if (!isFriend &&
8187 CheckSpecializationInstantiationRedecl(FD->getLocation(),
John McCall4f7ced62010-02-11 01:33:53 +00008188 TSK_ExplicitSpecialization,
8189 Specialization,
8190 SpecInfo->getTemplateSpecializationKind(),
8191 SpecInfo->getPointOfInstantiation(),
Abramo Bagnara8075c852010-06-12 07:44:57 +00008192 HasNoEffect))
Douglas Gregor06db9f52009-10-12 20:18:28 +00008193 return true;
Simon Pilgrim6905d222016-12-30 22:55:33 +00008194
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008195 // Mark the prior declaration as an explicit specialization, so that later
8196 // clients know that this is an explicit specialization.
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00008197 if (!isFriend) {
Faisal Vali81a88be2016-06-14 03:23:15 +00008198 // Since explicit specializations do not inherit '=delete' from their
8199 // primary function template - check if the 'specialization' that was
8200 // implicitly generated (during template argument deduction for partial
8201 // ordering) from the most specialized of all the function templates that
8202 // 'FD' could have been specializing, has a 'deleted' definition. If so,
8203 // first check that it was implicitly generated during template argument
8204 // deduction by making sure it wasn't referenced, and then reset the deleted
8205 // flag to not-deleted, so that we can inherit that information from 'FD'.
8206 if (Specialization->isDeleted() && !SpecInfo->isExplicitSpecialization() &&
8207 !Specialization->getCanonicalDecl()->isReferenced()) {
Richard Smith77e9e842017-05-09 23:02:10 +00008208 // FIXME: This assert will not hold in the presence of modules.
Faisal Vali81a88be2016-06-14 03:23:15 +00008209 assert(
8210 Specialization->getCanonicalDecl() == Specialization &&
8211 "This must be the only existing declaration of this specialization");
Richard Smith77e9e842017-05-09 23:02:10 +00008212 // FIXME: We need an update record for this AST mutation.
Faisal Vali81a88be2016-06-14 03:23:15 +00008213 Specialization->setDeletedAsWritten(false);
Faisal Vali5e9e8ac2016-04-17 17:32:04 +00008214 }
Richard Smith54f04402017-05-18 02:29:20 +00008215 // FIXME: We need an update record for this AST mutation.
John McCall816d75b2010-03-24 07:46:06 +00008216 SpecInfo->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00008217 MarkUnusedFileScopedDecl(Specialization);
8218 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008219
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008220 // Turn the given function declaration into a function template
8221 // specialization, with the template arguments from the previous
8222 // specialization.
Abramo Bagnara02ccd282010-05-20 15:32:11 +00008223 // Take copies of (semantic and syntactic) template argument lists.
8224 const TemplateArgumentList* TemplArgs = new (Context)
8225 TemplateArgumentList(Specialization->getTemplateSpecializationArgs());
Richard Smith7d3c3ef2015-10-02 00:49:37 +00008226 FD->setFunctionTemplateSpecialization(
8227 Specialization->getPrimaryTemplate(), TemplArgs, /*InsertPos=*/nullptr,
8228 SpecInfo->getTemplateSpecializationKind(),
8229 ExplicitTemplateArgs ? &ConvertedTemplateArgs[Specialization] : nullptr);
Rafael Espindola6ae7e502013-04-03 19:27:57 +00008230
Artem Belevich64135c32016-12-08 19:38:13 +00008231 // A function template specialization inherits the target attributes
8232 // of its template. (We require the attributes explicitly in the
8233 // code to match, but a template may have implicit attributes by
8234 // virtue e.g. of being constexpr, and it passes these implicit
8235 // attributes on to its specializations.)
8236 if (LangOpts.CUDA)
8237 inheritCUDATargetAttrs(FD, *Specialization->getPrimaryTemplate());
8238
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008239 // The "previous declaration" for this function template specialization is
8240 // the prior function template specialization.
John McCall1f82f242009-11-18 22:49:29 +00008241 Previous.clear();
8242 Previous.addDecl(Specialization);
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00008243 return false;
8244}
8245
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00008246/// Perform semantic analysis for the given non-template member
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008247/// specialization.
8248///
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008249/// This routine performs all of the semantic analysis required for an
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008250/// explicit member function specialization. On successful completion,
8251/// the function declaration \p FD will become a member function
8252/// specialization.
8253///
Douglas Gregor86d142a2009-10-08 07:24:58 +00008254/// \param Member the member declaration, which will be updated to become a
8255/// specialization.
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008256///
John McCall1f82f242009-11-18 22:49:29 +00008257/// \param Previous the set of declarations, one of which may be specialized
8258/// by this function specialization; the set will be modified to contain the
8259/// redeclared member.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008260bool
John McCall1f82f242009-11-18 22:49:29 +00008261Sema::CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous) {
Douglas Gregor86d142a2009-10-08 07:24:58 +00008262 assert(!isa<TemplateDecl>(Member) && "Only for non-template members");
John McCalle820e5e2010-04-13 20:37:33 +00008263
Douglas Gregor86d142a2009-10-08 07:24:58 +00008264 // Try to find the member we are instantiating.
Richard Smith22e7cc62016-05-24 00:01:49 +00008265 NamedDecl *FoundInstantiation = nullptr;
Craig Topperc3ec1492014-05-26 06:22:03 +00008266 NamedDecl *Instantiation = nullptr;
8267 NamedDecl *InstantiatedFrom = nullptr;
8268 MemberSpecializationInfo *MSInfo = nullptr;
Douglas Gregor06db9f52009-10-12 20:18:28 +00008269
John McCall1f82f242009-11-18 22:49:29 +00008270 if (Previous.empty()) {
Douglas Gregor86d142a2009-10-08 07:24:58 +00008271 // Nowhere to look anyway.
8272 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Member)) {
John McCall1f82f242009-11-18 22:49:29 +00008273 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
8274 I != E; ++I) {
8275 NamedDecl *D = (*I)->getUnderlyingDecl();
8276 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
Rafael Espindola66747222013-12-10 00:59:31 +00008277 QualType Adjusted = Function->getType();
8278 if (!hasExplicitCallingConv(Adjusted))
8279 Adjusted = adjustCCAndNoReturn(Adjusted, Method->getType());
8280 if (Context.hasSameType(Adjusted, Method->getType())) {
Richard Smith22e7cc62016-05-24 00:01:49 +00008281 FoundInstantiation = *I;
Douglas Gregor86d142a2009-10-08 07:24:58 +00008282 Instantiation = Method;
8283 InstantiatedFrom = Method->getInstantiatedFromMemberFunction();
Douglas Gregor06db9f52009-10-12 20:18:28 +00008284 MSInfo = Method->getMemberSpecializationInfo();
Douglas Gregor86d142a2009-10-08 07:24:58 +00008285 break;
8286 }
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008287 }
8288 }
Douglas Gregor86d142a2009-10-08 07:24:58 +00008289 } else if (isa<VarDecl>(Member)) {
John McCall1f82f242009-11-18 22:49:29 +00008290 VarDecl *PrevVar;
8291 if (Previous.isSingleResult() &&
8292 (PrevVar = dyn_cast<VarDecl>(Previous.getFoundDecl())))
Douglas Gregor86d142a2009-10-08 07:24:58 +00008293 if (PrevVar->isStaticDataMember()) {
Richard Smith22e7cc62016-05-24 00:01:49 +00008294 FoundInstantiation = Previous.getRepresentativeDecl();
John McCall1f82f242009-11-18 22:49:29 +00008295 Instantiation = PrevVar;
Douglas Gregor86d142a2009-10-08 07:24:58 +00008296 InstantiatedFrom = PrevVar->getInstantiatedFromStaticDataMember();
Douglas Gregor06db9f52009-10-12 20:18:28 +00008297 MSInfo = PrevVar->getMemberSpecializationInfo();
Douglas Gregor86d142a2009-10-08 07:24:58 +00008298 }
8299 } else if (isa<RecordDecl>(Member)) {
John McCall1f82f242009-11-18 22:49:29 +00008300 CXXRecordDecl *PrevRecord;
8301 if (Previous.isSingleResult() &&
8302 (PrevRecord = dyn_cast<CXXRecordDecl>(Previous.getFoundDecl()))) {
Richard Smith22e7cc62016-05-24 00:01:49 +00008303 FoundInstantiation = Previous.getRepresentativeDecl();
John McCall1f82f242009-11-18 22:49:29 +00008304 Instantiation = PrevRecord;
Douglas Gregor86d142a2009-10-08 07:24:58 +00008305 InstantiatedFrom = PrevRecord->getInstantiatedFromMemberClass();
Douglas Gregor06db9f52009-10-12 20:18:28 +00008306 MSInfo = PrevRecord->getMemberSpecializationInfo();
Douglas Gregor86d142a2009-10-08 07:24:58 +00008307 }
Richard Smith7d137e32012-03-23 03:33:32 +00008308 } else if (isa<EnumDecl>(Member)) {
8309 EnumDecl *PrevEnum;
8310 if (Previous.isSingleResult() &&
8311 (PrevEnum = dyn_cast<EnumDecl>(Previous.getFoundDecl()))) {
Richard Smith22e7cc62016-05-24 00:01:49 +00008312 FoundInstantiation = Previous.getRepresentativeDecl();
Richard Smith7d137e32012-03-23 03:33:32 +00008313 Instantiation = PrevEnum;
8314 InstantiatedFrom = PrevEnum->getInstantiatedFromMemberEnum();
8315 MSInfo = PrevEnum->getMemberSpecializationInfo();
8316 }
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008317 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008318
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008319 if (!Instantiation) {
Douglas Gregor86d142a2009-10-08 07:24:58 +00008320 // There is no previous declaration that matches. Since member
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008321 // specializations are always out-of-line, the caller will complain about
8322 // this mismatch later.
8323 return false;
8324 }
John McCalle820e5e2010-04-13 20:37:33 +00008325
Richard Smith77e9e842017-05-09 23:02:10 +00008326 // A member specialization in a friend declaration isn't really declaring
8327 // an explicit specialization, just identifying a specific (possibly implicit)
8328 // specialization. Don't change the template specialization kind.
8329 //
8330 // FIXME: Is this really valid? Other compilers reject.
John McCalle820e5e2010-04-13 20:37:33 +00008331 if (Member->getFriendObjectKind() != Decl::FOK_None) {
8332 // Preserve instantiation information.
8333 if (InstantiatedFrom && isa<CXXMethodDecl>(Member)) {
8334 cast<CXXMethodDecl>(Member)->setInstantiationOfMemberFunction(
8335 cast<CXXMethodDecl>(InstantiatedFrom),
8336 cast<CXXMethodDecl>(Instantiation)->getTemplateSpecializationKind());
8337 } else if (InstantiatedFrom && isa<CXXRecordDecl>(Member)) {
8338 cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
8339 cast<CXXRecordDecl>(InstantiatedFrom),
8340 cast<CXXRecordDecl>(Instantiation)->getTemplateSpecializationKind());
8341 }
8342
8343 Previous.clear();
Richard Smith22e7cc62016-05-24 00:01:49 +00008344 Previous.addDecl(FoundInstantiation);
John McCalle820e5e2010-04-13 20:37:33 +00008345 return false;
8346 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008347
Douglas Gregor86d142a2009-10-08 07:24:58 +00008348 // Make sure that this is a specialization of a member.
8349 if (!InstantiatedFrom) {
8350 Diag(Member->getLocation(), diag::err_spec_member_not_instantiated)
8351 << Member;
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008352 Diag(Instantiation->getLocation(), diag::note_specialized_decl);
8353 return true;
8354 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008355
Douglas Gregor06db9f52009-10-12 20:18:28 +00008356 // C++ [temp.expl.spec]p6:
8357 // If a template, a member template or the member of a class template is
Nico Weberd3bdadf2011-12-23 20:58:04 +00008358 // explicitly specialized then that specialization shall be declared
Douglas Gregor06db9f52009-10-12 20:18:28 +00008359 // before the first use of that specialization that would cause an implicit
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008360 // instantiation to take place, in every translation unit in which such a
Douglas Gregor06db9f52009-10-12 20:18:28 +00008361 // use occurs; no diagnostic is required.
8362 assert(MSInfo && "Member specialization info missing?");
John McCall4f7ced62010-02-11 01:33:53 +00008363
Abramo Bagnara8075c852010-06-12 07:44:57 +00008364 bool HasNoEffect = false;
John McCall4f7ced62010-02-11 01:33:53 +00008365 if (CheckSpecializationInstantiationRedecl(Member->getLocation(),
8366 TSK_ExplicitSpecialization,
8367 Instantiation,
8368 MSInfo->getTemplateSpecializationKind(),
8369 MSInfo->getPointOfInstantiation(),
Abramo Bagnara8075c852010-06-12 07:44:57 +00008370 HasNoEffect))
Douglas Gregor06db9f52009-10-12 20:18:28 +00008371 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008372
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008373 // Check the scope of this explicit specialization.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008374 if (CheckTemplateSpecializationScope(*this,
Douglas Gregor86d142a2009-10-08 07:24:58 +00008375 InstantiatedFrom,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008376 Instantiation, Member->getLocation(),
Douglas Gregorba8e1ac2009-10-14 23:50:59 +00008377 false))
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008378 return true;
Douglas Gregord801b062009-10-07 23:56:10 +00008379
Richard Smith77e9e842017-05-09 23:02:10 +00008380 // Note that this member specialization is an "instantiation of" the
8381 // corresponding member of the original template.
8382 if (auto *MemberFunction = dyn_cast<FunctionDecl>(Member)) {
Douglas Gregorbbe8f462009-10-08 15:14:33 +00008383 FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
8384 if (InstantiationFunction->getTemplateSpecializationKind() ==
8385 TSK_ImplicitInstantiation) {
Faisal Vali5e9e8ac2016-04-17 17:32:04 +00008386 // Explicit specializations of member functions of class templates do not
8387 // inherit '=delete' from the member function they are specializing.
8388 if (InstantiationFunction->isDeleted()) {
Richard Smith77e9e842017-05-09 23:02:10 +00008389 // FIXME: This assert will not hold in the presence of modules.
Faisal Vali5e9e8ac2016-04-17 17:32:04 +00008390 assert(InstantiationFunction->getCanonicalDecl() ==
8391 InstantiationFunction);
Richard Smith77e9e842017-05-09 23:02:10 +00008392 // FIXME: We need an update record for this AST mutation.
Richard Smith5f274382016-09-28 23:55:27 +00008393 InstantiationFunction->setDeletedAsWritten(false);
Faisal Vali5e9e8ac2016-04-17 17:32:04 +00008394 }
Douglas Gregorbbe8f462009-10-08 15:14:33 +00008395 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008396
Richard Smith77e9e842017-05-09 23:02:10 +00008397 MemberFunction->setInstantiationOfMemberFunction(
8398 cast<CXXMethodDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
8399 } else if (auto *MemberVar = dyn_cast<VarDecl>(Member)) {
8400 MemberVar->setInstantiationOfStaticDataMember(
Larisse Voufo39a1e502013-08-06 01:03:05 +00008401 cast<VarDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
Richard Smith77e9e842017-05-09 23:02:10 +00008402 } else if (auto *MemberClass = dyn_cast<CXXRecordDecl>(Member)) {
8403 MemberClass->setInstantiationOfMemberClass(
8404 cast<CXXRecordDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
8405 } else if (auto *MemberEnum = dyn_cast<EnumDecl>(Member)) {
8406 MemberEnum->setInstantiationOfMemberEnum(
Richard Smith7d137e32012-03-23 03:33:32 +00008407 cast<EnumDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
Richard Smith77e9e842017-05-09 23:02:10 +00008408 } else {
8409 llvm_unreachable("unknown member specialization kind");
Douglas Gregor86d142a2009-10-08 07:24:58 +00008410 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008411
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008412 // Save the caller the trouble of having to figure out which declaration
8413 // this specialization matches.
John McCall1f82f242009-11-18 22:49:29 +00008414 Previous.clear();
Richard Smith22e7cc62016-05-24 00:01:49 +00008415 Previous.addDecl(FoundInstantiation);
Douglas Gregor5c0405d2009-10-07 22:35:40 +00008416 return false;
8417}
8418
Richard Smith77e9e842017-05-09 23:02:10 +00008419/// Complete the explicit specialization of a member of a class template by
8420/// updating the instantiated member to be marked as an explicit specialization.
8421///
8422/// \param OrigD The member declaration instantiated from the template.
8423/// \param Loc The location of the explicit specialization of the member.
8424template<typename DeclT>
8425static void completeMemberSpecializationImpl(Sema &S, DeclT *OrigD,
8426 SourceLocation Loc) {
8427 if (OrigD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
8428 return;
8429
8430 // FIXME: Inform AST mutation listeners of this AST mutation.
8431 // FIXME: If there are multiple in-class declarations of the member (from
8432 // multiple modules, or a declaration and later definition of a member type),
8433 // should we update all of them?
8434 OrigD->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
8435 OrigD->setLocation(Loc);
8436}
8437
8438void Sema::CompleteMemberSpecialization(NamedDecl *Member,
8439 LookupResult &Previous) {
8440 NamedDecl *Instantiation = cast<NamedDecl>(Member->getCanonicalDecl());
8441 if (Instantiation == Member)
8442 return;
8443
8444 if (auto *Function = dyn_cast<CXXMethodDecl>(Instantiation))
8445 completeMemberSpecializationImpl(*this, Function, Member->getLocation());
8446 else if (auto *Var = dyn_cast<VarDecl>(Instantiation))
8447 completeMemberSpecializationImpl(*this, Var, Member->getLocation());
8448 else if (auto *Record = dyn_cast<CXXRecordDecl>(Instantiation))
8449 completeMemberSpecializationImpl(*this, Record, Member->getLocation());
8450 else if (auto *Enum = dyn_cast<EnumDecl>(Instantiation))
8451 completeMemberSpecializationImpl(*this, Enum, Member->getLocation());
8452 else
8453 llvm_unreachable("unknown member specialization kind");
8454}
8455
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00008456/// Check the scope of an explicit instantiation.
Douglas Gregor6cc1df52010-07-13 00:10:04 +00008457///
8458/// \returns true if a serious error occurs, false otherwise.
8459static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D,
Douglas Gregore47f5a72009-10-14 23:41:34 +00008460 SourceLocation InstLoc,
8461 bool WasQualifiedName) {
Sebastian Redl50c68252010-08-31 00:36:30 +00008462 DeclContext *OrigContext= D->getDeclContext()->getEnclosingNamespaceContext();
8463 DeclContext *CurContext = S.CurContext->getRedeclContext();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008464
Douglas Gregor6cc1df52010-07-13 00:10:04 +00008465 if (CurContext->isRecord()) {
8466 S.Diag(InstLoc, diag::err_explicit_instantiation_in_class)
8467 << D;
8468 return true;
8469 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008470
Richard Smith050d2612011-10-18 02:28:33 +00008471 // C++11 [temp.explicit]p3:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008472 // An explicit instantiation shall appear in an enclosing namespace of its
Richard Smith050d2612011-10-18 02:28:33 +00008473 // template. If the name declared in the explicit instantiation is an
8474 // unqualified name, the explicit instantiation shall appear in the
8475 // namespace where its template is declared or, if that namespace is inline
8476 // (7.3.1), any namespace from its enclosing namespace set.
Douglas Gregore47f5a72009-10-14 23:41:34 +00008477 //
8478 // This is DR275, which we do not retroactively apply to C++98/03.
Richard Smith050d2612011-10-18 02:28:33 +00008479 if (WasQualifiedName) {
8480 if (CurContext->Encloses(OrigContext))
8481 return false;
8482 } else {
8483 if (CurContext->InEnclosingNamespaceSetOf(OrigContext))
8484 return false;
8485 }
8486
8487 if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
8488 if (WasQualifiedName)
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008489 S.Diag(InstLoc,
Richard Smith2bf7fdb2013-01-02 11:42:31 +00008490 S.getLangOpts().CPlusPlus11?
Richard Smith050d2612011-10-18 02:28:33 +00008491 diag::err_explicit_instantiation_out_of_scope :
8492 diag::warn_explicit_instantiation_out_of_scope_0x)
Douglas Gregore47f5a72009-10-14 23:41:34 +00008493 << D << NS;
8494 else
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008495 S.Diag(InstLoc,
Richard Smith2bf7fdb2013-01-02 11:42:31 +00008496 S.getLangOpts().CPlusPlus11?
Richard Smith050d2612011-10-18 02:28:33 +00008497 diag::err_explicit_instantiation_unqualified_wrong_namespace :
8498 diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
8499 << D << NS;
8500 } else
8501 S.Diag(InstLoc,
Richard Smith2bf7fdb2013-01-02 11:42:31 +00008502 S.getLangOpts().CPlusPlus11?
Richard Smith050d2612011-10-18 02:28:33 +00008503 diag::err_explicit_instantiation_must_be_global :
8504 diag::warn_explicit_instantiation_must_be_global_0x)
8505 << D;
Douglas Gregore47f5a72009-10-14 23:41:34 +00008506 S.Diag(D->getLocation(), diag::note_explicit_instantiation_here);
Douglas Gregor6cc1df52010-07-13 00:10:04 +00008507 return false;
Douglas Gregore47f5a72009-10-14 23:41:34 +00008508}
8509
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00008510/// Determine whether the given scope specifier has a template-id in it.
Douglas Gregore47f5a72009-10-14 23:41:34 +00008511static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS) {
8512 if (!SS.isSet())
8513 return false;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008514
Richard Smith050d2612011-10-18 02:28:33 +00008515 // C++11 [temp.explicit]p3:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008516 // If the explicit instantiation is for a member function, a member class
Douglas Gregore47f5a72009-10-14 23:41:34 +00008517 // or a static data member of a class template specialization, the name of
8518 // the class template specialization in the qualified-id for the member
8519 // name shall be a simple-template-id.
8520 //
8521 // C++98 has the same restriction, just worded differently.
Aaron Ballman4a979672014-01-03 13:56:08 +00008522 for (NestedNameSpecifier *NNS = SS.getScopeRep(); NNS;
8523 NNS = NNS->getPrefix())
John McCall424cec92011-01-19 06:33:43 +00008524 if (const Type *T = NNS->getAsType())
Douglas Gregore47f5a72009-10-14 23:41:34 +00008525 if (isa<TemplateSpecializationType>(T))
8526 return true;
8527
8528 return false;
8529}
8530
Shoaib Meenaifc78d7c2016-12-05 18:01:35 +00008531/// Make a dllexport or dllimport attr on a class template specialization take
8532/// effect.
8533static void dllExportImportClassTemplateSpecialization(
8534 Sema &S, ClassTemplateSpecializationDecl *Def) {
8535 auto *A = cast_or_null<InheritableAttr>(getDLLAttr(Def));
8536 assert(A && "dllExportImportClassTemplateSpecialization called "
8537 "on Def without dllexport or dllimport");
8538
8539 // We reject explicit instantiations in class scope, so there should
8540 // never be any delayed exported classes to worry about.
8541 assert(S.DelayedDllExportClasses.empty() &&
8542 "delayed exports present at explicit instantiation");
8543 S.checkClassLevelDLLAttribute(Def);
8544
8545 // Propagate attribute to base class templates.
8546 for (auto &B : Def->bases()) {
8547 if (auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
8548 B.getType()->getAsCXXRecordDecl()))
8549 S.propagateDLLAttrToBaseClassTemplate(Def, A, BT, B.getLocStart());
8550 }
8551
8552 S.referenceDLLExportedClassMethods();
8553}
8554
Douglas Gregor2ec748c2009-05-14 00:28:11 +00008555// Explicit instantiation of a class template specialization
Erich Keanec480f302018-07-12 21:09:05 +00008556DeclResult Sema::ActOnExplicitInstantiation(
8557 Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc,
8558 unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS,
8559 TemplateTy TemplateD, SourceLocation TemplateNameLoc,
8560 SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn,
8561 SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {
Douglas Gregora1f49972009-05-13 00:25:59 +00008562 // Find the class template we're specializing
Serge Pavlov9ddb76e2013-08-27 13:15:56 +00008563 TemplateName Name = TemplateD.get();
Richard Smith392497b2013-06-22 22:03:31 +00008564 TemplateDecl *TD = Name.getAsTemplateDecl();
Douglas Gregora1f49972009-05-13 00:25:59 +00008565 // Check that the specialization uses the same tag kind as the
8566 // original template.
Abramo Bagnara6150c882010-05-11 21:36:43 +00008567 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
8568 assert(Kind != TTK_Enum &&
8569 "Invalid enum tag in class template explicit instantiation!");
Richard Smith392497b2013-06-22 22:03:31 +00008570
Richard Trieu265c3442016-04-05 21:13:54 +00008571 ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(TD);
8572
8573 if (!ClassTemplate) {
Reid Kleckner1a4ab7e2016-12-09 19:47:58 +00008574 NonTagKind NTK = getNonTagTypeDeclKind(TD, Kind);
8575 Diag(TemplateNameLoc, diag::err_tag_reference_non_tag) << TD << NTK << Kind;
Richard Trieu265c3442016-04-05 21:13:54 +00008576 Diag(TD->getLocation(), diag::note_previous_use);
Richard Smith392497b2013-06-22 22:03:31 +00008577 return true;
8578 }
8579
Douglas Gregord9034f02009-05-14 16:41:31 +00008580 if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
Richard Trieucaa33d32011-06-10 03:11:26 +00008581 Kind, /*isDefinition*/false, KWLoc,
Justin Bognerc6ecb7c2015-07-10 23:05:47 +00008582 ClassTemplate->getIdentifier())) {
Mike Stump11289f42009-09-09 15:08:12 +00008583 Diag(KWLoc, diag::err_use_with_wrong_tag)
Douglas Gregora1f49972009-05-13 00:25:59 +00008584 << ClassTemplate
Douglas Gregora771f462010-03-31 17:46:05 +00008585 << FixItHint::CreateReplacement(KWLoc,
Douglas Gregora1f49972009-05-13 00:25:59 +00008586 ClassTemplate->getTemplatedDecl()->getKindName());
Mike Stump11289f42009-09-09 15:08:12 +00008587 Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
Douglas Gregora1f49972009-05-13 00:25:59 +00008588 diag::note_previous_use);
8589 Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
8590 }
8591
Douglas Gregore47f5a72009-10-14 23:41:34 +00008592 // C++0x [temp.explicit]p2:
8593 // There are two forms of explicit instantiation: an explicit instantiation
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008594 // definition and an explicit instantiation declaration. An explicit
8595 // instantiation declaration begins with the extern keyword. [...]
Hans Wennborgfd76d912015-01-15 21:18:30 +00008596 TemplateSpecializationKind TSK = ExternLoc.isInvalid()
8597 ? TSK_ExplicitInstantiationDefinition
8598 : TSK_ExplicitInstantiationDeclaration;
8599
8600 if (TSK == TSK_ExplicitInstantiationDeclaration) {
8601 // Check for dllexport class template instantiation declarations.
Erich Keanec480f302018-07-12 21:09:05 +00008602 for (const AttributeList &AL : Attr) {
8603 if (AL.getKind() == AttributeList::AT_DLLExport) {
Hans Wennborgfd76d912015-01-15 21:18:30 +00008604 Diag(ExternLoc,
8605 diag::warn_attribute_dllexport_explicit_instantiation_decl);
Erich Keanec480f302018-07-12 21:09:05 +00008606 Diag(AL.getLoc(), diag::note_attribute);
Hans Wennborgfd76d912015-01-15 21:18:30 +00008607 break;
8608 }
8609 }
8610
8611 if (auto *A = ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
8612 Diag(ExternLoc,
8613 diag::warn_attribute_dllexport_explicit_instantiation_decl);
8614 Diag(A->getLocation(), diag::note_attribute);
8615 }
8616 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008617
Hans Wennborga86a83b2016-05-26 19:42:56 +00008618 // In MSVC mode, dllimported explicit instantiation definitions are treated as
8619 // instantiation declarations for most purposes.
8620 bool DLLImportExplicitInstantiationDef = false;
8621 if (TSK == TSK_ExplicitInstantiationDefinition &&
8622 Context.getTargetInfo().getCXXABI().isMicrosoft()) {
8623 // Check for dllimport class template instantiation definitions.
8624 bool DLLImport =
8625 ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
Erich Keanec480f302018-07-12 21:09:05 +00008626 for (const AttributeList &AL : Attr) {
8627 if (AL.getKind() == AttributeList::AT_DLLImport)
Hans Wennborga86a83b2016-05-26 19:42:56 +00008628 DLLImport = true;
Erich Keanec480f302018-07-12 21:09:05 +00008629 if (AL.getKind() == AttributeList::AT_DLLExport) {
Hans Wennborga86a83b2016-05-26 19:42:56 +00008630 // dllexport trumps dllimport here.
8631 DLLImport = false;
8632 break;
8633 }
8634 }
8635 if (DLLImport) {
8636 TSK = TSK_ExplicitInstantiationDeclaration;
8637 DLLImportExplicitInstantiationDef = true;
8638 }
8639 }
8640
Douglas Gregora1f49972009-05-13 00:25:59 +00008641 // Translate the parser's template argument list in our AST format.
John McCall6b51f282009-11-23 01:53:49 +00008642 TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
Douglas Gregorb53edfb2009-11-10 19:49:08 +00008643 translateTemplateArguments(TemplateArgsIn, TemplateArgs);
Douglas Gregora1f49972009-05-13 00:25:59 +00008644
8645 // Check that the template argument list is well-formed for this
8646 // template.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00008647 SmallVector<TemplateArgument, 4> Converted;
John McCall6b51f282009-11-23 01:53:49 +00008648 if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
8649 TemplateArgs, false, Converted))
Douglas Gregora1f49972009-05-13 00:25:59 +00008650 return true;
8651
Douglas Gregora1f49972009-05-13 00:25:59 +00008652 // Find the class template specialization declaration that
8653 // corresponds to these arguments.
Craig Topperc3ec1492014-05-26 06:22:03 +00008654 void *InsertPos = nullptr;
Douglas Gregora1f49972009-05-13 00:25:59 +00008655 ClassTemplateSpecializationDecl *PrevDecl
Craig Topper7e0daca2014-06-26 04:58:53 +00008656 = ClassTemplate->findSpecialization(Converted, InsertPos);
Douglas Gregora1f49972009-05-13 00:25:59 +00008657
Abramo Bagnara8075c852010-06-12 07:44:57 +00008658 TemplateSpecializationKind PrevDecl_TSK
8659 = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared;
8660
Douglas Gregor54888652009-10-07 00:13:32 +00008661 // C++0x [temp.explicit]p2:
8662 // [...] An explicit instantiation shall appear in an enclosing
8663 // namespace of its template. [...]
8664 //
8665 // This is C++ DR 275.
Douglas Gregor6cc1df52010-07-13 00:10:04 +00008666 if (CheckExplicitInstantiationScope(*this, ClassTemplate, TemplateNameLoc,
8667 SS.isSet()))
8668 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008669
Craig Topperc3ec1492014-05-26 06:22:03 +00008670 ClassTemplateSpecializationDecl *Specialization = nullptr;
Douglas Gregora1f49972009-05-13 00:25:59 +00008671
Abramo Bagnara8075c852010-06-12 07:44:57 +00008672 bool HasNoEffect = false;
Douglas Gregora1f49972009-05-13 00:25:59 +00008673 if (PrevDecl) {
Douglas Gregor1d957a32009-10-27 18:42:08 +00008674 if (CheckSpecializationInstantiationRedecl(TemplateNameLoc, TSK,
Abramo Bagnara8075c852010-06-12 07:44:57 +00008675 PrevDecl, PrevDecl_TSK,
Douglas Gregor12e49d32009-10-15 22:53:21 +00008676 PrevDecl->getPointOfInstantiation(),
Abramo Bagnara8075c852010-06-12 07:44:57 +00008677 HasNoEffect))
John McCall48871652010-08-21 09:40:31 +00008678 return PrevDecl;
Douglas Gregora1f49972009-05-13 00:25:59 +00008679
Abramo Bagnara8075c852010-06-12 07:44:57 +00008680 // Even though HasNoEffect == true means that this explicit instantiation
8681 // has no effect on semantics, we go on to put its syntax in the AST.
8682
8683 if (PrevDecl_TSK == TSK_ImplicitInstantiation ||
8684 PrevDecl_TSK == TSK_Undeclared) {
Douglas Gregor4aa04b12009-09-11 21:19:12 +00008685 // Since the only prior class template specialization with these
8686 // arguments was referenced but not declared, reuse that
Abramo Bagnara8075c852010-06-12 07:44:57 +00008687 // declaration node as our own, updating the source location
8688 // for the template name to reflect our new declaration.
8689 // (Other source locations will be updated later.)
Douglas Gregor4aa04b12009-09-11 21:19:12 +00008690 Specialization = PrevDecl;
8691 Specialization->setLocation(TemplateNameLoc);
Craig Topperc3ec1492014-05-26 06:22:03 +00008692 PrevDecl = nullptr;
Douglas Gregor4aa04b12009-09-11 21:19:12 +00008693 }
Hans Wennborga86a83b2016-05-26 19:42:56 +00008694
8695 if (PrevDecl_TSK == TSK_ExplicitInstantiationDeclaration &&
8696 DLLImportExplicitInstantiationDef) {
8697 // The new specialization might add a dllimport attribute.
8698 HasNoEffect = false;
8699 }
Douglas Gregor12e49d32009-10-15 22:53:21 +00008700 }
Abramo Bagnara8075c852010-06-12 07:44:57 +00008701
Douglas Gregor4aa04b12009-09-11 21:19:12 +00008702 if (!Specialization) {
Douglas Gregora1f49972009-05-13 00:25:59 +00008703 // Create a new class template specialization declaration node for
8704 // this explicit specialization.
8705 Specialization
Douglas Gregore9029562010-05-06 00:28:52 +00008706 = ClassTemplateSpecializationDecl::Create(Context, Kind,
Douglas Gregora1f49972009-05-13 00:25:59 +00008707 ClassTemplate->getDeclContext(),
Abramo Bagnara29c2d462011-03-09 14:09:51 +00008708 KWLoc, TemplateNameLoc,
Douglas Gregora1f49972009-05-13 00:25:59 +00008709 ClassTemplate,
David Majnemer8b622692016-07-03 21:17:51 +00008710 Converted,
Douglas Gregor1ccc8412010-11-07 23:05:16 +00008711 PrevDecl);
John McCall3e11ebe2010-03-15 10:12:16 +00008712 SetNestedNameSpecifier(Specialization, SS);
Douglas Gregora1f49972009-05-13 00:25:59 +00008713
Argyrios Kyrtzidis47470f22010-07-20 13:59:28 +00008714 if (!HasNoEffect && !PrevDecl) {
Abramo Bagnara8075c852010-06-12 07:44:57 +00008715 // Insert the new specialization.
Argyrios Kyrtzidis47470f22010-07-20 13:59:28 +00008716 ClassTemplate->AddSpecialization(Specialization, InsertPos);
Abramo Bagnara8075c852010-06-12 07:44:57 +00008717 }
Douglas Gregora1f49972009-05-13 00:25:59 +00008718 }
8719
8720 // Build the fully-sugared type for this explicit instantiation as
8721 // the user wrote in the explicit instantiation itself. This means
8722 // that we'll pretty-print the type retrieved from the
8723 // specialization's declaration the way that the user actually wrote
8724 // the explicit instantiation, rather than formatting the name based
8725 // on the "canonical" representation used to store the template
8726 // arguments in the specialization.
John McCalle78aac42010-03-10 03:28:59 +00008727 TypeSourceInfo *WrittenTy
8728 = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
8729 TemplateArgs,
Douglas Gregora1f49972009-05-13 00:25:59 +00008730 Context.getTypeDeclType(Specialization));
8731 Specialization->setTypeAsWritten(WrittenTy);
Douglas Gregora1f49972009-05-13 00:25:59 +00008732
Abramo Bagnara8075c852010-06-12 07:44:57 +00008733 // Set source locations for keywords.
8734 Specialization->setExternLoc(ExternLoc);
8735 Specialization->setTemplateKeywordLoc(TemplateLoc);
Argyrios Kyrtzidisd798c052016-07-15 18:11:33 +00008736 Specialization->setBraceRange(SourceRange());
Abramo Bagnara8075c852010-06-12 07:44:57 +00008737
Shoaib Meenai5adfb5a2017-01-13 01:28:34 +00008738 bool PreviouslyDLLExported = Specialization->hasAttr<DLLExportAttr>();
Erich Keanec480f302018-07-12 21:09:05 +00008739 ProcessDeclAttributeList(S, Specialization, Attr);
Rafael Espindola0b062072012-01-03 06:04:21 +00008740
Abramo Bagnara8075c852010-06-12 07:44:57 +00008741 // Add the explicit instantiation into its lexical context. However,
8742 // since explicit instantiations are never found by name lookup, we
8743 // just put it into the declaration context directly.
8744 Specialization->setLexicalDeclContext(CurContext);
8745 CurContext->addDecl(Specialization);
8746
8747 // Syntax is now OK, so return if it has no other effect on semantics.
8748 if (HasNoEffect) {
8749 // Set the template specialization kind.
8750 Specialization->setTemplateSpecializationKind(TSK);
John McCall48871652010-08-21 09:40:31 +00008751 return Specialization;
Douglas Gregor0681a352009-11-25 06:01:46 +00008752 }
Douglas Gregora1f49972009-05-13 00:25:59 +00008753
8754 // C++ [temp.explicit]p3:
Douglas Gregora1f49972009-05-13 00:25:59 +00008755 // A definition of a class template or class member template
8756 // shall be in scope at the point of the explicit instantiation of
8757 // the class template or class member template.
8758 //
8759 // This check comes when we actually try to perform the
8760 // instantiation.
Douglas Gregor12e49d32009-10-15 22:53:21 +00008761 ClassTemplateSpecializationDecl *Def
8762 = cast_or_null<ClassTemplateSpecializationDecl>(
Douglas Gregor0a5a2212010-02-11 01:04:33 +00008763 Specialization->getDefinition());
Douglas Gregor12e49d32009-10-15 22:53:21 +00008764 if (!Def)
Douglas Gregoref6ab412009-10-27 06:26:26 +00008765 InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK);
Abramo Bagnara8075c852010-06-12 07:44:57 +00008766 else if (TSK == TSK_ExplicitInstantiationDefinition) {
Douglas Gregor88d292c2010-05-13 16:44:06 +00008767 MarkVTableUsed(TemplateNameLoc, Specialization, true);
Abramo Bagnara8075c852010-06-12 07:44:57 +00008768 Specialization->setPointOfInstantiation(Def->getPointOfInstantiation());
8769 }
Douglas Gregor88d292c2010-05-13 16:44:06 +00008770
Douglas Gregor1d957a32009-10-27 18:42:08 +00008771 // Instantiate the members of this class template specialization.
8772 Def = cast_or_null<ClassTemplateSpecializationDecl>(
Douglas Gregor0a5a2212010-02-11 01:04:33 +00008773 Specialization->getDefinition());
Rafael Espindola8d04f062010-03-22 23:12:48 +00008774 if (Def) {
Rafael Espindolafa1708fd2010-03-23 19:55:22 +00008775 TemplateSpecializationKind Old_TSK = Def->getTemplateSpecializationKind();
Rafael Espindolafa1708fd2010-03-23 19:55:22 +00008776 // Fix a TSK_ExplicitInstantiationDeclaration followed by a
8777 // TSK_ExplicitInstantiationDefinition
8778 if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
Hans Wennborga86a83b2016-05-26 19:42:56 +00008779 (TSK == TSK_ExplicitInstantiationDefinition ||
8780 DLLImportExplicitInstantiationDef)) {
Richard Smitheb36ddf2014-04-24 22:45:46 +00008781 // FIXME: Need to notify the ASTMutationListener that we did this.
Rafael Espindolafa1708fd2010-03-23 19:55:22 +00008782 Def->setTemplateSpecializationKind(TSK);
Rafael Espindola8d04f062010-03-22 23:12:48 +00008783
Hans Wennborgc0875502015-06-09 00:39:05 +00008784 if (!getDLLAttr(Def) && getDLLAttr(Specialization) &&
Shoaib Meenaiab3f96c2016-11-09 23:52:20 +00008785 (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
8786 Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
Hans Wennborgc0875502015-06-09 00:39:05 +00008787 // In the MS ABI, an explicit instantiation definition can add a dll
8788 // attribute to a template with a previous instantiation declaration.
8789 // MinGW doesn't allow this.
Hans Wennborg17f9b442015-05-27 00:06:45 +00008790 auto *A = cast<InheritableAttr>(
8791 getDLLAttr(Specialization)->clone(getASTContext()));
8792 A->setInherited(true);
8793 Def->addAttr(A);
Shoaib Meenaifc78d7c2016-12-05 18:01:35 +00008794 dllExportImportClassTemplateSpecialization(*this, Def);
Hans Wennborg17f9b442015-05-27 00:06:45 +00008795 }
8796 }
8797
Shoaib Meenaifc78d7c2016-12-05 18:01:35 +00008798 // Fix a TSK_ImplicitInstantiation followed by a
8799 // TSK_ExplicitInstantiationDefinition
Shoaib Meenai5adfb5a2017-01-13 01:28:34 +00008800 bool NewlyDLLExported =
8801 !PreviouslyDLLExported && Specialization->hasAttr<DLLExportAttr>();
8802 if (Old_TSK == TSK_ImplicitInstantiation && NewlyDLLExported &&
Shoaib Meenaifc78d7c2016-12-05 18:01:35 +00008803 (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
8804 Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
8805 // In the MS ABI, an explicit instantiation definition can add a dll
8806 // attribute to a template with a previous implicit instantiation.
8807 // MinGW doesn't allow this. We limit clang to only adding dllexport, to
8808 // avoid potentially strange codegen behavior. For example, if we extend
8809 // this conditional to dllimport, and we have a source file calling a
8810 // method on an implicitly instantiated template class instance and then
8811 // declaring a dllimport explicit instantiation definition for the same
8812 // template class, the codegen for the method call will not respect the
8813 // dllimport, while it will with cl. The Def will already have the DLL
8814 // attribute, since the Def and Specialization will be the same in the
8815 // case of Old_TSK == TSK_ImplicitInstantiation, and we already added the
8816 // attribute to the Specialization; we just need to make it take effect.
8817 assert(Def == Specialization &&
8818 "Def and Specialization should match for implicit instantiation");
8819 dllExportImportClassTemplateSpecialization(*this, Def);
8820 }
8821
Argyrios Kyrtzidis322d8532015-09-11 01:44:56 +00008822 // Set the template specialization kind. Make sure it is set before
8823 // instantiating the members which will trigger ASTConsumer callbacks.
8824 Specialization->setTemplateSpecializationKind(TSK);
Douglas Gregor12e49d32009-10-15 22:53:21 +00008825 InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK);
Argyrios Kyrtzidis322d8532015-09-11 01:44:56 +00008826 } else {
8827
8828 // Set the template specialization kind.
8829 Specialization->setTemplateSpecializationKind(TSK);
Rafael Espindola8d04f062010-03-22 23:12:48 +00008830 }
Douglas Gregora1f49972009-05-13 00:25:59 +00008831
John McCall48871652010-08-21 09:40:31 +00008832 return Specialization;
Douglas Gregora1f49972009-05-13 00:25:59 +00008833}
8834
Douglas Gregor2ec748c2009-05-14 00:28:11 +00008835// Explicit instantiation of a member class of a class template.
John McCall48871652010-08-21 09:40:31 +00008836DeclResult
Erich Keanec480f302018-07-12 21:09:05 +00008837Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc,
8838 SourceLocation TemplateLoc, unsigned TagSpec,
8839 SourceLocation KWLoc, CXXScopeSpec &SS,
8840 IdentifierInfo *Name, SourceLocation NameLoc,
8841 const ParsedAttributesView &Attr) {
Douglas Gregor2ec748c2009-05-14 00:28:11 +00008842
Douglas Gregord6ab8742009-05-28 23:31:59 +00008843 bool Owned = false;
John McCall7f41d982009-09-11 04:59:25 +00008844 bool IsDependent = false;
John McCallfaf5fb42010-08-26 23:41:50 +00008845 Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference,
John McCall48871652010-08-21 09:40:31 +00008846 KWLoc, SS, Name, NameLoc, Attr, AS_none,
Douglas Gregor2820e692011-09-09 19:05:14 +00008847 /*ModulePrivateLoc=*/SourceLocation(),
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00008848 MultiTemplateParamsArg(), Owned, IsDependent,
Richard Smith649c7b062014-01-08 00:56:48 +00008849 SourceLocation(), false, TypeResult(),
Akira Hatanaka12ddcee2017-06-26 18:46:12 +00008850 /*IsTypeSpecifier*/false,
8851 /*IsTemplateParamOrArg*/false);
John McCall7f41d982009-09-11 04:59:25 +00008852 assert(!IsDependent && "explicit instantiation of dependent name not yet handled");
8853
Douglas Gregor2ec748c2009-05-14 00:28:11 +00008854 if (!TagD)
8855 return true;
8856
John McCall48871652010-08-21 09:40:31 +00008857 TagDecl *Tag = cast<TagDecl>(TagD);
Richard Smith7d137e32012-03-23 03:33:32 +00008858 assert(!Tag->isEnum() && "shouldn't see enumerations here");
Douglas Gregor2ec748c2009-05-14 00:28:11 +00008859
Douglas Gregorb8006faf2009-05-27 17:30:49 +00008860 if (Tag->isInvalidDecl())
8861 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008862
Douglas Gregor2ec748c2009-05-14 00:28:11 +00008863 CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag);
8864 CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
8865 if (!Pattern) {
8866 Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
8867 << Context.getTypeDeclType(Record);
8868 Diag(Record->getLocation(), diag::note_nontemplate_decl_here);
8869 return true;
8870 }
8871
Douglas Gregore47f5a72009-10-14 23:41:34 +00008872 // C++0x [temp.explicit]p2:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008873 // If the explicit instantiation is for a class or member class, the
8874 // elaborated-type-specifier in the declaration shall include a
Douglas Gregore47f5a72009-10-14 23:41:34 +00008875 // simple-template-id.
8876 //
8877 // C++98 has the same restriction, just worded differently.
8878 if (!ScopeSpecifierHasTemplateId(SS))
Douglas Gregor010815a2010-06-16 16:26:47 +00008879 Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
Douglas Gregore47f5a72009-10-14 23:41:34 +00008880 << Record << SS.getRange();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008881
Douglas Gregore47f5a72009-10-14 23:41:34 +00008882 // C++0x [temp.explicit]p2:
8883 // There are two forms of explicit instantiation: an explicit instantiation
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008884 // definition and an explicit instantiation declaration. An explicit
Douglas Gregore47f5a72009-10-14 23:41:34 +00008885 // instantiation declaration begins with the extern keyword. [...]
Douglas Gregor5d851972009-10-14 21:46:58 +00008886 TemplateSpecializationKind TSK
8887 = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
8888 : TSK_ExplicitInstantiationDeclaration;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008889
Douglas Gregor2ec748c2009-05-14 00:28:11 +00008890 // C++0x [temp.explicit]p2:
8891 // [...] An explicit instantiation shall appear in an enclosing
8892 // namespace of its template. [...]
8893 //
8894 // This is C++ DR 275.
Douglas Gregore47f5a72009-10-14 23:41:34 +00008895 CheckExplicitInstantiationScope(*this, Record, NameLoc, true);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008896
Douglas Gregord6ba93d2009-10-15 15:54:05 +00008897 // Verify that it is okay to explicitly instantiate here.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008898 CXXRecordDecl *PrevDecl
Douglas Gregorec9fd132012-01-14 16:38:05 +00008899 = cast_or_null<CXXRecordDecl>(Record->getPreviousDecl());
Douglas Gregor0a5a2212010-02-11 01:04:33 +00008900 if (!PrevDecl && Record->getDefinition())
Douglas Gregor8f003d02009-10-15 18:07:02 +00008901 PrevDecl = Record;
8902 if (PrevDecl) {
Douglas Gregord6ba93d2009-10-15 15:54:05 +00008903 MemberSpecializationInfo *MSInfo = PrevDecl->getMemberSpecializationInfo();
Abramo Bagnara8075c852010-06-12 07:44:57 +00008904 bool HasNoEffect = false;
Douglas Gregord6ba93d2009-10-15 15:54:05 +00008905 assert(MSInfo && "No member specialization information?");
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008906 if (CheckSpecializationInstantiationRedecl(TemplateLoc, TSK,
Douglas Gregord6ba93d2009-10-15 15:54:05 +00008907 PrevDecl,
8908 MSInfo->getTemplateSpecializationKind(),
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008909 MSInfo->getPointOfInstantiation(),
Abramo Bagnara8075c852010-06-12 07:44:57 +00008910 HasNoEffect))
Douglas Gregord6ba93d2009-10-15 15:54:05 +00008911 return true;
Abramo Bagnara8075c852010-06-12 07:44:57 +00008912 if (HasNoEffect)
Douglas Gregord6ba93d2009-10-15 15:54:05 +00008913 return TagD;
8914 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008915
Douglas Gregor12e49d32009-10-15 22:53:21 +00008916 CXXRecordDecl *RecordDef
Douglas Gregor0a5a2212010-02-11 01:04:33 +00008917 = cast_or_null<CXXRecordDecl>(Record->getDefinition());
Douglas Gregor12e49d32009-10-15 22:53:21 +00008918 if (!RecordDef) {
Douglas Gregor68edf132009-10-15 12:53:22 +00008919 // C++ [temp.explicit]p3:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008920 // A definition of a member class of a class template shall be in scope
Douglas Gregor68edf132009-10-15 12:53:22 +00008921 // at the point of an explicit instantiation of the member class.
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008922 CXXRecordDecl *Def
Douglas Gregor0a5a2212010-02-11 01:04:33 +00008923 = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
Douglas Gregor68edf132009-10-15 12:53:22 +00008924 if (!Def) {
Douglas Gregora8b89d22009-10-15 14:05:49 +00008925 Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
8926 << 0 << Record->getDeclName() << Record->getDeclContext();
Douglas Gregor68edf132009-10-15 12:53:22 +00008927 Diag(Pattern->getLocation(), diag::note_forward_declaration)
8928 << Pattern;
8929 return true;
Douglas Gregor1d957a32009-10-27 18:42:08 +00008930 } else {
8931 if (InstantiateClass(NameLoc, Record, Def,
8932 getTemplateInstantiationArgs(Record),
8933 TSK))
8934 return true;
8935
Douglas Gregor0a5a2212010-02-11 01:04:33 +00008936 RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition());
Douglas Gregor1d957a32009-10-27 18:42:08 +00008937 if (!RecordDef)
8938 return true;
8939 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008940 }
8941
Douglas Gregor1d957a32009-10-27 18:42:08 +00008942 // Instantiate all of the members of the class.
8943 InstantiateClassMembers(NameLoc, RecordDef,
8944 getTemplateInstantiationArgs(Record), TSK);
Douglas Gregor2ec748c2009-05-14 00:28:11 +00008945
Douglas Gregor88d292c2010-05-13 16:44:06 +00008946 if (TSK == TSK_ExplicitInstantiationDefinition)
8947 MarkVTableUsed(NameLoc, RecordDef, true);
8948
Mike Stump87c57ac2009-05-16 07:39:55 +00008949 // FIXME: We don't have any representation for explicit instantiations of
8950 // member classes. Such a representation is not needed for compilation, but it
8951 // should be available for clients that want to see all of the declarations in
8952 // the source code.
Douglas Gregor2ec748c2009-05-14 00:28:11 +00008953 return TagD;
8954}
8955
John McCallfaf5fb42010-08-26 23:41:50 +00008956DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
8957 SourceLocation ExternLoc,
8958 SourceLocation TemplateLoc,
8959 Declarator &D) {
Douglas Gregor450f00842009-09-25 18:43:00 +00008960 // Explicit instantiations always require a name.
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00008961 // TODO: check if/when DNInfo should replace Name.
8962 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
8963 DeclarationName Name = NameInfo.getName();
Douglas Gregor450f00842009-09-25 18:43:00 +00008964 if (!Name) {
8965 if (!D.isInvalidType())
Daniel Dunbar62ee6412012-03-09 18:35:03 +00008966 Diag(D.getDeclSpec().getLocStart(),
Douglas Gregor450f00842009-09-25 18:43:00 +00008967 diag::err_explicit_instantiation_requires_name)
8968 << D.getDeclSpec().getSourceRange()
8969 << D.getSourceRange();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008970
Douglas Gregor450f00842009-09-25 18:43:00 +00008971 return true;
8972 }
8973
8974 // The scope passed in may not be a decl scope. Zip up the scope tree until
8975 // we find one that is.
8976 while ((S->getFlags() & Scope::DeclScope) == 0 ||
8977 (S->getFlags() & Scope::TemplateParamScope) != 0)
8978 S = S->getParent();
8979
8980 // Determine the type of the declaration.
John McCall8cb7bdf2010-06-04 23:28:52 +00008981 TypeSourceInfo *T = GetTypeForDeclarator(D, S);
8982 QualType R = T->getType();
Douglas Gregor450f00842009-09-25 18:43:00 +00008983 if (R.isNull())
8984 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00008985
Douglas Gregor781ba6e2011-05-21 18:53:30 +00008986 // C++ [dcl.stc]p1:
Simon Pilgrim6905d222016-12-30 22:55:33 +00008987 // A storage-class-specifier shall not be specified in [...] an explicit
Douglas Gregor781ba6e2011-05-21 18:53:30 +00008988 // instantiation (14.7.2) directive.
Douglas Gregor450f00842009-09-25 18:43:00 +00008989 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
Douglas Gregor450f00842009-09-25 18:43:00 +00008990 Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)
8991 << Name;
8992 return true;
Simon Pilgrim6905d222016-12-30 22:55:33 +00008993 } else if (D.getDeclSpec().getStorageClassSpec()
Douglas Gregor781ba6e2011-05-21 18:53:30 +00008994 != DeclSpec::SCS_unspecified) {
8995 // Complain about then remove the storage class specifier.
8996 Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)
8997 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
Simon Pilgrim6905d222016-12-30 22:55:33 +00008998
Douglas Gregor781ba6e2011-05-21 18:53:30 +00008999 D.getMutableDeclSpec().ClearStorageClassSpecs();
Douglas Gregor450f00842009-09-25 18:43:00 +00009000 }
9001
Douglas Gregor3c74d412009-10-14 20:14:33 +00009002 // C++0x [temp.explicit]p1:
9003 // [...] An explicit instantiation of a function template shall not use the
9004 // inline or constexpr specifiers.
9005 // Presumably, this also applies to member functions of class templates as
9006 // well.
Richard Smith83c19292011-10-18 03:44:03 +00009007 if (D.getDeclSpec().isInlineSpecified())
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009008 Diag(D.getDeclSpec().getInlineSpecLoc(),
Richard Smith2bf7fdb2013-01-02 11:42:31 +00009009 getLangOpts().CPlusPlus11 ?
Richard Smith83c19292011-10-18 03:44:03 +00009010 diag::err_explicit_instantiation_inline :
9011 diag::warn_explicit_instantiation_inline_0x)
Richard Smith465841e2011-10-14 19:58:02 +00009012 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
Larisse Voufo39a1e502013-08-06 01:03:05 +00009013 if (D.getDeclSpec().isConstexprSpecified() && R->isFunctionType())
Richard Smith465841e2011-10-14 19:58:02 +00009014 // FIXME: Add a fix-it to remove the 'constexpr' and add a 'const' if one is
9015 // not already specified.
9016 Diag(D.getDeclSpec().getConstexprSpecLoc(),
9017 diag::err_explicit_instantiation_constexpr);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009018
Richard Smith19a311a2017-02-09 22:47:51 +00009019 // A deduction guide is not on the list of entities that can be explicitly
9020 // instantiated.
9021 if (Name.getNameKind() == DeclarationName::CXXDeductionGuideName) {
9022 Diag(D.getDeclSpec().getLocStart(), diag::err_deduction_guide_specialized)
9023 << /*explicit instantiation*/ 0;
9024 return true;
9025 }
9026
Douglas Gregore47f5a72009-10-14 23:41:34 +00009027 // C++0x [temp.explicit]p2:
9028 // There are two forms of explicit instantiation: an explicit instantiation
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009029 // definition and an explicit instantiation declaration. An explicit
9030 // instantiation declaration begins with the extern keyword. [...]
Douglas Gregor450f00842009-09-25 18:43:00 +00009031 TemplateSpecializationKind TSK
9032 = ExternLoc.isInvalid()? TSK_ExplicitInstantiationDefinition
9033 : TSK_ExplicitInstantiationDeclaration;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009034
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00009035 LookupResult Previous(*this, NameInfo, LookupOrdinaryName);
John McCall27b18f82009-11-17 02:14:36 +00009036 LookupParsedName(Previous, S, &D.getCXXScopeSpec());
Douglas Gregor450f00842009-09-25 18:43:00 +00009037
9038 if (!R->isFunctionType()) {
9039 // C++ [temp.explicit]p1:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009040 // A [...] static data member of a class template can be explicitly
9041 // instantiated from the member definition associated with its class
Douglas Gregor450f00842009-09-25 18:43:00 +00009042 // template.
Larisse Voufo39a1e502013-08-06 01:03:05 +00009043 // C++1y [temp.explicit]p1:
9044 // A [...] variable [...] template specialization can be explicitly
9045 // instantiated from its template.
John McCall27b18f82009-11-17 02:14:36 +00009046 if (Previous.isAmbiguous())
9047 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009048
John McCall67c00872009-12-02 08:25:40 +00009049 VarDecl *Prev = Previous.getAsSingle<VarDecl>();
Larisse Voufo39a1e502013-08-06 01:03:05 +00009050 VarTemplateDecl *PrevTemplate = Previous.getAsSingle<VarTemplateDecl>();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009051
Larisse Voufo39a1e502013-08-06 01:03:05 +00009052 if (!PrevTemplate) {
9053 if (!Prev || !Prev->isStaticDataMember()) {
9054 // We expect to see a data data member here.
9055 Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
9056 << Name;
9057 for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
9058 P != PEnd; ++P)
9059 Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
9060 return true;
9061 }
9062
9063 if (!Prev->getInstantiatedFromStaticDataMember()) {
9064 // FIXME: Check for explicit specialization?
9065 Diag(D.getIdentifierLoc(),
9066 diag::err_explicit_instantiation_data_member_not_instantiated)
9067 << Prev;
9068 Diag(Prev->getLocation(), diag::note_explicit_instantiation_here);
9069 // FIXME: Can we provide a note showing where this was declared?
9070 return true;
9071 }
9072 } else {
9073 // Explicitly instantiate a variable template.
9074
9075 // C++1y [dcl.spec.auto]p6:
9076 // ... A program that uses auto or decltype(auto) in a context not
9077 // explicitly allowed in this section is ill-formed.
9078 //
9079 // This includes auto-typed variable template instantiations.
9080 if (R->isUndeducedType()) {
9081 Diag(T->getTypeLoc().getLocStart(),
9082 diag::err_auto_not_allowed_var_inst);
9083 return true;
9084 }
9085
Faisal Vali2ab8c152017-12-30 04:15:27 +00009086 if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId) {
Richard Smithef985ac2013-09-18 02:10:12 +00009087 // C++1y [temp.explicit]p3:
9088 // If the explicit instantiation is for a variable, the unqualified-id
9089 // in the declaration shall be a template-id.
9090 Diag(D.getIdentifierLoc(),
9091 diag::err_explicit_instantiation_without_template_id)
9092 << PrevTemplate;
9093 Diag(PrevTemplate->getLocation(),
9094 diag::note_explicit_instantiation_here);
9095 return true;
Larisse Voufo39a1e502013-08-06 01:03:05 +00009096 }
9097
Richard Smithef985ac2013-09-18 02:10:12 +00009098 // Translate the parser's template argument list into our AST format.
Richard Smith4b55a9c2014-04-17 03:29:33 +00009099 TemplateArgumentListInfo TemplateArgs =
9100 makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);
Richard Smithef985ac2013-09-18 02:10:12 +00009101
Larisse Voufo39a1e502013-08-06 01:03:05 +00009102 DeclResult Res = CheckVarTemplateId(PrevTemplate, TemplateLoc,
9103 D.getIdentifierLoc(), TemplateArgs);
9104 if (Res.isInvalid())
9105 return true;
9106
9107 // Ignore access control bits, we don't need them for redeclaration
9108 // checking.
9109 Prev = cast<VarDecl>(Res.get());
Douglas Gregor450f00842009-09-25 18:43:00 +00009110 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009111
Douglas Gregore47f5a72009-10-14 23:41:34 +00009112 // C++0x [temp.explicit]p2:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009113 // If the explicit instantiation is for a member function, a member class
Douglas Gregore47f5a72009-10-14 23:41:34 +00009114 // or a static data member of a class template specialization, the name of
9115 // the class template specialization in the qualified-id for the member
9116 // name shall be a simple-template-id.
9117 //
9118 // C++98 has the same restriction, just worded differently.
Larisse Voufo39a1e502013-08-06 01:03:05 +00009119 //
Richard Smith5977d872013-09-18 21:55:14 +00009120 // This does not apply to variable template specializations, where the
9121 // template-id is in the unqualified-id instead.
9122 if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()) && !PrevTemplate)
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009123 Diag(D.getIdentifierLoc(),
Douglas Gregor010815a2010-06-16 16:26:47 +00009124 diag::ext_explicit_instantiation_without_qualified_id)
Douglas Gregore47f5a72009-10-14 23:41:34 +00009125 << Prev << D.getCXXScopeSpec().getRange();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009126
Douglas Gregore47f5a72009-10-14 23:41:34 +00009127 // Check the scope of this explicit instantiation.
9128 CheckExplicitInstantiationScope(*this, Prev, D.getIdentifierLoc(), true);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009129
Douglas Gregord6ba93d2009-10-15 15:54:05 +00009130 // Verify that it is okay to explicitly instantiate here.
Richard Smith8809a0c2013-09-27 20:14:12 +00009131 TemplateSpecializationKind PrevTSK = Prev->getTemplateSpecializationKind();
9132 SourceLocation POI = Prev->getPointOfInstantiation();
Abramo Bagnara8075c852010-06-12 07:44:57 +00009133 bool HasNoEffect = false;
Douglas Gregor1d957a32009-10-27 18:42:08 +00009134 if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
Larisse Voufo39a1e502013-08-06 01:03:05 +00009135 PrevTSK, POI, HasNoEffect))
Douglas Gregord6ba93d2009-10-15 15:54:05 +00009136 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009137
Larisse Voufo39a1e502013-08-06 01:03:05 +00009138 if (!HasNoEffect) {
9139 // Instantiate static data member or variable template.
Larisse Voufo39a1e502013-08-06 01:03:05 +00009140 Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
9141 if (PrevTemplate) {
9142 // Merge attributes.
Erich Keanec480f302018-07-12 21:09:05 +00009143 ProcessDeclAttributeList(S, Prev, D.getDeclSpec().getAttributes());
Larisse Voufo39a1e502013-08-06 01:03:05 +00009144 }
9145 if (TSK == TSK_ExplicitInstantiationDefinition)
9146 InstantiateVariableDefinition(D.getIdentifierLoc(), Prev);
9147 }
9148
9149 // Check the new variable specialization against the parsed input.
9150 if (PrevTemplate && Prev && !Context.hasSameType(Prev->getType(), R)) {
9151 Diag(T->getTypeLoc().getLocStart(),
9152 diag::err_invalid_var_template_spec_type)
9153 << 0 << PrevTemplate << R << Prev->getType();
9154 Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
9155 << 2 << PrevTemplate->getDeclName();
9156 return true;
9157 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009158
Douglas Gregor450f00842009-09-25 18:43:00 +00009159 // FIXME: Create an ExplicitInstantiation node?
Craig Topperc3ec1492014-05-26 06:22:03 +00009160 return (Decl*) nullptr;
Douglas Gregor450f00842009-09-25 18:43:00 +00009161 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009162
9163 // If the declarator is a template-id, translate the parser's template
Douglas Gregor0e876e02009-09-25 23:53:26 +00009164 // argument list into our AST format.
Douglas Gregord90fd522009-09-25 21:45:23 +00009165 bool HasExplicitTemplateArgs = false;
John McCall6b51f282009-11-23 01:53:49 +00009166 TemplateArgumentListInfo TemplateArgs;
Faisal Vali2ab8c152017-12-30 04:15:27 +00009167 if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {
Richard Smith4b55a9c2014-04-17 03:29:33 +00009168 TemplateArgs = makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);
Douglas Gregord90fd522009-09-25 21:45:23 +00009169 HasExplicitTemplateArgs = true;
9170 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009171
Douglas Gregor450f00842009-09-25 18:43:00 +00009172 // C++ [temp.explicit]p1:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009173 // A [...] function [...] can be explicitly instantiated from its template.
9174 // A member function [...] of a class template can be explicitly
9175 // instantiated from the member definition associated with its class
Douglas Gregor450f00842009-09-25 18:43:00 +00009176 // template.
John McCall27c11dd2017-06-07 23:00:05 +00009177 UnresolvedSet<8> TemplateMatches;
9178 FunctionDecl *NonTemplateMatch = nullptr;
Larisse Voufo98b20f12013-07-19 23:00:19 +00009179 TemplateSpecCandidateSet FailedCandidates(D.getIdentifierLoc());
Douglas Gregor450f00842009-09-25 18:43:00 +00009180 for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
9181 P != PEnd; ++P) {
9182 NamedDecl *Prev = *P;
Douglas Gregord90fd522009-09-25 21:45:23 +00009183 if (!HasExplicitTemplateArgs) {
9184 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
Richard Smithbaa47832016-12-01 02:11:49 +00009185 QualType Adjusted = adjustCCAndNoReturn(R, Method->getType(),
9186 /*AdjustExceptionSpec*/true);
Rafael Espindola6edca7d2013-12-01 16:54:29 +00009187 if (Context.hasSameUnqualifiedType(Method->getType(), Adjusted)) {
John McCall27c11dd2017-06-07 23:00:05 +00009188 if (Method->getPrimaryTemplate()) {
9189 TemplateMatches.addDecl(Method, P.getAccess());
9190 } else {
9191 // FIXME: Can this assert ever happen? Needs a test.
9192 assert(!NonTemplateMatch && "Multiple NonTemplateMatches");
9193 NonTemplateMatch = Method;
9194 }
Douglas Gregord90fd522009-09-25 21:45:23 +00009195 }
Douglas Gregor450f00842009-09-25 18:43:00 +00009196 }
9197 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009198
Douglas Gregor450f00842009-09-25 18:43:00 +00009199 FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Prev);
9200 if (!FunTmpl)
9201 continue;
9202
Larisse Voufo98b20f12013-07-19 23:00:19 +00009203 TemplateDeductionInfo Info(FailedCandidates.getLocation());
Craig Topperc3ec1492014-05-26 06:22:03 +00009204 FunctionDecl *Specialization = nullptr;
Douglas Gregor450f00842009-09-25 18:43:00 +00009205 if (TemplateDeductionResult TDK
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009206 = DeduceTemplateArguments(FunTmpl,
Craig Topperc3ec1492014-05-26 06:22:03 +00009207 (HasExplicitTemplateArgs ? &TemplateArgs
9208 : nullptr),
Douglas Gregor450f00842009-09-25 18:43:00 +00009209 R, Specialization, Info)) {
Larisse Voufo98b20f12013-07-19 23:00:19 +00009210 // Keep track of almost-matches.
9211 FailedCandidates.addCandidate()
Richard Smithc2bebe92016-05-11 20:37:46 +00009212 .set(P.getPair(), FunTmpl->getTemplatedDecl(),
Larisse Voufo98b20f12013-07-19 23:00:19 +00009213 MakeDeductionFailureInfo(Context, TDK, Info));
Douglas Gregor450f00842009-09-25 18:43:00 +00009214 (void)TDK;
9215 continue;
9216 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009217
Artem Belevich64135c32016-12-08 19:38:13 +00009218 // Target attributes are part of the cuda function signature, so
9219 // the cuda target of the instantiated function must match that of its
9220 // template. Given that C++ template deduction does not take
9221 // target attributes into account, we reject candidates here that
9222 // have a different target.
9223 if (LangOpts.CUDA &&
9224 IdentifyCUDATarget(Specialization,
9225 /* IgnoreImplicitHDAttributes = */ true) !=
Erich Keanec480f302018-07-12 21:09:05 +00009226 IdentifyCUDATarget(D.getDeclSpec().getAttributes())) {
Artem Belevich64135c32016-12-08 19:38:13 +00009227 FailedCandidates.addCandidate().set(
9228 P.getPair(), FunTmpl->getTemplatedDecl(),
9229 MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
9230 continue;
Artem Belevich13e9b4d2016-12-07 19:27:16 +00009231 }
9232
John McCall27c11dd2017-06-07 23:00:05 +00009233 TemplateMatches.addDecl(Specialization, P.getAccess());
Douglas Gregor450f00842009-09-25 18:43:00 +00009234 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009235
John McCall27c11dd2017-06-07 23:00:05 +00009236 FunctionDecl *Specialization = NonTemplateMatch;
9237 if (!Specialization) {
9238 // Find the most specialized function template specialization.
9239 UnresolvedSetIterator Result = getMostSpecialized(
9240 TemplateMatches.begin(), TemplateMatches.end(), FailedCandidates,
9241 D.getIdentifierLoc(),
9242 PDiag(diag::err_explicit_instantiation_not_known) << Name,
9243 PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
9244 PDiag(diag::note_explicit_instantiation_candidate));
Douglas Gregor450f00842009-09-25 18:43:00 +00009245
John McCall27c11dd2017-06-07 23:00:05 +00009246 if (Result == TemplateMatches.end())
9247 return true;
John McCall58cc69d2010-01-27 01:50:18 +00009248
John McCall27c11dd2017-06-07 23:00:05 +00009249 // Ignore access control bits, we don't need them for redeclaration checking.
9250 Specialization = cast<FunctionDecl>(*Result);
9251 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009252
Alexey Bataev73983912014-11-06 10:10:50 +00009253 // C++11 [except.spec]p4
9254 // In an explicit instantiation an exception-specification may be specified,
9255 // but is not required.
9256 // If an exception-specification is specified in an explicit instantiation
9257 // directive, it shall be compatible with the exception-specifications of
9258 // other declarations of that function.
9259 if (auto *FPT = R->getAs<FunctionProtoType>())
9260 if (FPT->hasExceptionSpec()) {
9261 unsigned DiagID =
9262 diag::err_mismatched_exception_spec_explicit_instantiation;
9263 if (getLangOpts().MicrosoftExt)
9264 DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
9265 bool Result = CheckEquivalentExceptionSpec(
9266 PDiag(DiagID) << Specialization->getType(),
9267 PDiag(diag::note_explicit_instantiation_here),
9268 Specialization->getType()->getAs<FunctionProtoType>(),
9269 Specialization->getLocation(), FPT, D.getLocStart());
9270 // In Microsoft mode, mismatching exception specifications just cause a
9271 // warning.
9272 if (!getLangOpts().MicrosoftExt && Result)
9273 return true;
9274 }
9275
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00009276 if (Specialization->getTemplateSpecializationKind() == TSK_Undeclared) {
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009277 Diag(D.getIdentifierLoc(),
Douglas Gregor450f00842009-09-25 18:43:00 +00009278 diag::err_explicit_instantiation_member_function_not_instantiated)
9279 << Specialization
9280 << (Specialization->getTemplateSpecializationKind() ==
9281 TSK_ExplicitSpecialization);
9282 Diag(Specialization->getLocation(), diag::note_explicit_instantiation_here);
9283 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009284 }
9285
Douglas Gregorec9fd132012-01-14 16:38:05 +00009286 FunctionDecl *PrevDecl = Specialization->getPreviousDecl();
Douglas Gregor8f003d02009-10-15 18:07:02 +00009287 if (!PrevDecl && Specialization->isThisDeclarationADefinition())
9288 PrevDecl = Specialization;
9289
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00009290 if (PrevDecl) {
Abramo Bagnara8075c852010-06-12 07:44:57 +00009291 bool HasNoEffect = false;
Douglas Gregor1d957a32009-10-27 18:42:08 +00009292 if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009293 PrevDecl,
9294 PrevDecl->getTemplateSpecializationKind(),
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00009295 PrevDecl->getPointOfInstantiation(),
Abramo Bagnara8075c852010-06-12 07:44:57 +00009296 HasNoEffect))
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00009297 return true;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009298
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00009299 // FIXME: We may still want to build some representation of this
9300 // explicit specialization.
Abramo Bagnara8075c852010-06-12 07:44:57 +00009301 if (HasNoEffect)
Craig Topperc3ec1492014-05-26 06:22:03 +00009302 return (Decl*) nullptr;
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00009303 }
Anders Carlsson65e6d132009-11-24 05:34:41 +00009304
Erich Keanec480f302018-07-12 21:09:05 +00009305 ProcessDeclAttributeList(S, Specialization, D.getDeclSpec().getAttributes());
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009306
Hans Wennborgb8304a62017-11-29 23:44:11 +00009307 // In MSVC mode, dllimported explicit instantiation definitions are treated as
9308 // instantiation declarations.
9309 if (TSK == TSK_ExplicitInstantiationDefinition &&
9310 Specialization->hasAttr<DLLImportAttr>() &&
9311 Context.getTargetInfo().getCXXABI().isMicrosoft())
9312 TSK = TSK_ExplicitInstantiationDeclaration;
9313
9314 Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
9315
Richard Smitheb36ddf2014-04-24 22:45:46 +00009316 if (Specialization->isDefined()) {
9317 // Let the ASTConsumer know that this function has been explicitly
9318 // instantiated now, and its linkage might have changed.
9319 Consumer.HandleTopLevelDecl(DeclGroupRef(Specialization));
9320 } else if (TSK == TSK_ExplicitInstantiationDefinition)
Chandler Carruthcfe41db2010-08-25 08:27:02 +00009321 InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization);
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009322
Douglas Gregore47f5a72009-10-14 23:41:34 +00009323 // C++0x [temp.explicit]p2:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009324 // If the explicit instantiation is for a member function, a member class
Douglas Gregore47f5a72009-10-14 23:41:34 +00009325 // or a static data member of a class template specialization, the name of
9326 // the class template specialization in the qualified-id for the member
9327 // name shall be a simple-template-id.
9328 //
9329 // C++98 has the same restriction, just worded differently.
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00009330 FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate();
Faisal Vali2ab8c152017-12-30 04:15:27 +00009331 if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId && !FunTmpl &&
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009332 D.getCXXScopeSpec().isSet() &&
Douglas Gregore47f5a72009-10-14 23:41:34 +00009333 !ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()))
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009334 Diag(D.getIdentifierLoc(),
Douglas Gregor010815a2010-06-16 16:26:47 +00009335 diag::ext_explicit_instantiation_without_qualified_id)
Douglas Gregore47f5a72009-10-14 23:41:34 +00009336 << Specialization << D.getCXXScopeSpec().getRange();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009337
Douglas Gregore47f5a72009-10-14 23:41:34 +00009338 CheckExplicitInstantiationScope(*this,
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009339 FunTmpl? (NamedDecl *)FunTmpl
Douglas Gregore47f5a72009-10-14 23:41:34 +00009340 : Specialization->getInstantiatedFromMemberFunction(),
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009341 D.getIdentifierLoc(),
Douglas Gregore47f5a72009-10-14 23:41:34 +00009342 D.getCXXScopeSpec().isSet());
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009343
Douglas Gregor450f00842009-09-25 18:43:00 +00009344 // FIXME: Create some kind of ExplicitInstantiationDecl here.
Craig Topperc3ec1492014-05-26 06:22:03 +00009345 return (Decl*) nullptr;
Douglas Gregor450f00842009-09-25 18:43:00 +00009346}
9347
John McCallfaf5fb42010-08-26 23:41:50 +00009348TypeResult
Faisal Vali090da2d2018-01-01 18:23:28 +00009349Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
John McCall7f41d982009-09-11 04:59:25 +00009350 const CXXScopeSpec &SS, IdentifierInfo *Name,
9351 SourceLocation TagLoc, SourceLocation NameLoc) {
9352 // This has to hold, because SS is expected to be defined.
9353 assert(Name && "Expected a name in a dependent tag");
9354
Aaron Ballman4a979672014-01-03 13:56:08 +00009355 NestedNameSpecifier *NNS = SS.getScopeRep();
John McCall7f41d982009-09-11 04:59:25 +00009356 if (!NNS)
9357 return true;
9358
Abramo Bagnara6150c882010-05-11 21:36:43 +00009359 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
Daniel Dunbarf4b37e12010-04-01 16:50:48 +00009360
Douglas Gregorba41d012010-04-24 16:38:41 +00009361 if (TUK == TUK_Declaration || TUK == TUK_Definition) {
9362 Diag(NameLoc, diag::err_dependent_tag_decl)
Abramo Bagnara6150c882010-05-11 21:36:43 +00009363 << (TUK == TUK_Definition) << Kind << SS.getRange();
Douglas Gregorba41d012010-04-24 16:38:41 +00009364 return true;
9365 }
Abramo Bagnara6150c882010-05-11 21:36:43 +00009366
Douglas Gregore7c20652011-03-02 00:47:37 +00009367 // Create the resulting type.
Abramo Bagnara6150c882010-05-11 21:36:43 +00009368 ElaboratedTypeKeyword Kwd = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
Douglas Gregore7c20652011-03-02 00:47:37 +00009369 QualType Result = Context.getDependentNameType(Kwd, NNS, Name);
Simon Pilgrim6905d222016-12-30 22:55:33 +00009370
Douglas Gregore7c20652011-03-02 00:47:37 +00009371 // Create type-source location information for this type.
9372 TypeLocBuilder TLB;
9373 DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(Result);
Abramo Bagnara9033e2b2012-02-06 19:09:27 +00009374 TL.setElaboratedKeywordLoc(TagLoc);
Douglas Gregore7c20652011-03-02 00:47:37 +00009375 TL.setQualifierLoc(SS.getWithLocInContext(Context));
9376 TL.setNameLoc(NameLoc);
9377 return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
John McCall7f41d982009-09-11 04:59:25 +00009378}
9379
John McCallfaf5fb42010-08-26 23:41:50 +00009380TypeResult
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009381Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
9382 const CXXScopeSpec &SS, const IdentifierInfo &II,
Douglas Gregorf7d77712010-06-16 22:31:08 +00009383 SourceLocation IdLoc) {
Douglas Gregor9cbc22b2011-02-28 22:42:13 +00009384 if (SS.isInvalid())
Douglas Gregor333489b2009-03-27 23:10:48 +00009385 return true;
Simon Pilgrim6905d222016-12-30 22:55:33 +00009386
Richard Smith0bf8a4922011-10-18 20:49:44 +00009387 if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
9388 Diag(TypenameLoc,
Richard Smith2bf7fdb2013-01-02 11:42:31 +00009389 getLangOpts().CPlusPlus11 ?
Richard Smith0bf8a4922011-10-18 20:49:44 +00009390 diag::warn_cxx98_compat_typename_outside_of_template :
9391 diag::ext_typename_outside_of_template)
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009392 << FixItHint::CreateRemoval(TypenameLoc);
9393
Douglas Gregor3d0da5f2011-03-01 01:34:45 +00009394 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
Douglas Gregor844cb502011-03-01 18:12:44 +00009395 QualType T = CheckTypenameType(TypenameLoc.isValid()? ETK_Typename : ETK_None,
9396 TypenameLoc, QualifierLoc, II, IdLoc);
Douglas Gregorfe3d7d02009-04-01 21:51:26 +00009397 if (T.isNull())
9398 return true;
John McCall99b2fe52010-04-29 23:50:39 +00009399
9400 TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
9401 if (isa<DependentNameType>(T)) {
David Blaikie6adc78e2013-02-18 22:06:02 +00009402 DependentNameTypeLoc TL = TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
Abramo Bagnara9033e2b2012-02-06 19:09:27 +00009403 TL.setElaboratedKeywordLoc(TypenameLoc);
Douglas Gregor3d0da5f2011-03-01 01:34:45 +00009404 TL.setQualifierLoc(QualifierLoc);
John McCallf7bcc812010-05-28 23:32:21 +00009405 TL.setNameLoc(IdLoc);
John McCall99b2fe52010-04-29 23:50:39 +00009406 } else {
David Blaikie6adc78e2013-02-18 22:06:02 +00009407 ElaboratedTypeLoc TL = TSI->getTypeLoc().castAs<ElaboratedTypeLoc>();
Abramo Bagnara9033e2b2012-02-06 19:09:27 +00009408 TL.setElaboratedKeywordLoc(TypenameLoc);
Douglas Gregor844cb502011-03-01 18:12:44 +00009409 TL.setQualifierLoc(QualifierLoc);
David Blaikie6adc78e2013-02-18 22:06:02 +00009410 TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
John McCall99b2fe52010-04-29 23:50:39 +00009411 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009412
John McCallba7bf592010-08-24 05:47:05 +00009413 return CreateParsedType(T, TSI);
Douglas Gregor333489b2009-03-27 23:10:48 +00009414}
9415
John McCallfaf5fb42010-08-26 23:41:50 +00009416TypeResult
Abramo Bagnara48c05be2012-02-06 14:41:24 +00009417Sema::ActOnTypenameType(Scope *S,
9418 SourceLocation TypenameLoc,
9419 const CXXScopeSpec &SS,
9420 SourceLocation TemplateKWLoc,
Douglas Gregorb09518c2011-02-27 22:46:49 +00009421 TemplateTy TemplateIn,
Richard Smith74f02342017-01-19 21:00:13 +00009422 IdentifierInfo *TemplateII,
9423 SourceLocation TemplateIILoc,
Douglas Gregorb09518c2011-02-27 22:46:49 +00009424 SourceLocation LAngleLoc,
9425 ASTTemplateArgsPtr TemplateArgsIn,
9426 SourceLocation RAngleLoc) {
Richard Smith0bf8a4922011-10-18 20:49:44 +00009427 if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
9428 Diag(TypenameLoc,
Richard Smith2bf7fdb2013-01-02 11:42:31 +00009429 getLangOpts().CPlusPlus11 ?
Richard Smith0bf8a4922011-10-18 20:49:44 +00009430 diag::warn_cxx98_compat_typename_outside_of_template :
9431 diag::ext_typename_outside_of_template)
9432 << FixItHint::CreateRemoval(TypenameLoc);
Simon Pilgrim6905d222016-12-30 22:55:33 +00009433
Richard Smith74f02342017-01-19 21:00:13 +00009434 // Strangely, non-type results are not ignored by this lookup, so the
9435 // program is ill-formed if it finds an injected-class-name.
Richard Smith62559bd2017-02-01 21:36:38 +00009436 if (TypenameLoc.isValid()) {
9437 auto *LookupRD =
9438 dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, false));
9439 if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
9440 Diag(TemplateIILoc,
9441 diag::ext_out_of_line_qualified_id_type_names_constructor)
9442 << TemplateII << 0 /*injected-class-name used as template name*/
9443 << (TemplateKWLoc.isValid() ? 1 : 0 /*'template'/'typename' keyword*/);
9444 }
Richard Smith74f02342017-01-19 21:00:13 +00009445 }
9446
Douglas Gregorb09518c2011-02-27 22:46:49 +00009447 // Translate the parser's template argument list in our AST format.
9448 TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
9449 translateTemplateArguments(TemplateArgsIn, TemplateArgs);
Simon Pilgrim6905d222016-12-30 22:55:33 +00009450
Douglas Gregorb09518c2011-02-27 22:46:49 +00009451 TemplateName Template = TemplateIn.get();
Douglas Gregor84a6a0a2011-03-01 16:44:30 +00009452 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
9453 // Construct a dependent template specialization type.
9454 assert(DTN && "dependent template has non-dependent name?");
Aaron Ballman4a979672014-01-03 13:56:08 +00009455 assert(DTN->getQualifier() == SS.getScopeRep());
Douglas Gregor84a6a0a2011-03-01 16:44:30 +00009456 QualType T = Context.getDependentTemplateSpecializationType(ETK_Typename,
9457 DTN->getQualifier(),
9458 DTN->getIdentifier(),
9459 TemplateArgs);
Simon Pilgrim6905d222016-12-30 22:55:33 +00009460
Douglas Gregor84a6a0a2011-03-01 16:44:30 +00009461 // Create source-location information for this type.
John McCallf7bcc812010-05-28 23:32:21 +00009462 TypeLocBuilder Builder;
Simon Pilgrim6905d222016-12-30 22:55:33 +00009463 DependentTemplateSpecializationTypeLoc SpecTL
Douglas Gregor84a6a0a2011-03-01 16:44:30 +00009464 = Builder.push<DependentTemplateSpecializationTypeLoc>(T);
Abramo Bagnara48c05be2012-02-06 14:41:24 +00009465 SpecTL.setElaboratedKeywordLoc(TypenameLoc);
9466 SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
Abramo Bagnarae0a70b22012-02-06 22:45:07 +00009467 SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
Richard Smith74f02342017-01-19 21:00:13 +00009468 SpecTL.setTemplateNameLoc(TemplateIILoc);
Douglas Gregorb09518c2011-02-27 22:46:49 +00009469 SpecTL.setLAngleLoc(LAngleLoc);
9470 SpecTL.setRAngleLoc(RAngleLoc);
Douglas Gregorb09518c2011-02-27 22:46:49 +00009471 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
9472 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
Douglas Gregor84a6a0a2011-03-01 16:44:30 +00009473 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
Douglas Gregor12bbfe12009-09-02 13:05:45 +00009474 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00009475
Richard Smith74f02342017-01-19 21:00:13 +00009476 QualType T = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
Douglas Gregor84a6a0a2011-03-01 16:44:30 +00009477 if (T.isNull())
9478 return true;
Simon Pilgrim6905d222016-12-30 22:55:33 +00009479
Abramo Bagnara48c05be2012-02-06 14:41:24 +00009480 // Provide source-location information for the template specialization type.
Douglas Gregorb09518c2011-02-27 22:46:49 +00009481 TypeLocBuilder Builder;
Abramo Bagnara48c05be2012-02-06 14:41:24 +00009482 TemplateSpecializationTypeLoc SpecTL
Douglas Gregor84a6a0a2011-03-01 16:44:30 +00009483 = Builder.push<TemplateSpecializationTypeLoc>(T);
Abramo Bagnara48c05be2012-02-06 14:41:24 +00009484 SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
Richard Smith74f02342017-01-19 21:00:13 +00009485 SpecTL.setTemplateNameLoc(TemplateIILoc);
Douglas Gregorb09518c2011-02-27 22:46:49 +00009486 SpecTL.setLAngleLoc(LAngleLoc);
9487 SpecTL.setRAngleLoc(RAngleLoc);
Douglas Gregorb09518c2011-02-27 22:46:49 +00009488 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
9489 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
Simon Pilgrim6905d222016-12-30 22:55:33 +00009490
Douglas Gregor84a6a0a2011-03-01 16:44:30 +00009491 T = Context.getElaboratedType(ETK_Typename, SS.getScopeRep(), T);
9492 ElaboratedTypeLoc TL = Builder.push<ElaboratedTypeLoc>(T);
Abramo Bagnara9033e2b2012-02-06 19:09:27 +00009493 TL.setElaboratedKeywordLoc(TypenameLoc);
Douglas Gregor844cb502011-03-01 18:12:44 +00009494 TL.setQualifierLoc(SS.getWithLocInContext(Context));
Simon Pilgrim6905d222016-12-30 22:55:33 +00009495
Douglas Gregor84a6a0a2011-03-01 16:44:30 +00009496 TypeSourceInfo *TSI = Builder.getTypeSourceInfo(Context, T);
9497 return CreateParsedType(T, TSI);
Douglas Gregordce2b622009-04-01 00:28:59 +00009498}
9499
Douglas Gregorb09518c2011-02-27 22:46:49 +00009500
Richard Smith6f8d2c62012-05-09 05:17:00 +00009501/// Determine whether this failed name lookup should be treated as being
9502/// disabled by a usage of std::enable_if.
9503static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II,
Douglas Gregor00fa10b2017-07-05 20:20:14 +00009504 SourceRange &CondRange, Expr *&Cond) {
Richard Smith6f8d2c62012-05-09 05:17:00 +00009505 // We must be looking for a ::type...
9506 if (!II.isStr("type"))
9507 return false;
9508
9509 // ... within an explicitly-written template specialization...
9510 if (!NNS || !NNS.getNestedNameSpecifier()->getAsType())
9511 return false;
9512 TypeLoc EnableIfTy = NNS.getTypeLoc();
David Blaikie6adc78e2013-02-18 22:06:02 +00009513 TemplateSpecializationTypeLoc EnableIfTSTLoc =
9514 EnableIfTy.getAs<TemplateSpecializationTypeLoc>();
9515 if (!EnableIfTSTLoc || EnableIfTSTLoc.getNumArgs() == 0)
Richard Smith6f8d2c62012-05-09 05:17:00 +00009516 return false;
George Burgess IV00f70bd2018-03-01 05:43:23 +00009517 const TemplateSpecializationType *EnableIfTST = EnableIfTSTLoc.getTypePtr();
Richard Smith6f8d2c62012-05-09 05:17:00 +00009518
9519 // ... which names a complete class template declaration...
9520 const TemplateDecl *EnableIfDecl =
9521 EnableIfTST->getTemplateName().getAsTemplateDecl();
9522 if (!EnableIfDecl || EnableIfTST->isIncompleteType())
9523 return false;
9524
9525 // ... called "enable_if".
9526 const IdentifierInfo *EnableIfII =
9527 EnableIfDecl->getDeclName().getAsIdentifierInfo();
9528 if (!EnableIfII || !EnableIfII->isStr("enable_if"))
9529 return false;
9530
9531 // Assume the first template argument is the condition.
David Blaikie6adc78e2013-02-18 22:06:02 +00009532 CondRange = EnableIfTSTLoc.getArgLoc(0).getSourceRange();
Douglas Gregor00fa10b2017-07-05 20:20:14 +00009533
9534 // Dig out the condition.
9535 Cond = nullptr;
9536 if (EnableIfTSTLoc.getArgLoc(0).getArgument().getKind()
9537 != TemplateArgument::Expression)
9538 return true;
9539
9540 Cond = EnableIfTSTLoc.getArgLoc(0).getSourceExpression();
9541
9542 // Ignore Boolean literals; they add no value.
9543 if (isa<CXXBoolLiteralExpr>(Cond->IgnoreParenCasts()))
9544 Cond = nullptr;
9545
Richard Smith6f8d2c62012-05-09 05:17:00 +00009546 return true;
9547}
9548
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00009549/// Build the type that describes a C++ typename specifier,
Douglas Gregor333489b2009-03-27 23:10:48 +00009550/// e.g., "typename T::type".
9551QualType
Simon Pilgrim6905d222016-12-30 22:55:33 +00009552Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword,
Douglas Gregor9cbc22b2011-02-28 22:42:13 +00009553 SourceLocation KeywordLoc,
Simon Pilgrim6905d222016-12-30 22:55:33 +00009554 NestedNameSpecifierLoc QualifierLoc,
Douglas Gregor9cbc22b2011-02-28 22:42:13 +00009555 const IdentifierInfo &II,
Abramo Bagnarad7548482010-05-19 21:37:53 +00009556 SourceLocation IILoc) {
John McCall0b66eb32010-05-01 00:40:08 +00009557 CXXScopeSpec SS;
Douglas Gregor9cbc22b2011-02-28 22:42:13 +00009558 SS.Adopt(QualifierLoc);
Douglas Gregor333489b2009-03-27 23:10:48 +00009559
John McCall0b66eb32010-05-01 00:40:08 +00009560 DeclContext *Ctx = computeDeclContext(SS);
9561 if (!Ctx) {
9562 // If the nested-name-specifier is dependent and couldn't be
9563 // resolved to a type, build a typename type.
Douglas Gregor9cbc22b2011-02-28 22:42:13 +00009564 assert(QualifierLoc.getNestedNameSpecifier()->isDependent());
Simon Pilgrim6905d222016-12-30 22:55:33 +00009565 return Context.getDependentNameType(Keyword,
9566 QualifierLoc.getNestedNameSpecifier(),
Douglas Gregor9cbc22b2011-02-28 22:42:13 +00009567 &II);
Douglas Gregorc9f9b862009-05-11 19:58:34 +00009568 }
Douglas Gregor333489b2009-03-27 23:10:48 +00009569
John McCall0b66eb32010-05-01 00:40:08 +00009570 // If the nested-name-specifier refers to the current instantiation,
9571 // the "typename" keyword itself is superfluous. In C++03, the
9572 // program is actually ill-formed. However, DR 382 (in C++0x CD1)
9573 // allows such extraneous "typename" keywords, and we retroactively
Douglas Gregorc9d26822010-06-14 22:07:54 +00009574 // apply this DR to C++03 code with only a warning. In any case we continue.
Douglas Gregorc9f9b862009-05-11 19:58:34 +00009575
John McCall0b66eb32010-05-01 00:40:08 +00009576 if (RequireCompleteDeclContext(SS, Ctx))
9577 return QualType();
Douglas Gregor333489b2009-03-27 23:10:48 +00009578
9579 DeclarationName Name(&II);
Abramo Bagnarad7548482010-05-19 21:37:53 +00009580 LookupResult Result(*this, Name, IILoc, LookupOrdinaryName);
Nikola Smiljanicfce370e2014-12-01 23:15:01 +00009581 LookupQualifiedName(Result, Ctx, SS);
Douglas Gregor333489b2009-03-27 23:10:48 +00009582 unsigned DiagID = 0;
Craig Topperc3ec1492014-05-26 06:22:03 +00009583 Decl *Referenced = nullptr;
John McCall27b18f82009-11-17 02:14:36 +00009584 switch (Result.getResultKind()) {
Richard Smith6f8d2c62012-05-09 05:17:00 +00009585 case LookupResult::NotFound: {
9586 // If we're looking up 'type' within a template named 'enable_if', produce
9587 // a more specific diagnostic.
9588 SourceRange CondRange;
Douglas Gregor00fa10b2017-07-05 20:20:14 +00009589 Expr *Cond = nullptr;
9590 if (isEnableIf(QualifierLoc, II, CondRange, Cond)) {
9591 // If we have a condition, narrow it down to the specific failed
9592 // condition.
9593 if (Cond) {
9594 Expr *FailedCond;
9595 std::string FailedDescription;
9596 std::tie(FailedCond, FailedDescription) =
Douglas Gregor672281a2017-09-14 23:38:42 +00009597 findFailedBooleanCondition(Cond, /*AllowTopLevelCond=*/true);
Douglas Gregor00fa10b2017-07-05 20:20:14 +00009598
9599 Diag(FailedCond->getExprLoc(),
9600 diag::err_typename_nested_not_found_requirement)
9601 << FailedDescription
9602 << FailedCond->getSourceRange();
9603 return QualType();
9604 }
9605
Richard Smith6f8d2c62012-05-09 05:17:00 +00009606 Diag(CondRange.getBegin(), diag::err_typename_nested_not_found_enable_if)
Douglas Gregor00fa10b2017-07-05 20:20:14 +00009607 << Ctx << CondRange;
Richard Smith6f8d2c62012-05-09 05:17:00 +00009608 return QualType();
9609 }
9610
Douglas Gregore40876a2009-10-13 21:16:44 +00009611 DiagID = diag::err_typename_nested_not_found;
Douglas Gregor333489b2009-03-27 23:10:48 +00009612 break;
Richard Smith6f8d2c62012-05-09 05:17:00 +00009613 }
Douglas Gregoraed2efb2010-12-09 00:06:27 +00009614
9615 case LookupResult::FoundUnresolvedValue: {
9616 // We found a using declaration that is a value. Most likely, the using
9617 // declaration itself is meant to have the 'typename' keyword.
Douglas Gregor9cbc22b2011-02-28 22:42:13 +00009618 SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
Douglas Gregoraed2efb2010-12-09 00:06:27 +00009619 IILoc);
9620 Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
9621 << Name << Ctx << FullRange;
9622 if (UnresolvedUsingValueDecl *Using
9623 = dyn_cast<UnresolvedUsingValueDecl>(Result.getRepresentativeDecl())){
Douglas Gregora9d87bc2011-02-25 00:36:19 +00009624 SourceLocation Loc = Using->getQualifierLoc().getBeginLoc();
Douglas Gregoraed2efb2010-12-09 00:06:27 +00009625 Diag(Loc, diag::note_using_value_decl_missing_typename)
9626 << FixItHint::CreateInsertion(Loc, "typename ");
9627 }
9628 }
9629 // Fall through to create a dependent typename type, from which we can recover
9630 // better.
Galina Kistanova3779cb32017-06-07 06:25:05 +00009631 LLVM_FALLTHROUGH;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009632
Douglas Gregord0d2ee02010-01-15 01:44:47 +00009633 case LookupResult::NotFoundInCurrentInstantiation:
9634 // Okay, it's a member of an unknown instantiation.
Simon Pilgrim6905d222016-12-30 22:55:33 +00009635 return Context.getDependentNameType(Keyword,
9636 QualifierLoc.getNestedNameSpecifier(),
Douglas Gregor9cbc22b2011-02-28 22:42:13 +00009637 &II);
Douglas Gregor333489b2009-03-27 23:10:48 +00009638
9639 case LookupResult::Found:
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009640 if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
Richard Smith74f02342017-01-19 21:00:13 +00009641 // C++ [class.qual]p2:
9642 // In a lookup in which function names are not ignored and the
9643 // nested-name-specifier nominates a class C, if the name specified
9644 // after the nested-name-specifier, when looked up in C, is the
9645 // injected-class-name of C [...] then the name is instead considered
9646 // to name the constructor of class C.
9647 //
9648 // Unlike in an elaborated-type-specifier, function names are not ignored
9649 // in typename-specifier lookup. However, they are ignored in all the
9650 // contexts where we form a typename type with no keyword (that is, in
9651 // mem-initializer-ids, base-specifiers, and elaborated-type-specifiers).
9652 //
9653 // FIXME: That's not strictly true: mem-initializer-id lookup does not
9654 // ignore functions, but that appears to be an oversight.
9655 auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(Ctx);
9656 auto *FoundRD = dyn_cast<CXXRecordDecl>(Type);
9657 if (Keyword == ETK_Typename && LookupRD && FoundRD &&
9658 FoundRD->isInjectedClassName() &&
9659 declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
9660 Diag(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)
9661 << &II << 1 << 0 /*'typename' keyword used*/;
9662
Abramo Bagnara6150c882010-05-11 21:36:43 +00009663 // We found a type. Build an ElaboratedType, since the
9664 // typename-specifier was just sugar.
Nico Weber72889432014-09-06 01:25:55 +00009665 MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
Richard Smith74f02342017-01-19 21:00:13 +00009666 return Context.getElaboratedType(Keyword,
Douglas Gregor9cbc22b2011-02-28 22:42:13 +00009667 QualifierLoc.getNestedNameSpecifier(),
Abramo Bagnara6150c882010-05-11 21:36:43 +00009668 Context.getTypeDeclType(Type));
Douglas Gregor333489b2009-03-27 23:10:48 +00009669 }
9670
Richard Smithee579842017-01-30 20:39:26 +00009671 // C++ [dcl.type.simple]p2:
9672 // A type-specifier of the form
9673 // typename[opt] nested-name-specifier[opt] template-name
9674 // is a placeholder for a deduced class type [...].
Aaron Ballmanc351fba2017-12-04 20:27:34 +00009675 if (getLangOpts().CPlusPlus17) {
Richard Smithee579842017-01-30 20:39:26 +00009676 if (auto *TD = getAsTypeTemplateDecl(Result.getFoundDecl())) {
9677 return Context.getElaboratedType(
9678 Keyword, QualifierLoc.getNestedNameSpecifier(),
9679 Context.getDeducedTemplateSpecializationType(TemplateName(TD),
9680 QualType(), false));
9681 }
9682 }
Richard Smith600b5262017-01-26 20:40:47 +00009683
Douglas Gregor333489b2009-03-27 23:10:48 +00009684 DiagID = diag::err_typename_nested_not_type;
John McCall9f3059a2009-10-09 21:13:30 +00009685 Referenced = Result.getFoundDecl();
Douglas Gregor333489b2009-03-27 23:10:48 +00009686 break;
9687
9688 case LookupResult::FoundOverloaded:
9689 DiagID = diag::err_typename_nested_not_type;
9690 Referenced = *Result.begin();
9691 break;
9692
John McCall6538c932009-10-10 05:48:19 +00009693 case LookupResult::Ambiguous:
Douglas Gregor333489b2009-03-27 23:10:48 +00009694 return QualType();
9695 }
9696
9697 // If we get here, it's because name lookup did not find a
9698 // type. Emit an appropriate diagnostic and return an error.
Douglas Gregor9cbc22b2011-02-28 22:42:13 +00009699 SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
Abramo Bagnarad7548482010-05-19 21:37:53 +00009700 IILoc);
9701 Diag(IILoc, DiagID) << FullRange << Name << Ctx;
Douglas Gregor333489b2009-03-27 23:10:48 +00009702 if (Referenced)
9703 Diag(Referenced->getLocation(), diag::note_typename_refers_here)
9704 << Name;
9705 return QualType();
9706}
Douglas Gregor15acfb92009-08-06 16:20:37 +00009707
9708namespace {
9709 // See Sema::RebuildTypeInCurrentInstantiation
Benjamin Kramer337e3a52009-11-28 19:45:26 +00009710 class CurrentInstantiationRebuilder
Mike Stump11289f42009-09-09 15:08:12 +00009711 : public TreeTransform<CurrentInstantiationRebuilder> {
Douglas Gregor15acfb92009-08-06 16:20:37 +00009712 SourceLocation Loc;
9713 DeclarationName Entity;
Mike Stump11289f42009-09-09 15:08:12 +00009714
Douglas Gregor15acfb92009-08-06 16:20:37 +00009715 public:
Douglas Gregor14cf7522010-04-30 18:55:50 +00009716 typedef TreeTransform<CurrentInstantiationRebuilder> inherited;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009717
Mike Stump11289f42009-09-09 15:08:12 +00009718 CurrentInstantiationRebuilder(Sema &SemaRef,
Douglas Gregor15acfb92009-08-06 16:20:37 +00009719 SourceLocation Loc,
Mike Stump11289f42009-09-09 15:08:12 +00009720 DeclarationName Entity)
9721 : TreeTransform<CurrentInstantiationRebuilder>(SemaRef),
Douglas Gregor15acfb92009-08-06 16:20:37 +00009722 Loc(Loc), Entity(Entity) { }
Mike Stump11289f42009-09-09 15:08:12 +00009723
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00009724 /// Determine whether the given type \p T has already been
Douglas Gregor15acfb92009-08-06 16:20:37 +00009725 /// transformed.
9726 ///
9727 /// For the purposes of type reconstruction, a type has already been
9728 /// transformed if it is NULL or if it is not dependent.
9729 bool AlreadyTransformed(QualType T) {
9730 return T.isNull() || !T->isDependentType();
9731 }
Mike Stump11289f42009-09-09 15:08:12 +00009732
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00009733 /// Returns the location of the entity whose type is being
Douglas Gregor15acfb92009-08-06 16:20:37 +00009734 /// rebuilt.
9735 SourceLocation getBaseLocation() { return Loc; }
Mike Stump11289f42009-09-09 15:08:12 +00009736
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00009737 /// Returns the name of the entity whose type is being rebuilt.
Douglas Gregor15acfb92009-08-06 16:20:37 +00009738 DeclarationName getBaseEntity() { return Entity; }
Mike Stump11289f42009-09-09 15:08:12 +00009739
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00009740 /// Sets the "base" location and entity when that
Douglas Gregoref6ab412009-10-27 06:26:26 +00009741 /// information is known based on another transformation.
9742 void setBase(SourceLocation Loc, DeclarationName Entity) {
9743 this->Loc = Loc;
9744 this->Entity = Entity;
9745 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00009746
Douglas Gregor0c46b2b2012-02-13 22:00:16 +00009747 ExprResult TransformLambdaExpr(LambdaExpr *E) {
9748 // Lambdas never need to be transformed.
9749 return E;
9750 }
Douglas Gregor15acfb92009-08-06 16:20:37 +00009751 };
Eugene Zelenko1ced5092016-02-12 22:53:10 +00009752} // end anonymous namespace
Douglas Gregor15acfb92009-08-06 16:20:37 +00009753
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00009754/// Rebuilds a type within the context of the current instantiation.
Douglas Gregor15acfb92009-08-06 16:20:37 +00009755///
Mike Stump11289f42009-09-09 15:08:12 +00009756/// The type \p T is part of the type of an out-of-line member definition of
Douglas Gregor15acfb92009-08-06 16:20:37 +00009757/// a class template (or class template partial specialization) that was parsed
Mike Stump11289f42009-09-09 15:08:12 +00009758/// and constructed before we entered the scope of the class template (or
Douglas Gregor15acfb92009-08-06 16:20:37 +00009759/// partial specialization thereof). This routine will rebuild that type now
9760/// that we have entered the declarator's scope, which may produce different
9761/// canonical types, e.g.,
9762///
9763/// \code
9764/// template<typename T>
9765/// struct X {
9766/// typedef T* pointer;
9767/// pointer data();
9768/// };
9769///
9770/// template<typename T>
9771/// typename X<T>::pointer X<T>::data() { ... }
9772/// \endcode
9773///
Douglas Gregorc1d2d8a2010-03-31 17:34:00 +00009774/// Here, the type "typename X<T>::pointer" will be created as a DependentNameType,
Douglas Gregor15acfb92009-08-06 16:20:37 +00009775/// since we do not know that we can look into X<T> when we parsed the type.
9776/// This function will rebuild the type, performing the lookup of "pointer"
Abramo Bagnara6150c882010-05-11 21:36:43 +00009777/// in X<T> and returning an ElaboratedType whose canonical type is the same
Douglas Gregor15acfb92009-08-06 16:20:37 +00009778/// as the canonical type of T*, allowing the return types of the out-of-line
9779/// definition and the declaration to match.
John McCall99b2fe52010-04-29 23:50:39 +00009780TypeSourceInfo *Sema::RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,
9781 SourceLocation Loc,
9782 DeclarationName Name) {
9783 if (!T || !T->getType()->isDependentType())
Douglas Gregor15acfb92009-08-06 16:20:37 +00009784 return T;
Mike Stump11289f42009-09-09 15:08:12 +00009785
Douglas Gregor15acfb92009-08-06 16:20:37 +00009786 CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name);
9787 return Rebuilder.TransformType(T);
Benjamin Kramer854d7de2009-08-11 22:33:06 +00009788}
Douglas Gregorbe999392009-09-15 16:23:51 +00009789
John McCalldadc5752010-08-24 06:29:42 +00009790ExprResult Sema::RebuildExprInCurrentInstantiation(Expr *E) {
John McCallba7bf592010-08-24 05:47:05 +00009791 CurrentInstantiationRebuilder Rebuilder(*this, E->getExprLoc(),
9792 DeclarationName());
9793 return Rebuilder.TransformExpr(E);
9794}
9795
John McCall99b2fe52010-04-29 23:50:39 +00009796bool Sema::RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS) {
Simon Pilgrim6905d222016-12-30 22:55:33 +00009797 if (SS.isInvalid())
Douglas Gregor10176412011-02-25 16:07:42 +00009798 return true;
John McCall2408e322010-04-27 00:57:59 +00009799
Douglas Gregor10176412011-02-25 16:07:42 +00009800 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
John McCall2408e322010-04-27 00:57:59 +00009801 CurrentInstantiationRebuilder Rebuilder(*this, SS.getRange().getBegin(),
9802 DeclarationName());
Simon Pilgrim6905d222016-12-30 22:55:33 +00009803 NestedNameSpecifierLoc Rebuilt
Douglas Gregor10176412011-02-25 16:07:42 +00009804 = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
Simon Pilgrim6905d222016-12-30 22:55:33 +00009805 if (!Rebuilt)
Douglas Gregor10176412011-02-25 16:07:42 +00009806 return true;
John McCall99b2fe52010-04-29 23:50:39 +00009807
Douglas Gregor10176412011-02-25 16:07:42 +00009808 SS.Adopt(Rebuilt);
John McCall99b2fe52010-04-29 23:50:39 +00009809 return false;
John McCall2408e322010-04-27 00:57:59 +00009810}
9811
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00009812/// Rebuild the template parameters now that we know we're in a current
Douglas Gregor041b0842011-10-14 15:31:12 +00009813/// instantiation.
9814bool Sema::RebuildTemplateParamsInCurrentInstantiation(
9815 TemplateParameterList *Params) {
9816 for (unsigned I = 0, N = Params->size(); I != N; ++I) {
9817 Decl *Param = Params->getParam(I);
Simon Pilgrim6905d222016-12-30 22:55:33 +00009818
Douglas Gregor041b0842011-10-14 15:31:12 +00009819 // There is nothing to rebuild in a type parameter.
9820 if (isa<TemplateTypeParmDecl>(Param))
9821 continue;
Simon Pilgrim6905d222016-12-30 22:55:33 +00009822
Douglas Gregor041b0842011-10-14 15:31:12 +00009823 // Rebuild the template parameter list of a template template parameter.
Simon Pilgrim6905d222016-12-30 22:55:33 +00009824 if (TemplateTemplateParmDecl *TTP
Douglas Gregor041b0842011-10-14 15:31:12 +00009825 = dyn_cast<TemplateTemplateParmDecl>(Param)) {
9826 if (RebuildTemplateParamsInCurrentInstantiation(
9827 TTP->getTemplateParameters()))
9828 return true;
Simon Pilgrim6905d222016-12-30 22:55:33 +00009829
Douglas Gregor041b0842011-10-14 15:31:12 +00009830 continue;
9831 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00009832
Douglas Gregor041b0842011-10-14 15:31:12 +00009833 // Rebuild the type of a non-type template parameter.
9834 NonTypeTemplateParmDecl *NTTP = cast<NonTypeTemplateParmDecl>(Param);
Simon Pilgrim6905d222016-12-30 22:55:33 +00009835 TypeSourceInfo *NewTSI
9836 = RebuildTypeInCurrentInstantiation(NTTP->getTypeSourceInfo(),
9837 NTTP->getLocation(),
Douglas Gregor041b0842011-10-14 15:31:12 +00009838 NTTP->getDeclName());
9839 if (!NewTSI)
9840 return true;
Simon Pilgrim6905d222016-12-30 22:55:33 +00009841
Douglas Gregor041b0842011-10-14 15:31:12 +00009842 if (NewTSI != NTTP->getTypeSourceInfo()) {
9843 NTTP->setTypeSourceInfo(NewTSI);
9844 NTTP->setType(NewTSI->getType());
9845 }
9846 }
Simon Pilgrim6905d222016-12-30 22:55:33 +00009847
Douglas Gregor041b0842011-10-14 15:31:12 +00009848 return false;
9849}
9850
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00009851/// Produces a formatted string that describes the binding of
Douglas Gregorbe999392009-09-15 16:23:51 +00009852/// template parameters to template arguments.
9853std::string
9854Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
9855 const TemplateArgumentList &Args) {
Douglas Gregor1ccc8412010-11-07 23:05:16 +00009856 return getTemplateArgumentBindingsText(Params, Args.data(), Args.size());
Douglas Gregore62e6a02009-11-11 19:13:48 +00009857}
9858
9859std::string
9860Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params,
9861 const TemplateArgument *Args,
9862 unsigned NumArgs) {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00009863 SmallString<128> Str;
Douglas Gregor0192c232010-12-20 16:52:59 +00009864 llvm::raw_svector_ostream Out(Str);
Douglas Gregorbe999392009-09-15 16:23:51 +00009865
Douglas Gregore62e6a02009-11-11 19:13:48 +00009866 if (!Params || Params->size() == 0 || NumArgs == 0)
Douglas Gregor0192c232010-12-20 16:52:59 +00009867 return std::string();
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009868
Douglas Gregorbe999392009-09-15 16:23:51 +00009869 for (unsigned I = 0, N = Params->size(); I != N; ++I) {
Douglas Gregore62e6a02009-11-11 19:13:48 +00009870 if (I >= NumArgs)
9871 break;
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009872
Douglas Gregorbe999392009-09-15 16:23:51 +00009873 if (I == 0)
Douglas Gregor0192c232010-12-20 16:52:59 +00009874 Out << "[with ";
Douglas Gregorbe999392009-09-15 16:23:51 +00009875 else
Douglas Gregor0192c232010-12-20 16:52:59 +00009876 Out << ", ";
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009877
Douglas Gregorbe999392009-09-15 16:23:51 +00009878 if (const IdentifierInfo *Id = Params->getParam(I)->getIdentifier()) {
Douglas Gregor0192c232010-12-20 16:52:59 +00009879 Out << Id->getName();
Douglas Gregorbe999392009-09-15 16:23:51 +00009880 } else {
Douglas Gregor0192c232010-12-20 16:52:59 +00009881 Out << '$' << I;
Douglas Gregorbe999392009-09-15 16:23:51 +00009882 }
NAKAMURA Takumif9cbcc42011-01-27 07:10:08 +00009883
Douglas Gregor0192c232010-12-20 16:52:59 +00009884 Out << " = ";
Douglas Gregor75acd922011-09-27 23:30:47 +00009885 Args[I].print(getPrintingPolicy(), Out);
Douglas Gregorbe999392009-09-15 16:23:51 +00009886 }
Douglas Gregor0192c232010-12-20 16:52:59 +00009887
9888 Out << ']';
9889 return Out.str();
Douglas Gregorbe999392009-09-15 16:23:51 +00009890}
Francois Pichet1c229c02011-04-22 22:18:13 +00009891
Richard Smithe40f2ba2013-08-07 21:41:30 +00009892void Sema::MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,
9893 CachedTokens &Toks) {
Francois Pichet1c229c02011-04-22 22:18:13 +00009894 if (!FD)
9895 return;
Richard Smithe40f2ba2013-08-07 21:41:30 +00009896
Justin Lebar28f09c52016-10-10 16:26:08 +00009897 auto LPT = llvm::make_unique<LateParsedTemplate>();
Richard Smithe40f2ba2013-08-07 21:41:30 +00009898
9899 // Take tokens to avoid allocations
9900 LPT->Toks.swap(Toks);
9901 LPT->D = FnD;
Justin Lebar28f09c52016-10-10 16:26:08 +00009902 LateParsedTemplateMap.insert(std::make_pair(FD, std::move(LPT)));
Richard Smithe40f2ba2013-08-07 21:41:30 +00009903
9904 FD->setLateTemplateParsed(true);
9905}
9906
9907void Sema::UnmarkAsLateParsedTemplate(FunctionDecl *FD) {
9908 if (!FD)
9909 return;
9910 FD->setLateTemplateParsed(false);
9911}
Francois Pichet1c229c02011-04-22 22:18:13 +00009912
9913bool Sema::IsInsideALocalClassWithinATemplateFunction() {
9914 DeclContext *DC = CurContext;
9915
9916 while (DC) {
9917 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(CurContext)) {
9918 const FunctionDecl *FD = RD->isLocalClass();
9919 return (FD && FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate);
9920 } else if (DC->isTranslationUnit() || DC->isNamespace())
9921 return false;
9922
9923 DC = DC->getParent();
9924 }
9925 return false;
9926}
Richard Smith6739a102016-05-05 00:56:12 +00009927
Benjamin Kramera0a13c32016-08-06 11:21:04 +00009928namespace {
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00009929/// Walk the path from which a declaration was instantiated, and check
Richard Smith6739a102016-05-05 00:56:12 +00009930/// that every explicit specialization along that path is visible. This enforces
9931/// C++ [temp.expl.spec]/6:
9932///
9933/// If a template, a member template or a member of a class template is
9934/// explicitly specialized then that specialization shall be declared before
9935/// the first use of that specialization that would cause an implicit
9936/// instantiation to take place, in every translation unit in which such a
9937/// use occurs; no diagnostic is required.
9938///
9939/// and also C++ [temp.class.spec]/1:
9940///
9941/// A partial specialization shall be declared before the first use of a
9942/// class template specialization that would make use of the partial
9943/// specialization as the result of an implicit or explicit instantiation
9944/// in every translation unit in which such a use occurs; no diagnostic is
9945/// required.
9946class ExplicitSpecializationVisibilityChecker {
9947 Sema &S;
9948 SourceLocation Loc;
9949 llvm::SmallVector<Module *, 8> Modules;
9950
9951public:
9952 ExplicitSpecializationVisibilityChecker(Sema &S, SourceLocation Loc)
9953 : S(S), Loc(Loc) {}
9954
9955 void check(NamedDecl *ND) {
9956 if (auto *FD = dyn_cast<FunctionDecl>(ND))
9957 return checkImpl(FD);
9958 if (auto *RD = dyn_cast<CXXRecordDecl>(ND))
9959 return checkImpl(RD);
9960 if (auto *VD = dyn_cast<VarDecl>(ND))
9961 return checkImpl(VD);
9962 if (auto *ED = dyn_cast<EnumDecl>(ND))
9963 return checkImpl(ED);
9964 }
9965
9966private:
9967 void diagnose(NamedDecl *D, bool IsPartialSpec) {
9968 auto Kind = IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization
9969 : Sema::MissingImportKind::ExplicitSpecialization;
9970 const bool Recover = true;
9971
9972 // If we got a custom set of modules (because only a subset of the
9973 // declarations are interesting), use them, otherwise let
9974 // diagnoseMissingImport intelligently pick some.
9975 if (Modules.empty())
9976 S.diagnoseMissingImport(Loc, D, Kind, Recover);
9977 else
9978 S.diagnoseMissingImport(Loc, D, D->getLocation(), Modules, Kind, Recover);
9979 }
9980
9981 // Check a specific declaration. There are three problematic cases:
9982 //
9983 // 1) The declaration is an explicit specialization of a template
9984 // specialization.
9985 // 2) The declaration is an explicit specialization of a member of an
9986 // templated class.
9987 // 3) The declaration is an instantiation of a template, and that template
9988 // is an explicit specialization of a member of a templated class.
9989 //
9990 // We don't need to go any deeper than that, as the instantiation of the
9991 // surrounding class / etc is not triggered by whatever triggered this
9992 // instantiation, and thus should be checked elsewhere.
9993 template<typename SpecDecl>
9994 void checkImpl(SpecDecl *Spec) {
9995 bool IsHiddenExplicitSpecialization = false;
9996 if (Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
9997 IsHiddenExplicitSpecialization =
9998 Spec->getMemberSpecializationInfo()
9999 ? !S.hasVisibleMemberSpecialization(Spec, &Modules)
Richard Smith54f04402017-05-18 02:29:20 +000010000 : !S.hasVisibleExplicitSpecialization(Spec, &Modules);
Richard Smith6739a102016-05-05 00:56:12 +000010001 } else {
10002 checkInstantiated(Spec);
10003 }
10004
10005 if (IsHiddenExplicitSpecialization)
10006 diagnose(Spec->getMostRecentDecl(), false);
10007 }
10008
10009 void checkInstantiated(FunctionDecl *FD) {
10010 if (auto *TD = FD->getPrimaryTemplate())
10011 checkTemplate(TD);
10012 }
10013
10014 void checkInstantiated(CXXRecordDecl *RD) {
10015 auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
10016 if (!SD)
10017 return;
10018
10019 auto From = SD->getSpecializedTemplateOrPartial();
10020 if (auto *TD = From.dyn_cast<ClassTemplateDecl *>())
10021 checkTemplate(TD);
10022 else if (auto *TD =
10023 From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
10024 if (!S.hasVisibleDeclaration(TD))
10025 diagnose(TD, true);
10026 checkTemplate(TD);
10027 }
10028 }
10029
10030 void checkInstantiated(VarDecl *RD) {
10031 auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
10032 if (!SD)
10033 return;
10034
10035 auto From = SD->getSpecializedTemplateOrPartial();
10036 if (auto *TD = From.dyn_cast<VarTemplateDecl *>())
10037 checkTemplate(TD);
10038 else if (auto *TD =
10039 From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
10040 if (!S.hasVisibleDeclaration(TD))
10041 diagnose(TD, true);
10042 checkTemplate(TD);
10043 }
10044 }
10045
10046 void checkInstantiated(EnumDecl *FD) {}
10047
10048 template<typename TemplDecl>
10049 void checkTemplate(TemplDecl *TD) {
10050 if (TD->isMemberSpecialization()) {
10051 if (!S.hasVisibleMemberSpecialization(TD, &Modules))
10052 diagnose(TD->getMostRecentDecl(), false);
10053 }
10054 }
10055};
Benjamin Kramera0a13c32016-08-06 11:21:04 +000010056} // end anonymous namespace
Richard Smith6739a102016-05-05 00:56:12 +000010057
10058void Sema::checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec) {
10059 if (!getLangOpts().Modules)
10060 return;
10061
10062 ExplicitSpecializationVisibilityChecker(*this, Loc).check(Spec);
10063}
10064
Adrian Prantl9fc8faf2018-05-09 01:00:01 +000010065/// Check whether a template partial specialization that we've discovered
Richard Smith6739a102016-05-05 00:56:12 +000010066/// is hidden, and produce suitable diagnostics if so.
10067void Sema::checkPartialSpecializationVisibility(SourceLocation Loc,
10068 NamedDecl *Spec) {
10069 llvm::SmallVector<Module *, 8> Modules;
10070 if (!hasVisibleDeclaration(Spec, &Modules))
10071 diagnoseMissingImport(Loc, Spec, Spec->getLocation(), Modules,
10072 MissingImportKind::PartialSpecialization,
10073 /*Recover*/true);
10074}