1 //===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===/
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //===----------------------------------------------------------------------===/
9 // This file implements semantic analysis for C++ templates.
10 //===----------------------------------------------------------------------===/
12 #include "clang/Sema/SemaInternal.h"
13 #include "clang/Sema/Lookup.h"
14 #include "clang/Sema/Scope.h"
15 #include "clang/Sema/Template.h"
16 #include "clang/Sema/TemplateDeduction.h"
17 #include "TreeTransform.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/ExprCXX.h"
21 #include "clang/AST/DeclFriend.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/RecursiveASTVisitor.h"
24 #include "clang/AST/TypeVisitor.h"
25 #include "clang/Sema/DeclSpec.h"
26 #include "clang/Sema/ParsedTemplate.h"
27 #include "clang/Basic/LangOptions.h"
28 #include "clang/Basic/PartialDiagnostic.h"
29 #include "llvm/ADT/StringExtras.h"
30 using namespace clang
;
33 // Exported for use by Parser.
35 clang::getTemplateParamsRange(TemplateParameterList
const * const *Ps
,
37 if (!N
) return SourceRange();
38 return SourceRange(Ps
[0]->getTemplateLoc(), Ps
[N
-1]->getRAngleLoc());
41 /// \brief Determine whether the declaration found is acceptable as the name
42 /// of a template and, if so, return that template declaration. Otherwise,
44 static NamedDecl
*isAcceptableTemplateName(ASTContext
&Context
,
46 NamedDecl
*D
= Orig
->getUnderlyingDecl();
48 if (isa
<TemplateDecl
>(D
))
51 if (CXXRecordDecl
*Record
= dyn_cast
<CXXRecordDecl
>(D
)) {
52 // C++ [temp.local]p1:
53 // Like normal (non-template) classes, class templates have an
54 // injected-class-name (Clause 9). The injected-class-name
55 // can be used with or without a template-argument-list. When
56 // it is used without a template-argument-list, it is
57 // equivalent to the injected-class-name followed by the
58 // template-parameters of the class template enclosed in
59 // <>. When it is used with a template-argument-list, it
60 // refers to the specified class template specialization,
61 // which could be the current specialization or another
63 if (Record
->isInjectedClassName()) {
64 Record
= cast
<CXXRecordDecl
>(Record
->getDeclContext());
65 if (Record
->getDescribedClassTemplate())
66 return Record
->getDescribedClassTemplate();
68 if (ClassTemplateSpecializationDecl
*Spec
69 = dyn_cast
<ClassTemplateSpecializationDecl
>(Record
))
70 return Spec
->getSpecializedTemplate();
79 static void FilterAcceptableTemplateNames(ASTContext
&C
, LookupResult
&R
) {
80 // The set of class templates we've already seen.
81 llvm::SmallPtrSet
<ClassTemplateDecl
*, 8> ClassTemplates
;
82 LookupResult::Filter filter
= R
.makeFilter();
83 while (filter
.hasNext()) {
84 NamedDecl
*Orig
= filter
.next();
85 NamedDecl
*Repl
= isAcceptableTemplateName(C
, Orig
);
88 else if (Repl
!= Orig
) {
90 // C++ [temp.local]p3:
91 // A lookup that finds an injected-class-name (10.2) can result in an
92 // ambiguity in certain cases (for example, if it is found in more than
93 // one base class). If all of the injected-class-names that are found
94 // refer to specializations of the same class template, and if the name
95 // is followed by a template-argument-list, the reference refers to the
96 // class template itself and not a specialization thereof, and is not
99 // FIXME: Will we eventually have to do the same for alias templates?
100 if (ClassTemplateDecl
*ClassTmpl
= dyn_cast
<ClassTemplateDecl
>(Repl
))
101 if (!ClassTemplates
.insert(ClassTmpl
)) {
106 // FIXME: we promote access to public here as a workaround to
107 // the fact that LookupResult doesn't let us remember that we
108 // found this template through a particular injected class name,
109 // which means we end up doing nasty things to the invariants.
110 // Pretending that access is public is *much* safer.
111 filter
.replace(Repl
, AS_public
);
117 TemplateNameKind
Sema::isTemplateName(Scope
*S
,
119 bool hasTemplateKeyword
,
121 ParsedType ObjectTypePtr
,
122 bool EnteringContext
,
123 TemplateTy
&TemplateResult
,
124 bool &MemberOfUnknownSpecialization
) {
125 assert(getLangOptions().CPlusPlus
&& "No template names in C!");
127 DeclarationName TName
;
128 MemberOfUnknownSpecialization
= false;
130 switch (Name
.getKind()) {
131 case UnqualifiedId::IK_Identifier
:
132 TName
= DeclarationName(Name
.Identifier
);
135 case UnqualifiedId::IK_OperatorFunctionId
:
136 TName
= Context
.DeclarationNames
.getCXXOperatorName(
137 Name
.OperatorFunctionId
.Operator
);
140 case UnqualifiedId::IK_LiteralOperatorId
:
141 TName
= Context
.DeclarationNames
.getCXXLiteralOperatorName(Name
.Identifier
);
145 return TNK_Non_template
;
148 QualType ObjectType
= ObjectTypePtr
.get();
150 LookupResult
R(*this, TName
, Name
.getSourceRange().getBegin(),
152 LookupTemplateName(R
, S
, SS
, ObjectType
, EnteringContext
,
153 MemberOfUnknownSpecialization
);
154 if (R
.empty()) return TNK_Non_template
;
155 if (R
.isAmbiguous()) {
156 // Suppress diagnostics; we'll redo this lookup later.
157 R
.suppressDiagnostics();
159 // FIXME: we might have ambiguous templates, in which case we
160 // should at least parse them properly!
161 return TNK_Non_template
;
164 TemplateName Template
;
165 TemplateNameKind TemplateKind
;
167 unsigned ResultCount
= R
.end() - R
.begin();
168 if (ResultCount
> 1) {
169 // We assume that we'll preserve the qualifier from a function
170 // template name in other ways.
171 Template
= Context
.getOverloadedTemplateName(R
.begin(), R
.end());
172 TemplateKind
= TNK_Function_template
;
174 // We'll do this lookup again later.
175 R
.suppressDiagnostics();
177 TemplateDecl
*TD
= cast
<TemplateDecl
>((*R
.begin())->getUnderlyingDecl());
179 if (SS
.isSet() && !SS
.isInvalid()) {
180 NestedNameSpecifier
*Qualifier
181 = static_cast<NestedNameSpecifier
*>(SS
.getScopeRep());
182 Template
= Context
.getQualifiedTemplateName(Qualifier
,
183 hasTemplateKeyword
, TD
);
185 Template
= TemplateName(TD
);
188 if (isa
<FunctionTemplateDecl
>(TD
)) {
189 TemplateKind
= TNK_Function_template
;
191 // We'll do this lookup again later.
192 R
.suppressDiagnostics();
194 assert(isa
<ClassTemplateDecl
>(TD
) || isa
<TemplateTemplateParmDecl
>(TD
));
195 TemplateKind
= TNK_Type_template
;
199 TemplateResult
= TemplateTy::make(Template
);
203 bool Sema::DiagnoseUnknownTemplateName(const IdentifierInfo
&II
,
204 SourceLocation IILoc
,
206 const CXXScopeSpec
*SS
,
207 TemplateTy
&SuggestedTemplate
,
208 TemplateNameKind
&SuggestedKind
) {
209 // We can't recover unless there's a dependent scope specifier preceding the
211 // FIXME: Typo correction?
212 if (!SS
|| !SS
->isSet() || !isDependentScopeSpecifier(*SS
) ||
213 computeDeclContext(*SS
))
216 // The code is missing a 'template' keyword prior to the dependent template
218 NestedNameSpecifier
*Qualifier
= (NestedNameSpecifier
*)SS
->getScopeRep();
219 Diag(IILoc
, diag::err_template_kw_missing
)
220 << Qualifier
<< II
.getName()
221 << FixItHint::CreateInsertion(IILoc
, "template ");
223 = TemplateTy::make(Context
.getDependentTemplateName(Qualifier
, &II
));
224 SuggestedKind
= TNK_Dependent_template_name
;
228 void Sema::LookupTemplateName(LookupResult
&Found
,
229 Scope
*S
, CXXScopeSpec
&SS
,
231 bool EnteringContext
,
232 bool &MemberOfUnknownSpecialization
) {
233 // Determine where to perform name lookup
234 MemberOfUnknownSpecialization
= false;
235 DeclContext
*LookupCtx
= 0;
236 bool isDependent
= false;
237 if (!ObjectType
.isNull()) {
238 // This nested-name-specifier occurs in a member access expression, e.g.,
239 // x->B::f, and we are looking into the type of the object.
240 assert(!SS
.isSet() && "ObjectType and scope specifier cannot coexist");
241 LookupCtx
= computeDeclContext(ObjectType
);
242 isDependent
= ObjectType
->isDependentType();
243 assert((isDependent
|| !ObjectType
->isIncompleteType()) &&
244 "Caller should have completed object type");
245 } else if (SS
.isSet()) {
246 // This nested-name-specifier occurs after another nested-name-specifier,
247 // so long into the context associated with the prior nested-name-specifier.
248 LookupCtx
= computeDeclContext(SS
, EnteringContext
);
249 isDependent
= isDependentScopeSpecifier(SS
);
251 // The declaration context must be complete.
252 if (LookupCtx
&& RequireCompleteDeclContext(SS
, LookupCtx
))
256 bool ObjectTypeSearchedInScope
= false;
258 // Perform "qualified" name lookup into the declaration context we
259 // computed, which is either the type of the base of a member access
260 // expression or the declaration context associated with a prior
261 // nested-name-specifier.
262 LookupQualifiedName(Found
, LookupCtx
);
264 if (!ObjectType
.isNull() && Found
.empty()) {
265 // C++ [basic.lookup.classref]p1:
266 // In a class member access expression (5.2.5), if the . or -> token is
267 // immediately followed by an identifier followed by a <, the
268 // identifier must be looked up to determine whether the < is the
269 // beginning of a template argument list (14.2) or a less-than operator.
270 // The identifier is first looked up in the class of the object
271 // expression. If the identifier is not found, it is then looked up in
272 // the context of the entire postfix-expression and shall name a class
273 // or function template.
274 if (S
) LookupName(Found
, S
);
275 ObjectTypeSearchedInScope
= true;
277 } else if (isDependent
&& (!S
|| ObjectType
.isNull())) {
278 // We cannot look into a dependent object type or nested nme
280 MemberOfUnknownSpecialization
= true;
283 // Perform unqualified name lookup in the current scope.
284 LookupName(Found
, S
);
287 if (Found
.empty() && !isDependent
) {
288 // If we did not find any names, attempt to correct any typos.
289 DeclarationName Name
= Found
.getLookupName();
290 if (DeclarationName Corrected
= CorrectTypo(Found
, S
, &SS
, LookupCtx
,
291 false, CTC_CXXCasts
)) {
292 FilterAcceptableTemplateNames(Context
, Found
);
293 if (!Found
.empty()) {
295 Diag(Found
.getNameLoc(), diag::err_no_member_template_suggest
)
296 << Name
<< LookupCtx
<< Found
.getLookupName() << SS
.getRange()
297 << FixItHint::CreateReplacement(Found
.getNameLoc(),
298 Found
.getLookupName().getAsString());
300 Diag(Found
.getNameLoc(), diag::err_no_template_suggest
)
301 << Name
<< Found
.getLookupName()
302 << FixItHint::CreateReplacement(Found
.getNameLoc(),
303 Found
.getLookupName().getAsString());
304 if (TemplateDecl
*Template
= Found
.getAsSingle
<TemplateDecl
>())
305 Diag(Template
->getLocation(), diag::note_previous_decl
)
306 << Template
->getDeclName();
310 Found
.setLookupName(Name
);
314 FilterAcceptableTemplateNames(Context
, Found
);
317 MemberOfUnknownSpecialization
= true;
321 if (S
&& !ObjectType
.isNull() && !ObjectTypeSearchedInScope
) {
322 // C++ [basic.lookup.classref]p1:
323 // [...] If the lookup in the class of the object expression finds a
324 // template, the name is also looked up in the context of the entire
325 // postfix-expression and [...]
327 LookupResult
FoundOuter(*this, Found
.getLookupName(), Found
.getNameLoc(),
329 LookupName(FoundOuter
, S
);
330 FilterAcceptableTemplateNames(Context
, FoundOuter
);
332 if (FoundOuter
.empty()) {
333 // - if the name is not found, the name found in the class of the
334 // object expression is used, otherwise
335 } else if (!FoundOuter
.getAsSingle
<ClassTemplateDecl
>()) {
336 // - if the name is found in the context of the entire
337 // postfix-expression and does not name a class template, the name
338 // found in the class of the object expression is used, otherwise
339 } else if (!Found
.isSuppressingDiagnostics()) {
340 // - if the name found is a class template, it must refer to the same
341 // entity as the one found in the class of the object expression,
342 // otherwise the program is ill-formed.
343 if (!Found
.isSingleResult() ||
344 Found
.getFoundDecl()->getCanonicalDecl()
345 != FoundOuter
.getFoundDecl()->getCanonicalDecl()) {
346 Diag(Found
.getNameLoc(),
347 diag::ext_nested_name_member_ref_lookup_ambiguous
)
348 << Found
.getLookupName()
350 Diag(Found
.getRepresentativeDecl()->getLocation(),
351 diag::note_ambig_member_ref_object_type
)
353 Diag(FoundOuter
.getFoundDecl()->getLocation(),
354 diag::note_ambig_member_ref_scope
);
356 // Recover by taking the template that we found in the object
357 // expression's type.
363 /// ActOnDependentIdExpression - Handle a dependent id-expression that
364 /// was just parsed. This is only possible with an explicit scope
365 /// specifier naming a dependent type.
367 Sema::ActOnDependentIdExpression(const CXXScopeSpec
&SS
,
368 const DeclarationNameInfo
&NameInfo
,
369 bool isAddressOfOperand
,
370 const TemplateArgumentListInfo
*TemplateArgs
) {
371 NestedNameSpecifier
*Qualifier
372 = static_cast<NestedNameSpecifier
*>(SS
.getScopeRep());
374 DeclContext
*DC
= getFunctionLevelDeclContext();
376 if (!isAddressOfOperand
&&
377 isa
<CXXMethodDecl
>(DC
) &&
378 cast
<CXXMethodDecl
>(DC
)->isInstance()) {
379 QualType ThisType
= cast
<CXXMethodDecl
>(DC
)->getThisType(Context
);
381 // Since the 'this' expression is synthesized, we don't need to
382 // perform the double-lookup check.
383 NamedDecl
*FirstQualifierInScope
= 0;
385 return Owned(CXXDependentScopeMemberExpr::Create(Context
,
386 /*This*/ 0, ThisType
,
388 /*Op*/ SourceLocation(),
389 Qualifier
, SS
.getRange(),
390 FirstQualifierInScope
,
395 return BuildDependentDeclRefExpr(SS
, NameInfo
, TemplateArgs
);
399 Sema::BuildDependentDeclRefExpr(const CXXScopeSpec
&SS
,
400 const DeclarationNameInfo
&NameInfo
,
401 const TemplateArgumentListInfo
*TemplateArgs
) {
402 return Owned(DependentScopeDeclRefExpr::Create(Context
,
403 static_cast<NestedNameSpecifier
*>(SS
.getScopeRep()),
409 /// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining
410 /// that the template parameter 'PrevDecl' is being shadowed by a new
411 /// declaration at location Loc. Returns true to indicate that this is
412 /// an error, and false otherwise.
413 bool Sema::DiagnoseTemplateParameterShadow(SourceLocation Loc
, Decl
*PrevDecl
) {
414 assert(PrevDecl
->isTemplateParameter() && "Not a template parameter");
416 // Microsoft Visual C++ permits template parameters to be shadowed.
417 if (getLangOptions().Microsoft
)
420 // C++ [temp.local]p4:
421 // A template-parameter shall not be redeclared within its
422 // scope (including nested scopes).
423 Diag(Loc
, diag::err_template_param_shadow
)
424 << cast
<NamedDecl
>(PrevDecl
)->getDeclName();
425 Diag(PrevDecl
->getLocation(), diag::note_template_param_here
);
429 /// AdjustDeclIfTemplate - If the given decl happens to be a template, reset
430 /// the parameter D to reference the templated declaration and return a pointer
431 /// to the template declaration. Otherwise, do nothing to D and return null.
432 TemplateDecl
*Sema::AdjustDeclIfTemplate(Decl
*&D
) {
433 if (TemplateDecl
*Temp
= dyn_cast_or_null
<TemplateDecl
>(D
)) {
434 D
= Temp
->getTemplatedDecl();
440 ParsedTemplateArgument
ParsedTemplateArgument::getTemplatePackExpansion(
441 SourceLocation EllipsisLoc
) const {
442 assert(Kind
== Template
&&
443 "Only template template arguments can be pack expansions here");
444 assert(getAsTemplate().get().containsUnexpandedParameterPack() &&
445 "Template template argument pack expansion without packs");
446 ParsedTemplateArgument
Result(*this);
447 Result
.EllipsisLoc
= EllipsisLoc
;
451 static TemplateArgumentLoc
translateTemplateArgument(Sema
&SemaRef
,
452 const ParsedTemplateArgument
&Arg
) {
454 switch (Arg
.getKind()) {
455 case ParsedTemplateArgument::Type
: {
457 QualType T
= SemaRef
.GetTypeFromParser(Arg
.getAsType(), &DI
);
459 DI
= SemaRef
.Context
.getTrivialTypeSourceInfo(T
, Arg
.getLocation());
460 return TemplateArgumentLoc(TemplateArgument(T
), DI
);
463 case ParsedTemplateArgument::NonType
: {
464 Expr
*E
= static_cast<Expr
*>(Arg
.getAsExpr());
465 return TemplateArgumentLoc(TemplateArgument(E
), E
);
468 case ParsedTemplateArgument::Template
: {
469 TemplateName Template
= Arg
.getAsTemplate().get();
470 return TemplateArgumentLoc(TemplateArgument(Template
,
471 Arg
.getEllipsisLoc().isValid()),
472 Arg
.getScopeSpec().getRange(),
474 Arg
.getEllipsisLoc());
478 llvm_unreachable("Unhandled parsed template argument");
479 return TemplateArgumentLoc();
482 /// \brief Translates template arguments as provided by the parser
483 /// into template arguments used by semantic analysis.
484 void Sema::translateTemplateArguments(const ASTTemplateArgsPtr
&TemplateArgsIn
,
485 TemplateArgumentListInfo
&TemplateArgs
) {
486 for (unsigned I
= 0, Last
= TemplateArgsIn
.size(); I
!= Last
; ++I
)
487 TemplateArgs
.addArgument(translateTemplateArgument(*this,
491 /// ActOnTypeParameter - Called when a C++ template type parameter
492 /// (e.g., "typename T") has been parsed. Typename specifies whether
493 /// the keyword "typename" was used to declare the type parameter
494 /// (otherwise, "class" was used), and KeyLoc is the location of the
495 /// "class" or "typename" keyword. ParamName is the name of the
496 /// parameter (NULL indicates an unnamed template parameter) and
497 /// ParamName is the location of the parameter name (if any).
498 /// If the type parameter has a default argument, it will be added
499 /// later via ActOnTypeParameterDefault.
500 Decl
*Sema::ActOnTypeParameter(Scope
*S
, bool Typename
, bool Ellipsis
,
501 SourceLocation EllipsisLoc
,
502 SourceLocation KeyLoc
,
503 IdentifierInfo
*ParamName
,
504 SourceLocation ParamNameLoc
,
505 unsigned Depth
, unsigned Position
,
506 SourceLocation EqualLoc
,
507 ParsedType DefaultArg
) {
508 assert(S
->isTemplateParamScope() &&
509 "Template type parameter not in template parameter scope!");
510 bool Invalid
= false;
513 NamedDecl
*PrevDecl
= LookupSingleName(S
, ParamName
, ParamNameLoc
,
516 if (PrevDecl
&& PrevDecl
->isTemplateParameter())
517 Invalid
= Invalid
|| DiagnoseTemplateParameterShadow(ParamNameLoc
,
521 SourceLocation Loc
= ParamNameLoc
;
525 TemplateTypeParmDecl
*Param
526 = TemplateTypeParmDecl::Create(Context
, Context
.getTranslationUnitDecl(),
527 Loc
, Depth
, Position
, ParamName
, Typename
,
530 Param
->setInvalidDecl();
533 // Add the template parameter into the current scope.
535 IdResolver
.AddDecl(Param
);
538 // C++0x [temp.param]p9:
539 // A default template-argument may be specified for any kind of
540 // template-parameter that is not a template parameter pack.
541 if (DefaultArg
&& Ellipsis
) {
542 Diag(EqualLoc
, diag::err_template_param_pack_default_arg
);
543 DefaultArg
= ParsedType();
546 // Handle the default argument, if provided.
548 TypeSourceInfo
*DefaultTInfo
;
549 GetTypeFromParser(DefaultArg
, &DefaultTInfo
);
551 assert(DefaultTInfo
&& "expected source information for type");
553 // Check for unexpanded parameter packs.
554 if (DiagnoseUnexpandedParameterPack(Loc
, DefaultTInfo
,
555 UPPC_DefaultArgument
))
558 // Check the template argument itself.
559 if (CheckTemplateArgument(Param
, DefaultTInfo
)) {
560 Param
->setInvalidDecl();
564 Param
->setDefaultArgument(DefaultTInfo
, false);
570 /// \brief Check that the type of a non-type template parameter is
573 /// \returns the (possibly-promoted) parameter type if valid;
574 /// otherwise, produces a diagnostic and returns a NULL type.
576 Sema::CheckNonTypeTemplateParameterType(QualType T
, SourceLocation Loc
) {
577 // We don't allow variably-modified types as the type of non-type template
579 if (T
->isVariablyModifiedType()) {
580 Diag(Loc
, diag::err_variably_modified_nontype_template_param
)
585 // C++ [temp.param]p4:
587 // A non-type template-parameter shall have one of the following
588 // (optionally cv-qualified) types:
590 // -- integral or enumeration type,
591 if (T
->isIntegralOrEnumerationType() ||
592 // -- pointer to object or pointer to function,
593 T
->isPointerType() ||
594 // -- reference to object or reference to function,
595 T
->isReferenceType() ||
596 // -- pointer to member.
597 T
->isMemberPointerType() ||
598 // If T is a dependent type, we can't do the check now, so we
599 // assume that it is well-formed.
600 T
->isDependentType())
602 // C++ [temp.param]p8:
604 // A non-type template-parameter of type "array of T" or
605 // "function returning T" is adjusted to be of type "pointer to
606 // T" or "pointer to function returning T", respectively.
607 else if (T
->isArrayType())
608 // FIXME: Keep the type prior to promotion?
609 return Context
.getArrayDecayedType(T
);
610 else if (T
->isFunctionType())
611 // FIXME: Keep the type prior to promotion?
612 return Context
.getPointerType(T
);
614 Diag(Loc
, diag::err_template_nontype_parm_bad_type
)
620 Decl
*Sema::ActOnNonTypeTemplateParameter(Scope
*S
, Declarator
&D
,
623 SourceLocation EqualLoc
,
625 TypeSourceInfo
*TInfo
= GetTypeForDeclarator(D
, S
);
626 QualType T
= TInfo
->getType();
628 assert(S
->isTemplateParamScope() &&
629 "Non-type template parameter not in template parameter scope!");
630 bool Invalid
= false;
632 IdentifierInfo
*ParamName
= D
.getIdentifier();
634 NamedDecl
*PrevDecl
= LookupSingleName(S
, ParamName
, D
.getIdentifierLoc(),
637 if (PrevDecl
&& PrevDecl
->isTemplateParameter())
638 Invalid
= Invalid
|| DiagnoseTemplateParameterShadow(D
.getIdentifierLoc(),
642 T
= CheckNonTypeTemplateParameterType(T
, D
.getIdentifierLoc());
644 T
= Context
.IntTy
; // Recover with an 'int' type.
648 bool IsParameterPack
= D
.hasEllipsis();
649 NonTypeTemplateParmDecl
*Param
650 = NonTypeTemplateParmDecl::Create(Context
, Context
.getTranslationUnitDecl(),
651 D
.getIdentifierLoc(),
652 Depth
, Position
, ParamName
, T
,
653 IsParameterPack
, TInfo
);
655 Param
->setInvalidDecl();
657 if (D
.getIdentifier()) {
658 // Add the template parameter into the current scope.
660 IdResolver
.AddDecl(Param
);
663 // C++0x [temp.param]p9:
664 // A default template-argument may be specified for any kind of
665 // template-parameter that is not a template parameter pack.
666 if (Default
&& IsParameterPack
) {
667 Diag(EqualLoc
, diag::err_template_param_pack_default_arg
);
671 // Check the well-formedness of the default template argument, if provided.
673 // Check for unexpanded parameter packs.
674 if (DiagnoseUnexpandedParameterPack(Default
, UPPC_DefaultArgument
))
677 TemplateArgument Converted
;
678 if (CheckTemplateArgument(Param
, Param
->getType(), Default
, Converted
)) {
679 Param
->setInvalidDecl();
683 Param
->setDefaultArgument(Default
, false);
689 /// ActOnTemplateTemplateParameter - Called when a C++ template template
690 /// parameter (e.g. T in template <template <typename> class T> class array)
691 /// has been parsed. S is the current scope.
692 Decl
*Sema::ActOnTemplateTemplateParameter(Scope
* S
,
693 SourceLocation TmpLoc
,
694 TemplateParamsTy
*Params
,
695 SourceLocation EllipsisLoc
,
696 IdentifierInfo
*Name
,
697 SourceLocation NameLoc
,
700 SourceLocation EqualLoc
,
701 ParsedTemplateArgument Default
) {
702 assert(S
->isTemplateParamScope() &&
703 "Template template parameter not in template parameter scope!");
705 // Construct the parameter object.
706 bool IsParameterPack
= EllipsisLoc
.isValid();
707 // FIXME: Pack-ness is dropped
708 TemplateTemplateParmDecl
*Param
=
709 TemplateTemplateParmDecl::Create(Context
, Context
.getTranslationUnitDecl(),
710 NameLoc
.isInvalid()? TmpLoc
: NameLoc
,
711 Depth
, Position
, IsParameterPack
,
714 // If the template template parameter has a name, then link the identifier
715 // into the scope and lookup mechanisms.
718 IdResolver
.AddDecl(Param
);
721 if (Params
->size() == 0) {
722 Diag(Param
->getLocation(), diag::err_template_template_parm_no_parms
)
723 << SourceRange(Params
->getLAngleLoc(), Params
->getRAngleLoc());
724 Param
->setInvalidDecl();
727 // C++0x [temp.param]p9:
728 // A default template-argument may be specified for any kind of
729 // template-parameter that is not a template parameter pack.
730 if (IsParameterPack
&& !Default
.isInvalid()) {
731 Diag(EqualLoc
, diag::err_template_param_pack_default_arg
);
732 Default
= ParsedTemplateArgument();
735 if (!Default
.isInvalid()) {
736 // Check only that we have a template template argument. We don't want to
737 // try to check well-formedness now, because our template template parameter
738 // might have dependent types in its template parameters, which we wouldn't
739 // be able to match now.
741 // If none of the template template parameter's template arguments mention
742 // other template parameters, we could actually perform more checking here.
743 // However, it isn't worth doing.
744 TemplateArgumentLoc DefaultArg
= translateTemplateArgument(*this, Default
);
745 if (DefaultArg
.getArgument().getAsTemplate().isNull()) {
746 Diag(DefaultArg
.getLocation(), diag::err_template_arg_not_class_template
)
747 << DefaultArg
.getSourceRange();
751 // Check for unexpanded parameter packs.
752 if (DiagnoseUnexpandedParameterPack(DefaultArg
.getLocation(),
753 DefaultArg
.getArgument().getAsTemplate(),
754 UPPC_DefaultArgument
))
757 Param
->setDefaultArgument(DefaultArg
, false);
763 /// ActOnTemplateParameterList - Builds a TemplateParameterList that
764 /// contains the template parameters in Params/NumParams.
765 Sema::TemplateParamsTy
*
766 Sema::ActOnTemplateParameterList(unsigned Depth
,
767 SourceLocation ExportLoc
,
768 SourceLocation TemplateLoc
,
769 SourceLocation LAngleLoc
,
770 Decl
**Params
, unsigned NumParams
,
771 SourceLocation RAngleLoc
) {
772 if (ExportLoc
.isValid())
773 Diag(ExportLoc
, diag::warn_template_export_unsupported
);
775 return TemplateParameterList::Create(Context
, TemplateLoc
, LAngleLoc
,
776 (NamedDecl
**)Params
, NumParams
,
780 static void SetNestedNameSpecifier(TagDecl
*T
, const CXXScopeSpec
&SS
) {
782 T
->setQualifierInfo(static_cast<NestedNameSpecifier
*>(SS
.getScopeRep()),
787 Sema::CheckClassTemplate(Scope
*S
, unsigned TagSpec
, TagUseKind TUK
,
788 SourceLocation KWLoc
, CXXScopeSpec
&SS
,
789 IdentifierInfo
*Name
, SourceLocation NameLoc
,
791 TemplateParameterList
*TemplateParams
,
792 AccessSpecifier AS
) {
793 assert(TemplateParams
&& TemplateParams
->size() > 0 &&
794 "No template parameters");
795 assert(TUK
!= TUK_Reference
&& "Can only declare or define class templates");
796 bool Invalid
= false;
798 // Check that we can declare a template here.
799 if (CheckTemplateDeclScope(S
, TemplateParams
))
802 TagTypeKind Kind
= TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec
);
803 assert(Kind
!= TTK_Enum
&& "can't build template of enumerated type");
805 // There is no such thing as an unnamed class template.
807 Diag(KWLoc
, diag::err_template_unnamed_class
);
811 // Find any previous declaration with this name.
812 DeclContext
*SemanticContext
;
813 LookupResult
Previous(*this, Name
, NameLoc
, LookupOrdinaryName
,
815 if (SS
.isNotEmpty() && !SS
.isInvalid()) {
816 SemanticContext
= computeDeclContext(SS
, true);
817 if (!SemanticContext
) {
818 // FIXME: Produce a reasonable diagnostic here
822 if (RequireCompleteDeclContext(SS
, SemanticContext
))
825 LookupQualifiedName(Previous
, SemanticContext
);
827 SemanticContext
= CurContext
;
828 LookupName(Previous
, S
);
831 if (Previous
.isAmbiguous())
834 NamedDecl
*PrevDecl
= 0;
835 if (Previous
.begin() != Previous
.end())
836 PrevDecl
= (*Previous
.begin())->getUnderlyingDecl();
838 // If there is a previous declaration with the same name, check
839 // whether this is a valid redeclaration.
840 ClassTemplateDecl
*PrevClassTemplate
841 = dyn_cast_or_null
<ClassTemplateDecl
>(PrevDecl
);
843 // We may have found the injected-class-name of a class template,
844 // class template partial specialization, or class template specialization.
845 // In these cases, grab the template that is being defined or specialized.
846 if (!PrevClassTemplate
&& PrevDecl
&& isa
<CXXRecordDecl
>(PrevDecl
) &&
847 cast
<CXXRecordDecl
>(PrevDecl
)->isInjectedClassName()) {
848 PrevDecl
= cast
<CXXRecordDecl
>(PrevDecl
->getDeclContext());
850 = cast
<CXXRecordDecl
>(PrevDecl
)->getDescribedClassTemplate();
851 if (!PrevClassTemplate
&& isa
<ClassTemplateSpecializationDecl
>(PrevDecl
)) {
853 = cast
<ClassTemplateSpecializationDecl
>(PrevDecl
)
854 ->getSpecializedTemplate();
858 if (TUK
== TUK_Friend
) {
859 // C++ [namespace.memdef]p3:
860 // [...] When looking for a prior declaration of a class or a function
861 // declared as a friend, and when the name of the friend class or
862 // function is neither a qualified name nor a template-id, scopes outside
863 // the innermost enclosing namespace scope are not considered.
865 DeclContext
*OutermostContext
= CurContext
;
866 while (!OutermostContext
->isFileContext())
867 OutermostContext
= OutermostContext
->getLookupParent();
870 (OutermostContext
->Equals(PrevDecl
->getDeclContext()) ||
871 OutermostContext
->Encloses(PrevDecl
->getDeclContext()))) {
872 SemanticContext
= PrevDecl
->getDeclContext();
874 // Declarations in outer scopes don't matter. However, the outermost
875 // context we computed is the semantic context for our new
877 PrevDecl
= PrevClassTemplate
= 0;
878 SemanticContext
= OutermostContext
;
882 if (CurContext
->isDependentContext()) {
883 // If this is a dependent context, we don't want to link the friend
884 // class template to the template in scope, because that would perform
885 // checking of the template parameter lists that can't be performed
886 // until the outer context is instantiated.
887 PrevDecl
= PrevClassTemplate
= 0;
889 } else if (PrevDecl
&& !isDeclInScope(PrevDecl
, SemanticContext
, S
))
890 PrevDecl
= PrevClassTemplate
= 0;
892 if (PrevClassTemplate
) {
893 // Ensure that the template parameter lists are compatible.
894 if (!TemplateParameterListsAreEqual(TemplateParams
,
895 PrevClassTemplate
->getTemplateParameters(),
900 // C++ [temp.class]p4:
901 // In a redeclaration, partial specialization, explicit
902 // specialization or explicit instantiation of a class template,
903 // the class-key shall agree in kind with the original class
904 // template declaration (7.1.5.3).
905 RecordDecl
*PrevRecordDecl
= PrevClassTemplate
->getTemplatedDecl();
906 if (!isAcceptableTagRedeclaration(PrevRecordDecl
, Kind
, KWLoc
, *Name
)) {
907 Diag(KWLoc
, diag::err_use_with_wrong_tag
)
909 << FixItHint::CreateReplacement(KWLoc
, PrevRecordDecl
->getKindName());
910 Diag(PrevRecordDecl
->getLocation(), diag::note_previous_use
);
911 Kind
= PrevRecordDecl
->getTagKind();
914 // Check for redefinition of this class template.
915 if (TUK
== TUK_Definition
) {
916 if (TagDecl
*Def
= PrevRecordDecl
->getDefinition()) {
917 Diag(NameLoc
, diag::err_redefinition
) << Name
;
918 Diag(Def
->getLocation(), diag::note_previous_definition
);
919 // FIXME: Would it make sense to try to "forget" the previous
920 // definition, as part of error recovery?
924 } else if (PrevDecl
&& PrevDecl
->isTemplateParameter()) {
925 // Maybe we will complain about the shadowed template parameter.
926 DiagnoseTemplateParameterShadow(NameLoc
, PrevDecl
);
927 // Just pretend that we didn't see the previous declaration.
929 } else if (PrevDecl
) {
931 // A class template shall not have the same name as any other
932 // template, class, function, object, enumeration, enumerator,
933 // namespace, or type in the same scope (3.3), except as specified
935 Diag(NameLoc
, diag::err_redefinition_different_kind
) << Name
;
936 Diag(PrevDecl
->getLocation(), diag::note_previous_definition
);
940 // Check the template parameter list of this declaration, possibly
941 // merging in the template parameter list from the previous class
942 // template declaration.
943 if (CheckTemplateParameterList(TemplateParams
,
944 PrevClassTemplate
? PrevClassTemplate
->getTemplateParameters() : 0,
949 // If the name of the template was qualified, we must be defining the
950 // template out-of-line.
951 if (!SS
.isInvalid() && !Invalid
&& !PrevClassTemplate
&&
952 !(TUK
== TUK_Friend
&& CurContext
->isDependentContext()))
953 Diag(NameLoc
, diag::err_member_def_does_not_match
)
954 << Name
<< SemanticContext
<< SS
.getRange();
957 CXXRecordDecl
*NewClass
=
958 CXXRecordDecl::Create(Context
, Kind
, SemanticContext
, NameLoc
, Name
, KWLoc
,
960 PrevClassTemplate
->getTemplatedDecl() : 0,
961 /*DelayTypeCreation=*/true);
962 SetNestedNameSpecifier(NewClass
, SS
);
964 ClassTemplateDecl
*NewTemplate
965 = ClassTemplateDecl::Create(Context
, SemanticContext
, NameLoc
,
966 DeclarationName(Name
), TemplateParams
,
967 NewClass
, PrevClassTemplate
);
968 NewClass
->setDescribedClassTemplate(NewTemplate
);
970 // Build the type for the class template declaration now.
971 QualType T
= NewTemplate
->getInjectedClassNameSpecialization();
972 T
= Context
.getInjectedClassNameType(NewClass
, T
);
973 assert(T
->isDependentType() && "Class template type is not dependent?");
976 // If we are providing an explicit specialization of a member that is a
977 // class template, make a note of that.
978 if (PrevClassTemplate
&&
979 PrevClassTemplate
->getInstantiatedFromMemberTemplate())
980 PrevClassTemplate
->setMemberSpecialization();
982 // Set the access specifier.
983 if (!Invalid
&& TUK
!= TUK_Friend
)
984 SetMemberAccessSpecifier(NewTemplate
, PrevClassTemplate
, AS
);
986 // Set the lexical context of these templates
987 NewClass
->setLexicalDeclContext(CurContext
);
988 NewTemplate
->setLexicalDeclContext(CurContext
);
990 if (TUK
== TUK_Definition
)
991 NewClass
->startDefinition();
994 ProcessDeclAttributeList(S
, NewClass
, Attr
);
996 if (TUK
!= TUK_Friend
)
997 PushOnScopeChains(NewTemplate
, S
);
999 if (PrevClassTemplate
&& PrevClassTemplate
->getAccess() != AS_none
) {
1000 NewTemplate
->setAccess(PrevClassTemplate
->getAccess());
1001 NewClass
->setAccess(PrevClassTemplate
->getAccess());
1004 NewTemplate
->setObjectOfFriendDecl(/* PreviouslyDeclared = */
1005 PrevClassTemplate
!= NULL
);
1007 // Friend templates are visible in fairly strange ways.
1008 if (!CurContext
->isDependentContext()) {
1009 DeclContext
*DC
= SemanticContext
->getRedeclContext();
1010 DC
->makeDeclVisibleInContext(NewTemplate
, /* Recoverable = */ false);
1011 if (Scope
*EnclosingScope
= getScopeForDeclContext(S
, DC
))
1012 PushOnScopeChains(NewTemplate
, EnclosingScope
,
1013 /* AddToContext = */ false);
1016 FriendDecl
*Friend
= FriendDecl::Create(Context
, CurContext
,
1017 NewClass
->getLocation(),
1019 /*FIXME:*/NewClass
->getLocation());
1020 Friend
->setAccess(AS_public
);
1021 CurContext
->addDecl(Friend
);
1025 NewTemplate
->setInvalidDecl();
1026 NewClass
->setInvalidDecl();
1031 /// \brief Diagnose the presence of a default template argument on a
1032 /// template parameter, which is ill-formed in certain contexts.
1034 /// \returns true if the default template argument should be dropped.
1035 static bool DiagnoseDefaultTemplateArgument(Sema
&S
,
1036 Sema::TemplateParamListContext TPC
,
1037 SourceLocation ParamLoc
,
1038 SourceRange DefArgRange
) {
1040 case Sema::TPC_ClassTemplate
:
1043 case Sema::TPC_FunctionTemplate
:
1044 // C++ [temp.param]p9:
1045 // A default template-argument shall not be specified in a
1046 // function template declaration or a function template
1048 // (This sentence is not in C++0x, per DR226).
1049 if (!S
.getLangOptions().CPlusPlus0x
)
1051 diag::err_template_parameter_default_in_function_template
)
1055 case Sema::TPC_ClassTemplateMember
:
1056 // C++0x [temp.param]p9:
1057 // A default template-argument shall not be specified in the
1058 // template-parameter-lists of the definition of a member of a
1059 // class template that appears outside of the member's class.
1060 S
.Diag(ParamLoc
, diag::err_template_parameter_default_template_member
)
1064 case Sema::TPC_FriendFunctionTemplate
:
1065 // C++ [temp.param]p9:
1066 // A default template-argument shall not be specified in a
1067 // friend template declaration.
1068 S
.Diag(ParamLoc
, diag::err_template_parameter_default_friend_template
)
1072 // FIXME: C++0x [temp.param]p9 allows default template-arguments
1073 // for friend function templates if there is only a single
1074 // declaration (and it is a definition). Strange!
1080 /// \brief Check for unexpanded parameter packs within the template parameters
1081 /// of a template template parameter, recursively.
1082 bool DiagnoseUnexpandedParameterPacks(Sema
&S
, TemplateTemplateParmDecl
*TTP
){
1083 TemplateParameterList
*Params
= TTP
->getTemplateParameters();
1084 for (unsigned I
= 0, N
= Params
->size(); I
!= N
; ++I
) {
1085 NamedDecl
*P
= Params
->getParam(I
);
1086 if (NonTypeTemplateParmDecl
*NTTP
= dyn_cast
<NonTypeTemplateParmDecl
>(P
)) {
1087 if (S
.DiagnoseUnexpandedParameterPack(NTTP
->getLocation(),
1088 NTTP
->getTypeSourceInfo(),
1089 Sema::UPPC_NonTypeTemplateParameterType
))
1095 if (TemplateTemplateParmDecl
*InnerTTP
1096 = dyn_cast
<TemplateTemplateParmDecl
>(P
))
1097 if (DiagnoseUnexpandedParameterPacks(S
, InnerTTP
))
1104 /// \brief Checks the validity of a template parameter list, possibly
1105 /// considering the template parameter list from a previous
1108 /// If an "old" template parameter list is provided, it must be
1109 /// equivalent (per TemplateParameterListsAreEqual) to the "new"
1110 /// template parameter list.
1112 /// \param NewParams Template parameter list for a new template
1113 /// declaration. This template parameter list will be updated with any
1114 /// default arguments that are carried through from the previous
1115 /// template parameter list.
1117 /// \param OldParams If provided, template parameter list from a
1118 /// previous declaration of the same template. Default template
1119 /// arguments will be merged from the old template parameter list to
1120 /// the new template parameter list.
1122 /// \param TPC Describes the context in which we are checking the given
1123 /// template parameter list.
1125 /// \returns true if an error occurred, false otherwise.
1126 bool Sema::CheckTemplateParameterList(TemplateParameterList
*NewParams
,
1127 TemplateParameterList
*OldParams
,
1128 TemplateParamListContext TPC
) {
1129 bool Invalid
= false;
1131 // C++ [temp.param]p10:
1132 // The set of default template-arguments available for use with a
1133 // template declaration or definition is obtained by merging the
1134 // default arguments from the definition (if in scope) and all
1135 // declarations in scope in the same way default function
1136 // arguments are (8.3.6).
1137 bool SawDefaultArgument
= false;
1138 SourceLocation PreviousDefaultArgLoc
;
1140 bool SawParameterPack
= false;
1141 SourceLocation ParameterPackLoc
;
1143 // Dummy initialization to avoid warnings.
1144 TemplateParameterList::iterator OldParam
= NewParams
->end();
1146 OldParam
= OldParams
->begin();
1148 for (TemplateParameterList::iterator NewParam
= NewParams
->begin(),
1149 NewParamEnd
= NewParams
->end();
1150 NewParam
!= NewParamEnd
; ++NewParam
) {
1151 // Variables used to diagnose redundant default arguments
1152 bool RedundantDefaultArg
= false;
1153 SourceLocation OldDefaultLoc
;
1154 SourceLocation NewDefaultLoc
;
1156 // Variables used to diagnose missing default arguments
1157 bool MissingDefaultArg
= false;
1159 // C++0x [temp.param]p11:
1160 // If a template parameter of a primary class template is a template
1161 // parameter pack, it shall be the last template parameter.
1162 if (SawParameterPack
&& TPC
== TPC_ClassTemplate
) {
1163 Diag(ParameterPackLoc
,
1164 diag::err_template_param_pack_must_be_last_template_parameter
);
1168 if (TemplateTypeParmDecl
*NewTypeParm
1169 = dyn_cast
<TemplateTypeParmDecl
>(*NewParam
)) {
1170 // Check the presence of a default argument here.
1171 if (NewTypeParm
->hasDefaultArgument() &&
1172 DiagnoseDefaultTemplateArgument(*this, TPC
,
1173 NewTypeParm
->getLocation(),
1174 NewTypeParm
->getDefaultArgumentInfo()->getTypeLoc()
1176 NewTypeParm
->removeDefaultArgument();
1178 // Merge default arguments for template type parameters.
1179 TemplateTypeParmDecl
*OldTypeParm
1180 = OldParams
? cast
<TemplateTypeParmDecl
>(*OldParam
) : 0;
1182 if (NewTypeParm
->isParameterPack()) {
1183 assert(!NewTypeParm
->hasDefaultArgument() &&
1184 "Parameter packs can't have a default argument!");
1185 SawParameterPack
= true;
1186 ParameterPackLoc
= NewTypeParm
->getLocation();
1187 } else if (OldTypeParm
&& OldTypeParm
->hasDefaultArgument() &&
1188 NewTypeParm
->hasDefaultArgument()) {
1189 OldDefaultLoc
= OldTypeParm
->getDefaultArgumentLoc();
1190 NewDefaultLoc
= NewTypeParm
->getDefaultArgumentLoc();
1191 SawDefaultArgument
= true;
1192 RedundantDefaultArg
= true;
1193 PreviousDefaultArgLoc
= NewDefaultLoc
;
1194 } else if (OldTypeParm
&& OldTypeParm
->hasDefaultArgument()) {
1195 // Merge the default argument from the old declaration to the
1197 SawDefaultArgument
= true;
1198 NewTypeParm
->setDefaultArgument(OldTypeParm
->getDefaultArgumentInfo(),
1200 PreviousDefaultArgLoc
= OldTypeParm
->getDefaultArgumentLoc();
1201 } else if (NewTypeParm
->hasDefaultArgument()) {
1202 SawDefaultArgument
= true;
1203 PreviousDefaultArgLoc
= NewTypeParm
->getDefaultArgumentLoc();
1204 } else if (SawDefaultArgument
)
1205 MissingDefaultArg
= true;
1206 } else if (NonTypeTemplateParmDecl
*NewNonTypeParm
1207 = dyn_cast
<NonTypeTemplateParmDecl
>(*NewParam
)) {
1208 // Check for unexpanded parameter packs.
1209 if (DiagnoseUnexpandedParameterPack(NewNonTypeParm
->getLocation(),
1210 NewNonTypeParm
->getTypeSourceInfo(),
1211 UPPC_NonTypeTemplateParameterType
)) {
1216 // Check the presence of a default argument here.
1217 if (NewNonTypeParm
->hasDefaultArgument() &&
1218 DiagnoseDefaultTemplateArgument(*this, TPC
,
1219 NewNonTypeParm
->getLocation(),
1220 NewNonTypeParm
->getDefaultArgument()->getSourceRange())) {
1221 NewNonTypeParm
->removeDefaultArgument();
1224 // Merge default arguments for non-type template parameters
1225 NonTypeTemplateParmDecl
*OldNonTypeParm
1226 = OldParams
? cast
<NonTypeTemplateParmDecl
>(*OldParam
) : 0;
1227 if (NewNonTypeParm
->isParameterPack()) {
1228 assert(!NewNonTypeParm
->hasDefaultArgument() &&
1229 "Parameter packs can't have a default argument!");
1230 SawParameterPack
= true;
1231 ParameterPackLoc
= NewNonTypeParm
->getLocation();
1232 } else if (OldNonTypeParm
&& OldNonTypeParm
->hasDefaultArgument() &&
1233 NewNonTypeParm
->hasDefaultArgument()) {
1234 OldDefaultLoc
= OldNonTypeParm
->getDefaultArgumentLoc();
1235 NewDefaultLoc
= NewNonTypeParm
->getDefaultArgumentLoc();
1236 SawDefaultArgument
= true;
1237 RedundantDefaultArg
= true;
1238 PreviousDefaultArgLoc
= NewDefaultLoc
;
1239 } else if (OldNonTypeParm
&& OldNonTypeParm
->hasDefaultArgument()) {
1240 // Merge the default argument from the old declaration to the
1242 SawDefaultArgument
= true;
1243 // FIXME: We need to create a new kind of "default argument"
1244 // expression that points to a previous non-type template
1246 NewNonTypeParm
->setDefaultArgument(
1247 OldNonTypeParm
->getDefaultArgument(),
1248 /*Inherited=*/ true);
1249 PreviousDefaultArgLoc
= OldNonTypeParm
->getDefaultArgumentLoc();
1250 } else if (NewNonTypeParm
->hasDefaultArgument()) {
1251 SawDefaultArgument
= true;
1252 PreviousDefaultArgLoc
= NewNonTypeParm
->getDefaultArgumentLoc();
1253 } else if (SawDefaultArgument
)
1254 MissingDefaultArg
= true;
1256 // Check the presence of a default argument here.
1257 TemplateTemplateParmDecl
*NewTemplateParm
1258 = cast
<TemplateTemplateParmDecl
>(*NewParam
);
1260 // Check for unexpanded parameter packs, recursively.
1261 if (DiagnoseUnexpandedParameterPacks(*this, NewTemplateParm
)) {
1266 if (NewTemplateParm
->hasDefaultArgument() &&
1267 DiagnoseDefaultTemplateArgument(*this, TPC
,
1268 NewTemplateParm
->getLocation(),
1269 NewTemplateParm
->getDefaultArgument().getSourceRange()))
1270 NewTemplateParm
->removeDefaultArgument();
1272 // Merge default arguments for template template parameters
1273 TemplateTemplateParmDecl
*OldTemplateParm
1274 = OldParams
? cast
<TemplateTemplateParmDecl
>(*OldParam
) : 0;
1275 if (NewTemplateParm
->isParameterPack()) {
1276 assert(!NewTemplateParm
->hasDefaultArgument() &&
1277 "Parameter packs can't have a default argument!");
1278 SawParameterPack
= true;
1279 ParameterPackLoc
= NewTemplateParm
->getLocation();
1280 } else if (OldTemplateParm
&& OldTemplateParm
->hasDefaultArgument() &&
1281 NewTemplateParm
->hasDefaultArgument()) {
1282 OldDefaultLoc
= OldTemplateParm
->getDefaultArgument().getLocation();
1283 NewDefaultLoc
= NewTemplateParm
->getDefaultArgument().getLocation();
1284 SawDefaultArgument
= true;
1285 RedundantDefaultArg
= true;
1286 PreviousDefaultArgLoc
= NewDefaultLoc
;
1287 } else if (OldTemplateParm
&& OldTemplateParm
->hasDefaultArgument()) {
1288 // Merge the default argument from the old declaration to the
1290 SawDefaultArgument
= true;
1291 // FIXME: We need to create a new kind of "default argument" expression
1292 // that points to a previous template template parameter.
1293 NewTemplateParm
->setDefaultArgument(
1294 OldTemplateParm
->getDefaultArgument(),
1295 /*Inherited=*/ true);
1296 PreviousDefaultArgLoc
1297 = OldTemplateParm
->getDefaultArgument().getLocation();
1298 } else if (NewTemplateParm
->hasDefaultArgument()) {
1299 SawDefaultArgument
= true;
1300 PreviousDefaultArgLoc
1301 = NewTemplateParm
->getDefaultArgument().getLocation();
1302 } else if (SawDefaultArgument
)
1303 MissingDefaultArg
= true;
1306 if (RedundantDefaultArg
) {
1307 // C++ [temp.param]p12:
1308 // A template-parameter shall not be given default arguments
1309 // by two different declarations in the same scope.
1310 Diag(NewDefaultLoc
, diag::err_template_param_default_arg_redefinition
);
1311 Diag(OldDefaultLoc
, diag::note_template_param_prev_default_arg
);
1313 } else if (MissingDefaultArg
) {
1314 // C++ [temp.param]p11:
1315 // If a template-parameter of a class template has a default
1316 // template-argument, each subsequent template- parameter shall either
1317 // have a default template-argument supplied or be a template parameter
1319 Diag((*NewParam
)->getLocation(),
1320 diag::err_template_param_default_arg_missing
);
1321 Diag(PreviousDefaultArgLoc
, diag::note_template_param_prev_default_arg
);
1325 // If we have an old template parameter list that we're merging
1326 // in, move on to the next parameter.
1336 /// A class which looks for a use of a certain level of template
1338 struct DependencyChecker
: RecursiveASTVisitor
<DependencyChecker
> {
1339 typedef RecursiveASTVisitor
<DependencyChecker
> super
;
1344 DependencyChecker(TemplateParameterList
*Params
) : Match(false) {
1345 NamedDecl
*ND
= Params
->getParam(0);
1346 if (TemplateTypeParmDecl
*PD
= dyn_cast
<TemplateTypeParmDecl
>(ND
)) {
1347 Depth
= PD
->getDepth();
1348 } else if (NonTypeTemplateParmDecl
*PD
=
1349 dyn_cast
<NonTypeTemplateParmDecl
>(ND
)) {
1350 Depth
= PD
->getDepth();
1352 Depth
= cast
<TemplateTemplateParmDecl
>(ND
)->getDepth();
1356 bool Matches(unsigned ParmDepth
) {
1357 if (ParmDepth
>= Depth
) {
1364 bool VisitTemplateTypeParmType(const TemplateTypeParmType
*T
) {
1365 return !Matches(T
->getDepth());
1368 bool TraverseTemplateName(TemplateName N
) {
1369 if (TemplateTemplateParmDecl
*PD
=
1370 dyn_cast_or_null
<TemplateTemplateParmDecl
>(N
.getAsTemplateDecl()))
1371 if (Matches(PD
->getDepth())) return false;
1372 return super::TraverseTemplateName(N
);
1375 bool VisitDeclRefExpr(DeclRefExpr
*E
) {
1376 if (NonTypeTemplateParmDecl
*PD
=
1377 dyn_cast
<NonTypeTemplateParmDecl
>(E
->getDecl())) {
1378 if (PD
->getDepth() == Depth
) {
1383 return super::VisitDeclRefExpr(E
);
1388 /// Determines whether a template-id depends on the given parameter
1391 DependsOnTemplateParameters(const TemplateSpecializationType
*TemplateId
,
1392 TemplateParameterList
*Params
) {
1393 DependencyChecker
Checker(Params
);
1394 Checker
.TraverseType(QualType(TemplateId
, 0));
1395 return Checker
.Match
;
1398 /// \brief Match the given template parameter lists to the given scope
1399 /// specifier, returning the template parameter list that applies to the
1402 /// \param DeclStartLoc the start of the declaration that has a scope
1403 /// specifier or a template parameter list.
1405 /// \param SS the scope specifier that will be matched to the given template
1406 /// parameter lists. This scope specifier precedes a qualified name that is
1409 /// \param ParamLists the template parameter lists, from the outermost to the
1410 /// innermost template parameter lists.
1412 /// \param NumParamLists the number of template parameter lists in ParamLists.
1414 /// \param IsFriend Whether to apply the slightly different rules for
1415 /// matching template parameters to scope specifiers in friend
1418 /// \param IsExplicitSpecialization will be set true if the entity being
1419 /// declared is an explicit specialization, false otherwise.
1421 /// \returns the template parameter list, if any, that corresponds to the
1422 /// name that is preceded by the scope specifier @p SS. This template
1423 /// parameter list may be have template parameters (if we're declaring a
1424 /// template) or may have no template parameters (if we're declaring a
1425 /// template specialization), or may be NULL (if we were's declaring isn't
1426 /// itself a template).
1427 TemplateParameterList
*
1428 Sema::MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc
,
1429 const CXXScopeSpec
&SS
,
1430 TemplateParameterList
**ParamLists
,
1431 unsigned NumParamLists
,
1433 bool &IsExplicitSpecialization
,
1435 IsExplicitSpecialization
= false;
1437 // Find the template-ids that occur within the nested-name-specifier. These
1438 // template-ids will match up with the template parameter lists.
1439 llvm::SmallVector
<const TemplateSpecializationType
*, 4>
1440 TemplateIdsInSpecifier
;
1441 llvm::SmallVector
<ClassTemplateSpecializationDecl
*, 4>
1442 ExplicitSpecializationsInSpecifier
;
1443 for (NestedNameSpecifier
*NNS
= (NestedNameSpecifier
*)SS
.getScopeRep();
1444 NNS
; NNS
= NNS
->getPrefix()) {
1445 const Type
*T
= NNS
->getAsType();
1448 // C++0x [temp.expl.spec]p17:
1449 // A member or a member template may be nested within many
1450 // enclosing class templates. In an explicit specialization for
1451 // such a member, the member declaration shall be preceded by a
1452 // template<> for each enclosing class template that is
1453 // explicitly specialized.
1455 // Following the existing practice of GNU and EDG, we allow a typedef of a
1456 // template specialization type.
1457 while (const TypedefType
*TT
= dyn_cast
<TypedefType
>(T
))
1458 T
= TT
->getDecl()->getUnderlyingType().getTypePtr();
1460 if (const TemplateSpecializationType
*SpecType
1461 = dyn_cast
<TemplateSpecializationType
>(T
)) {
1462 TemplateDecl
*Template
= SpecType
->getTemplateName().getAsTemplateDecl();
1464 continue; // FIXME: should this be an error? probably...
1466 if (const RecordType
*Record
= SpecType
->getAs
<RecordType
>()) {
1467 ClassTemplateSpecializationDecl
*SpecDecl
1468 = cast
<ClassTemplateSpecializationDecl
>(Record
->getDecl());
1469 // If the nested name specifier refers to an explicit specialization,
1470 // we don't need a template<> header.
1471 if (SpecDecl
->getSpecializationKind() == TSK_ExplicitSpecialization
) {
1472 ExplicitSpecializationsInSpecifier
.push_back(SpecDecl
);
1477 TemplateIdsInSpecifier
.push_back(SpecType
);
1481 // Reverse the list of template-ids in the scope specifier, so that we can
1482 // more easily match up the template-ids and the template parameter lists.
1483 std::reverse(TemplateIdsInSpecifier
.begin(), TemplateIdsInSpecifier
.end());
1485 SourceLocation FirstTemplateLoc
= DeclStartLoc
;
1487 FirstTemplateLoc
= ParamLists
[0]->getTemplateLoc();
1489 // Match the template-ids found in the specifier to the template parameter
1491 unsigned ParamIdx
= 0, TemplateIdx
= 0;
1492 for (unsigned NumTemplateIds
= TemplateIdsInSpecifier
.size();
1493 TemplateIdx
!= NumTemplateIds
; ++TemplateIdx
) {
1494 const TemplateSpecializationType
*TemplateId
1495 = TemplateIdsInSpecifier
[TemplateIdx
];
1496 bool DependentTemplateId
= TemplateId
->isDependentType();
1498 // In friend declarations we can have template-ids which don't
1499 // depend on the corresponding template parameter lists. But
1500 // assume that empty parameter lists are supposed to match this
1502 if (IsFriend
&& ParamIdx
< NumParamLists
&& ParamLists
[ParamIdx
]->size()) {
1503 if (!DependentTemplateId
||
1504 !DependsOnTemplateParameters(TemplateId
, ParamLists
[ParamIdx
]))
1508 if (ParamIdx
>= NumParamLists
) {
1509 // We have a template-id without a corresponding template parameter
1512 // ...which is fine if this is a friend declaration.
1514 IsExplicitSpecialization
= true;
1518 if (DependentTemplateId
) {
1519 // FIXME: the location information here isn't great.
1520 Diag(SS
.getRange().getBegin(),
1521 diag::err_template_spec_needs_template_parameters
)
1522 << QualType(TemplateId
, 0)
1526 Diag(SS
.getRange().getBegin(), diag::err_template_spec_needs_header
)
1528 << FixItHint::CreateInsertion(FirstTemplateLoc
, "template<> ");
1529 IsExplicitSpecialization
= true;
1534 // Check the template parameter list against its corresponding template-id.
1535 if (DependentTemplateId
) {
1536 TemplateParameterList
*ExpectedTemplateParams
= 0;
1538 // Are there cases in (e.g.) friends where this won't match?
1539 if (const InjectedClassNameType
*Injected
1540 = TemplateId
->getAs
<InjectedClassNameType
>()) {
1541 CXXRecordDecl
*Record
= Injected
->getDecl();
1542 if (ClassTemplatePartialSpecializationDecl
*Partial
=
1543 dyn_cast
<ClassTemplatePartialSpecializationDecl
>(Record
))
1544 ExpectedTemplateParams
= Partial
->getTemplateParameters();
1546 ExpectedTemplateParams
= Record
->getDescribedClassTemplate()
1547 ->getTemplateParameters();
1550 if (ExpectedTemplateParams
)
1551 TemplateParameterListsAreEqual(ParamLists
[ParamIdx
],
1552 ExpectedTemplateParams
,
1553 true, TPL_TemplateMatch
);
1555 CheckTemplateParameterList(ParamLists
[ParamIdx
], 0,
1556 TPC_ClassTemplateMember
);
1557 } else if (ParamLists
[ParamIdx
]->size() > 0)
1558 Diag(ParamLists
[ParamIdx
]->getTemplateLoc(),
1559 diag::err_template_param_list_matches_nontemplate
)
1561 << ParamLists
[ParamIdx
]->getSourceRange();
1563 IsExplicitSpecialization
= true;
1568 // If there were at least as many template-ids as there were template
1569 // parameter lists, then there are no template parameter lists remaining for
1570 // the declaration itself.
1571 if (ParamIdx
>= NumParamLists
)
1574 // If there were too many template parameter lists, complain about that now.
1575 if (ParamIdx
!= NumParamLists
- 1) {
1576 while (ParamIdx
< NumParamLists
- 1) {
1577 bool isExplicitSpecHeader
= ParamLists
[ParamIdx
]->size() == 0;
1578 Diag(ParamLists
[ParamIdx
]->getTemplateLoc(),
1579 isExplicitSpecHeader
? diag::warn_template_spec_extra_headers
1580 : diag::err_template_spec_extra_headers
)
1581 << SourceRange(ParamLists
[ParamIdx
]->getTemplateLoc(),
1582 ParamLists
[ParamIdx
]->getRAngleLoc());
1584 if (isExplicitSpecHeader
&& !ExplicitSpecializationsInSpecifier
.empty()) {
1585 Diag(ExplicitSpecializationsInSpecifier
.back()->getLocation(),
1586 diag::note_explicit_template_spec_does_not_need_header
)
1587 << ExplicitSpecializationsInSpecifier
.back();
1588 ExplicitSpecializationsInSpecifier
.pop_back();
1591 // We have a template parameter list with no corresponding scope, which
1592 // means that the resulting template declaration can't be instantiated
1593 // properly (we'll end up with dependent nodes when we shouldn't).
1594 if (!isExplicitSpecHeader
)
1601 // Return the last template parameter list, which corresponds to the
1602 // entity being declared.
1603 return ParamLists
[NumParamLists
- 1];
1606 QualType
Sema::CheckTemplateIdType(TemplateName Name
,
1607 SourceLocation TemplateLoc
,
1608 const TemplateArgumentListInfo
&TemplateArgs
) {
1609 TemplateDecl
*Template
= Name
.getAsTemplateDecl();
1611 // The template name does not resolve to a template, so we just
1612 // build a dependent template-id type.
1613 return Context
.getTemplateSpecializationType(Name
, TemplateArgs
);
1616 // Check that the template argument list is well-formed for this
1618 llvm::SmallVector
<TemplateArgument
, 4> Converted
;
1619 if (CheckTemplateArgumentList(Template
, TemplateLoc
, TemplateArgs
,
1623 assert((Converted
.size() == Template
->getTemplateParameters()->size()) &&
1624 "Converted template argument list is too short!");
1628 if (Name
.isDependent() ||
1629 TemplateSpecializationType::anyDependentTemplateArguments(
1631 // This class template specialization is a dependent
1632 // type. Therefore, its canonical type is another class template
1633 // specialization type that contains all of the converted
1634 // arguments in canonical form. This ensures that, e.g., A<T> and
1635 // A<T, T> have identical types when A is declared as:
1637 // template<typename T, typename U = T> struct A;
1638 TemplateName CanonName
= Context
.getCanonicalTemplateName(Name
);
1639 CanonType
= Context
.getTemplateSpecializationType(CanonName
,
1643 // FIXME: CanonType is not actually the canonical type, and unfortunately
1644 // it is a TemplateSpecializationType that we will never use again.
1645 // In the future, we need to teach getTemplateSpecializationType to only
1646 // build the canonical type and return that to us.
1647 CanonType
= Context
.getCanonicalType(CanonType
);
1649 // This might work out to be a current instantiation, in which
1650 // case the canonical type needs to be the InjectedClassNameType.
1652 // TODO: in theory this could be a simple hashtable lookup; most
1653 // changes to CurContext don't change the set of current
1655 if (isa
<ClassTemplateDecl
>(Template
)) {
1656 for (DeclContext
*Ctx
= CurContext
; Ctx
; Ctx
= Ctx
->getLookupParent()) {
1657 // If we get out to a namespace, we're done.
1658 if (Ctx
->isFileContext()) break;
1660 // If this isn't a record, keep looking.
1661 CXXRecordDecl
*Record
= dyn_cast
<CXXRecordDecl
>(Ctx
);
1662 if (!Record
) continue;
1664 // Look for one of the two cases with InjectedClassNameTypes
1665 // and check whether it's the same template.
1666 if (!isa
<ClassTemplatePartialSpecializationDecl
>(Record
) &&
1667 !Record
->getDescribedClassTemplate())
1670 // Fetch the injected class name type and check whether its
1671 // injected type is equal to the type we just built.
1672 QualType ICNT
= Context
.getTypeDeclType(Record
);
1673 QualType Injected
= cast
<InjectedClassNameType
>(ICNT
)
1674 ->getInjectedSpecializationType();
1676 if (CanonType
!= Injected
->getCanonicalTypeInternal())
1679 // If so, the canonical type of this TST is the injected
1680 // class name type of the record we just found.
1681 assert(ICNT
.isCanonical());
1686 } else if (ClassTemplateDecl
*ClassTemplate
1687 = dyn_cast
<ClassTemplateDecl
>(Template
)) {
1688 // Find the class template specialization declaration that
1689 // corresponds to these arguments.
1690 void *InsertPos
= 0;
1691 ClassTemplateSpecializationDecl
*Decl
1692 = ClassTemplate
->findSpecialization(Converted
.data(), Converted
.size(),
1695 // This is the first time we have referenced this class template
1696 // specialization. Create the canonical declaration and add it to
1697 // the set of specializations.
1698 Decl
= ClassTemplateSpecializationDecl::Create(Context
,
1699 ClassTemplate
->getTemplatedDecl()->getTagKind(),
1700 ClassTemplate
->getDeclContext(),
1701 ClassTemplate
->getLocation(),
1704 Converted
.size(), 0);
1705 ClassTemplate
->AddSpecialization(Decl
, InsertPos
);
1706 Decl
->setLexicalDeclContext(CurContext
);
1709 CanonType
= Context
.getTypeDeclType(Decl
);
1710 assert(isa
<RecordType
>(CanonType
) &&
1711 "type of non-dependent specialization is not a RecordType");
1714 // Build the fully-sugared type for this class template
1715 // specialization, which refers back to the class template
1716 // specialization we created or found.
1717 return Context
.getTemplateSpecializationType(Name
, TemplateArgs
, CanonType
);
1721 Sema::ActOnTemplateIdType(TemplateTy TemplateD
, SourceLocation TemplateLoc
,
1722 SourceLocation LAngleLoc
,
1723 ASTTemplateArgsPtr TemplateArgsIn
,
1724 SourceLocation RAngleLoc
) {
1725 TemplateName Template
= TemplateD
.getAsVal
<TemplateName
>();
1727 // Translate the parser's template argument list in our AST format.
1728 TemplateArgumentListInfo
TemplateArgs(LAngleLoc
, RAngleLoc
);
1729 translateTemplateArguments(TemplateArgsIn
, TemplateArgs
);
1731 QualType Result
= CheckTemplateIdType(Template
, TemplateLoc
, TemplateArgs
);
1732 TemplateArgsIn
.release();
1734 if (Result
.isNull())
1737 TypeSourceInfo
*DI
= Context
.CreateTypeSourceInfo(Result
);
1738 TemplateSpecializationTypeLoc TL
1739 = cast
<TemplateSpecializationTypeLoc
>(DI
->getTypeLoc());
1740 TL
.setTemplateNameLoc(TemplateLoc
);
1741 TL
.setLAngleLoc(LAngleLoc
);
1742 TL
.setRAngleLoc(RAngleLoc
);
1743 for (unsigned i
= 0, e
= TL
.getNumArgs(); i
!= e
; ++i
)
1744 TL
.setArgLocInfo(i
, TemplateArgs
[i
].getLocInfo());
1746 return CreateParsedType(Result
, DI
);
1749 TypeResult
Sema::ActOnTagTemplateIdType(CXXScopeSpec
&SS
,
1750 TypeResult TypeResult
,
1752 TypeSpecifierType TagSpec
,
1753 SourceLocation TagLoc
) {
1754 if (TypeResult
.isInvalid())
1755 return ::TypeResult();
1758 QualType Type
= GetTypeFromParser(TypeResult
.get(), &DI
);
1760 // Verify the tag specifier.
1761 TagTypeKind TagKind
= TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec
);
1763 if (const RecordType
*RT
= Type
->getAs
<RecordType
>()) {
1764 RecordDecl
*D
= RT
->getDecl();
1766 IdentifierInfo
*Id
= D
->getIdentifier();
1767 assert(Id
&& "templated class must have an identifier");
1769 if (!isAcceptableTagRedeclaration(D
, TagKind
, TagLoc
, *Id
)) {
1770 Diag(TagLoc
, diag::err_use_with_wrong_tag
)
1772 << FixItHint::CreateReplacement(SourceRange(TagLoc
), D
->getKindName());
1773 Diag(D
->getLocation(), diag::note_previous_use
);
1777 ElaboratedTypeKeyword Keyword
1778 = TypeWithKeyword::getKeywordForTagTypeKind(TagKind
);
1779 QualType ElabType
= Context
.getElaboratedType(Keyword
, /*NNS=*/0, Type
);
1781 TypeSourceInfo
*ElabDI
= Context
.CreateTypeSourceInfo(ElabType
);
1782 ElaboratedTypeLoc TL
= cast
<ElaboratedTypeLoc
>(ElabDI
->getTypeLoc());
1783 TL
.setKeywordLoc(TagLoc
);
1784 TL
.setQualifierRange(SS
.getRange());
1785 TL
.getNamedTypeLoc().initializeFullCopy(DI
->getTypeLoc());
1786 return CreateParsedType(ElabType
, ElabDI
);
1789 ExprResult
Sema::BuildTemplateIdExpr(const CXXScopeSpec
&SS
,
1792 const TemplateArgumentListInfo
&TemplateArgs
) {
1793 // FIXME: Can we do any checking at this point? I guess we could check the
1794 // template arguments that we have against the template name, if the template
1795 // name refers to a single template. That's not a terribly common case,
1798 // These should be filtered out by our callers.
1799 assert(!R
.empty() && "empty lookup results when building templateid");
1800 assert(!R
.isAmbiguous() && "ambiguous lookup when building templateid");
1802 NestedNameSpecifier
*Qualifier
= 0;
1803 SourceRange QualifierRange
;
1805 Qualifier
= static_cast<NestedNameSpecifier
*>(SS
.getScopeRep());
1806 QualifierRange
= SS
.getRange();
1809 // We don't want lookup warnings at this point.
1810 R
.suppressDiagnostics();
1812 UnresolvedLookupExpr
*ULE
1813 = UnresolvedLookupExpr::Create(Context
, R
.getNamingClass(),
1814 Qualifier
, QualifierRange
,
1815 R
.getLookupNameInfo(),
1816 RequiresADL
, TemplateArgs
,
1817 R
.begin(), R
.end());
1822 // We actually only call this from template instantiation.
1824 Sema::BuildQualifiedTemplateIdExpr(CXXScopeSpec
&SS
,
1825 const DeclarationNameInfo
&NameInfo
,
1826 const TemplateArgumentListInfo
&TemplateArgs
) {
1828 if (!(DC
= computeDeclContext(SS
, false)) ||
1829 DC
->isDependentContext() ||
1830 RequireCompleteDeclContext(SS
, DC
))
1831 return BuildDependentDeclRefExpr(SS
, NameInfo
, &TemplateArgs
);
1833 bool MemberOfUnknownSpecialization
;
1834 LookupResult
R(*this, NameInfo
, LookupOrdinaryName
);
1835 LookupTemplateName(R
, (Scope
*) 0, SS
, QualType(), /*Entering*/ false,
1836 MemberOfUnknownSpecialization
);
1838 if (R
.isAmbiguous())
1842 Diag(NameInfo
.getLoc(), diag::err_template_kw_refers_to_non_template
)
1843 << NameInfo
.getName() << SS
.getRange();
1847 if (ClassTemplateDecl
*Temp
= R
.getAsSingle
<ClassTemplateDecl
>()) {
1848 Diag(NameInfo
.getLoc(), diag::err_template_kw_refers_to_class_template
)
1849 << (NestedNameSpecifier
*) SS
.getScopeRep()
1850 << NameInfo
.getName() << SS
.getRange();
1851 Diag(Temp
->getLocation(), diag::note_referenced_class_template
);
1855 return BuildTemplateIdExpr(SS
, R
, /* ADL */ false, TemplateArgs
);
1858 /// \brief Form a dependent template name.
1860 /// This action forms a dependent template name given the template
1861 /// name and its (presumably dependent) scope specifier. For
1862 /// example, given "MetaFun::template apply", the scope specifier \p
1863 /// SS will be "MetaFun::", \p TemplateKWLoc contains the location
1864 /// of the "template" keyword, and "apply" is the \p Name.
1865 TemplateNameKind
Sema::ActOnDependentTemplateName(Scope
*S
,
1866 SourceLocation TemplateKWLoc
,
1868 UnqualifiedId
&Name
,
1869 ParsedType ObjectType
,
1870 bool EnteringContext
,
1871 TemplateTy
&Result
) {
1872 if (TemplateKWLoc
.isValid() && S
&& !S
->getTemplateParamParent() &&
1873 !getLangOptions().CPlusPlus0x
)
1874 Diag(TemplateKWLoc
, diag::ext_template_outside_of_template
)
1875 << FixItHint::CreateRemoval(TemplateKWLoc
);
1877 DeclContext
*LookupCtx
= 0;
1879 LookupCtx
= computeDeclContext(SS
, EnteringContext
);
1880 if (!LookupCtx
&& ObjectType
)
1881 LookupCtx
= computeDeclContext(ObjectType
.get());
1883 // C++0x [temp.names]p5:
1884 // If a name prefixed by the keyword template is not the name of
1885 // a template, the program is ill-formed. [Note: the keyword
1886 // template may not be applied to non-template members of class
1887 // templates. -end note ] [ Note: as is the case with the
1888 // typename prefix, the template prefix is allowed in cases
1889 // where it is not strictly necessary; i.e., when the
1890 // nested-name-specifier or the expression on the left of the ->
1891 // or . is not dependent on a template-parameter, or the use
1892 // does not appear in the scope of a template. -end note]
1894 // Note: C++03 was more strict here, because it banned the use of
1895 // the "template" keyword prior to a template-name that was not a
1896 // dependent name. C++ DR468 relaxed this requirement (the
1897 // "template" keyword is now permitted). We follow the C++0x
1898 // rules, even in C++03 mode with a warning, retroactively applying the DR.
1899 bool MemberOfUnknownSpecialization
;
1900 TemplateNameKind TNK
= isTemplateName(0, SS
, TemplateKWLoc
.isValid(), Name
,
1901 ObjectType
, EnteringContext
, Result
,
1902 MemberOfUnknownSpecialization
);
1903 if (TNK
== TNK_Non_template
&& LookupCtx
->isDependentContext() &&
1904 isa
<CXXRecordDecl
>(LookupCtx
) &&
1905 cast
<CXXRecordDecl
>(LookupCtx
)->hasAnyDependentBases()) {
1906 // This is a dependent template. Handle it below.
1907 } else if (TNK
== TNK_Non_template
) {
1908 Diag(Name
.getSourceRange().getBegin(),
1909 diag::err_template_kw_refers_to_non_template
)
1910 << GetNameFromUnqualifiedId(Name
).getName()
1911 << Name
.getSourceRange()
1913 return TNK_Non_template
;
1915 // We found something; return it.
1920 NestedNameSpecifier
*Qualifier
1921 = static_cast<NestedNameSpecifier
*>(SS
.getScopeRep());
1923 switch (Name
.getKind()) {
1924 case UnqualifiedId::IK_Identifier
:
1925 Result
= TemplateTy::make(Context
.getDependentTemplateName(Qualifier
,
1927 return TNK_Dependent_template_name
;
1929 case UnqualifiedId::IK_OperatorFunctionId
:
1930 Result
= TemplateTy::make(Context
.getDependentTemplateName(Qualifier
,
1931 Name
.OperatorFunctionId
.Operator
));
1932 return TNK_Dependent_template_name
;
1934 case UnqualifiedId::IK_LiteralOperatorId
:
1935 assert(false && "We don't support these; Parse shouldn't have allowed propagation");
1941 Diag(Name
.getSourceRange().getBegin(),
1942 diag::err_template_kw_refers_to_non_template
)
1943 << GetNameFromUnqualifiedId(Name
).getName()
1944 << Name
.getSourceRange()
1946 return TNK_Non_template
;
1949 bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl
*Param
,
1950 const TemplateArgumentLoc
&AL
,
1951 llvm::SmallVectorImpl
<TemplateArgument
> &Converted
) {
1952 const TemplateArgument
&Arg
= AL
.getArgument();
1954 // Check template type parameter.
1955 switch(Arg
.getKind()) {
1956 case TemplateArgument::Type
:
1957 // C++ [temp.arg.type]p1:
1958 // A template-argument for a template-parameter which is a
1959 // type shall be a type-id.
1961 case TemplateArgument::Template
: {
1962 // We have a template type parameter but the template argument
1963 // is a template without any arguments.
1964 SourceRange SR
= AL
.getSourceRange();
1965 TemplateName Name
= Arg
.getAsTemplate();
1966 Diag(SR
.getBegin(), diag::err_template_missing_args
)
1968 if (TemplateDecl
*Decl
= Name
.getAsTemplateDecl())
1969 Diag(Decl
->getLocation(), diag::note_template_decl_here
);
1974 // We have a template type parameter but the template argument
1976 SourceRange SR
= AL
.getSourceRange();
1977 Diag(SR
.getBegin(), diag::err_template_arg_must_be_type
) << SR
;
1978 Diag(Param
->getLocation(), diag::note_template_param_here
);
1984 if (CheckTemplateArgument(Param
, AL
.getTypeSourceInfo()))
1987 // Add the converted template type argument.
1988 Converted
.push_back(
1989 TemplateArgument(Context
.getCanonicalType(Arg
.getAsType())));
1993 /// \brief Substitute template arguments into the default template argument for
1994 /// the given template type parameter.
1996 /// \param SemaRef the semantic analysis object for which we are performing
1997 /// the substitution.
1999 /// \param Template the template that we are synthesizing template arguments
2002 /// \param TemplateLoc the location of the template name that started the
2003 /// template-id we are checking.
2005 /// \param RAngleLoc the location of the right angle bracket ('>') that
2006 /// terminates the template-id.
2008 /// \param Param the template template parameter whose default we are
2009 /// substituting into.
2011 /// \param Converted the list of template arguments provided for template
2012 /// parameters that precede \p Param in the template parameter list.
2014 /// \returns the substituted template argument, or NULL if an error occurred.
2015 static TypeSourceInfo
*
2016 SubstDefaultTemplateArgument(Sema
&SemaRef
,
2017 TemplateDecl
*Template
,
2018 SourceLocation TemplateLoc
,
2019 SourceLocation RAngleLoc
,
2020 TemplateTypeParmDecl
*Param
,
2021 llvm::SmallVectorImpl
<TemplateArgument
> &Converted
) {
2022 TypeSourceInfo
*ArgType
= Param
->getDefaultArgumentInfo();
2024 // If the argument type is dependent, instantiate it now based
2025 // on the previously-computed template arguments.
2026 if (ArgType
->getType()->isDependentType()) {
2027 TemplateArgumentList
TemplateArgs(TemplateArgumentList::OnStack
,
2028 Converted
.data(), Converted
.size());
2030 MultiLevelTemplateArgumentList AllTemplateArgs
2031 = SemaRef
.getTemplateInstantiationArgs(Template
, &TemplateArgs
);
2033 Sema::InstantiatingTemplate
Inst(SemaRef
, TemplateLoc
,
2034 Template
, Converted
.data(),
2036 SourceRange(TemplateLoc
, RAngleLoc
));
2038 ArgType
= SemaRef
.SubstType(ArgType
, AllTemplateArgs
,
2039 Param
->getDefaultArgumentLoc(),
2040 Param
->getDeclName());
2046 /// \brief Substitute template arguments into the default template argument for
2047 /// the given non-type template parameter.
2049 /// \param SemaRef the semantic analysis object for which we are performing
2050 /// the substitution.
2052 /// \param Template the template that we are synthesizing template arguments
2055 /// \param TemplateLoc the location of the template name that started the
2056 /// template-id we are checking.
2058 /// \param RAngleLoc the location of the right angle bracket ('>') that
2059 /// terminates the template-id.
2061 /// \param Param the non-type template parameter whose default we are
2062 /// substituting into.
2064 /// \param Converted the list of template arguments provided for template
2065 /// parameters that precede \p Param in the template parameter list.
2067 /// \returns the substituted template argument, or NULL if an error occurred.
2069 SubstDefaultTemplateArgument(Sema
&SemaRef
,
2070 TemplateDecl
*Template
,
2071 SourceLocation TemplateLoc
,
2072 SourceLocation RAngleLoc
,
2073 NonTypeTemplateParmDecl
*Param
,
2074 llvm::SmallVectorImpl
<TemplateArgument
> &Converted
) {
2075 TemplateArgumentList
TemplateArgs(TemplateArgumentList::OnStack
,
2076 Converted
.data(), Converted
.size());
2078 MultiLevelTemplateArgumentList AllTemplateArgs
2079 = SemaRef
.getTemplateInstantiationArgs(Template
, &TemplateArgs
);
2081 Sema::InstantiatingTemplate
Inst(SemaRef
, TemplateLoc
,
2082 Template
, Converted
.data(),
2084 SourceRange(TemplateLoc
, RAngleLoc
));
2086 return SemaRef
.SubstExpr(Param
->getDefaultArgument(), AllTemplateArgs
);
2089 /// \brief Substitute template arguments into the default template argument for
2090 /// the given template template parameter.
2092 /// \param SemaRef the semantic analysis object for which we are performing
2093 /// the substitution.
2095 /// \param Template the template that we are synthesizing template arguments
2098 /// \param TemplateLoc the location of the template name that started the
2099 /// template-id we are checking.
2101 /// \param RAngleLoc the location of the right angle bracket ('>') that
2102 /// terminates the template-id.
2104 /// \param Param the template template parameter whose default we are
2105 /// substituting into.
2107 /// \param Converted the list of template arguments provided for template
2108 /// parameters that precede \p Param in the template parameter list.
2110 /// \returns the substituted template argument, or NULL if an error occurred.
2112 SubstDefaultTemplateArgument(Sema
&SemaRef
,
2113 TemplateDecl
*Template
,
2114 SourceLocation TemplateLoc
,
2115 SourceLocation RAngleLoc
,
2116 TemplateTemplateParmDecl
*Param
,
2117 llvm::SmallVectorImpl
<TemplateArgument
> &Converted
) {
2118 TemplateArgumentList
TemplateArgs(TemplateArgumentList::OnStack
,
2119 Converted
.data(), Converted
.size());
2121 MultiLevelTemplateArgumentList AllTemplateArgs
2122 = SemaRef
.getTemplateInstantiationArgs(Template
, &TemplateArgs
);
2124 Sema::InstantiatingTemplate
Inst(SemaRef
, TemplateLoc
,
2125 Template
, Converted
.data(),
2127 SourceRange(TemplateLoc
, RAngleLoc
));
2129 return SemaRef
.SubstTemplateName(
2130 Param
->getDefaultArgument().getArgument().getAsTemplate(),
2131 Param
->getDefaultArgument().getTemplateNameLoc(),
2135 /// \brief If the given template parameter has a default template
2136 /// argument, substitute into that default template argument and
2137 /// return the corresponding template argument.
2139 Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl
*Template
,
2140 SourceLocation TemplateLoc
,
2141 SourceLocation RAngleLoc
,
2143 llvm::SmallVectorImpl
<TemplateArgument
> &Converted
) {
2144 if (TemplateTypeParmDecl
*TypeParm
= dyn_cast
<TemplateTypeParmDecl
>(Param
)) {
2145 if (!TypeParm
->hasDefaultArgument())
2146 return TemplateArgumentLoc();
2148 TypeSourceInfo
*DI
= SubstDefaultTemplateArgument(*this, Template
,
2154 return TemplateArgumentLoc(TemplateArgument(DI
->getType()), DI
);
2156 return TemplateArgumentLoc();
2159 if (NonTypeTemplateParmDecl
*NonTypeParm
2160 = dyn_cast
<NonTypeTemplateParmDecl
>(Param
)) {
2161 if (!NonTypeParm
->hasDefaultArgument())
2162 return TemplateArgumentLoc();
2164 ExprResult Arg
= SubstDefaultTemplateArgument(*this, Template
,
2169 if (Arg
.isInvalid())
2170 return TemplateArgumentLoc();
2172 Expr
*ArgE
= Arg
.takeAs
<Expr
>();
2173 return TemplateArgumentLoc(TemplateArgument(ArgE
), ArgE
);
2176 TemplateTemplateParmDecl
*TempTempParm
2177 = cast
<TemplateTemplateParmDecl
>(Param
);
2178 if (!TempTempParm
->hasDefaultArgument())
2179 return TemplateArgumentLoc();
2181 TemplateName TName
= SubstDefaultTemplateArgument(*this, Template
,
2187 return TemplateArgumentLoc();
2189 return TemplateArgumentLoc(TemplateArgument(TName
),
2190 TempTempParm
->getDefaultArgument().getTemplateQualifierRange(),
2191 TempTempParm
->getDefaultArgument().getTemplateNameLoc());
2194 /// \brief Check that the given template argument corresponds to the given
2195 /// template parameter.
2196 bool Sema::CheckTemplateArgument(NamedDecl
*Param
,
2197 const TemplateArgumentLoc
&Arg
,
2198 NamedDecl
*Template
,
2199 SourceLocation TemplateLoc
,
2200 SourceLocation RAngleLoc
,
2201 llvm::SmallVectorImpl
<TemplateArgument
> &Converted
,
2202 CheckTemplateArgumentKind CTAK
) {
2203 // Check template type parameters.
2204 if (TemplateTypeParmDecl
*TTP
= dyn_cast
<TemplateTypeParmDecl
>(Param
))
2205 return CheckTemplateTypeArgument(TTP
, Arg
, Converted
);
2207 // Check non-type template parameters.
2208 if (NonTypeTemplateParmDecl
*NTTP
=dyn_cast
<NonTypeTemplateParmDecl
>(Param
)) {
2209 // Do substitution on the type of the non-type template parameter
2210 // with the template arguments we've seen thus far. But if the
2211 // template has a dependent context then we cannot substitute yet.
2212 QualType NTTPType
= NTTP
->getType();
2213 if (NTTPType
->isDependentType() &&
2214 !isa
<TemplateTemplateParmDecl
>(Template
) &&
2215 !Template
->getDeclContext()->isDependentContext()) {
2216 // Do substitution on the type of the non-type template parameter.
2217 InstantiatingTemplate
Inst(*this, TemplateLoc
, Template
,
2218 NTTP
, Converted
.data(), Converted
.size(),
2219 SourceRange(TemplateLoc
, RAngleLoc
));
2221 TemplateArgumentList
TemplateArgs(TemplateArgumentList::OnStack
,
2222 Converted
.data(), Converted
.size());
2223 NTTPType
= SubstType(NTTPType
,
2224 MultiLevelTemplateArgumentList(TemplateArgs
),
2225 NTTP
->getLocation(),
2226 NTTP
->getDeclName());
2227 // If that worked, check the non-type template parameter type
2229 if (!NTTPType
.isNull())
2230 NTTPType
= CheckNonTypeTemplateParameterType(NTTPType
,
2231 NTTP
->getLocation());
2232 if (NTTPType
.isNull())
2236 switch (Arg
.getArgument().getKind()) {
2237 case TemplateArgument::Null
:
2238 assert(false && "Should never see a NULL template argument here");
2241 case TemplateArgument::Expression
: {
2242 Expr
*E
= Arg
.getArgument().getAsExpr();
2243 TemplateArgument Result
;
2244 if (CheckTemplateArgument(NTTP
, NTTPType
, E
, Result
, CTAK
))
2247 Converted
.push_back(Result
);
2251 case TemplateArgument::Declaration
:
2252 case TemplateArgument::Integral
:
2253 // We've already checked this template argument, so just copy
2254 // it to the list of converted arguments.
2255 Converted
.push_back(Arg
.getArgument());
2258 case TemplateArgument::Template
:
2259 case TemplateArgument::TemplateExpansion
:
2260 // We were given a template template argument. It may not be ill-formed;
2262 if (DependentTemplateName
*DTN
2263 = Arg
.getArgument().getAsTemplateOrTemplatePattern()
2264 .getAsDependentTemplateName()) {
2265 // We have a template argument such as \c T::template X, which we
2266 // parsed as a template template argument. However, since we now
2267 // know that we need a non-type template argument, convert this
2268 // template name into an expression.
2270 DeclarationNameInfo
NameInfo(DTN
->getIdentifier(),
2271 Arg
.getTemplateNameLoc());
2273 Expr
*E
= DependentScopeDeclRefExpr::Create(Context
,
2274 DTN
->getQualifier(),
2275 Arg
.getTemplateQualifierRange(),
2278 // If we parsed the template argument as a pack expansion, create a
2279 // pack expansion expression.
2280 if (Arg
.getArgument().getKind() == TemplateArgument::TemplateExpansion
){
2281 ExprResult Expansion
= ActOnPackExpansion(E
,
2282 Arg
.getTemplateEllipsisLoc());
2283 if (Expansion
.isInvalid())
2286 E
= Expansion
.get();
2289 TemplateArgument Result
;
2290 if (CheckTemplateArgument(NTTP
, NTTPType
, E
, Result
))
2293 Converted
.push_back(Result
);
2297 // We have a template argument that actually does refer to a class
2298 // template, template alias, or template template parameter, and
2299 // therefore cannot be a non-type template argument.
2300 Diag(Arg
.getLocation(), diag::err_template_arg_must_be_expr
)
2301 << Arg
.getSourceRange();
2303 Diag(Param
->getLocation(), diag::note_template_param_here
);
2306 case TemplateArgument::Type
: {
2307 // We have a non-type template parameter but the template
2308 // argument is a type.
2310 // C++ [temp.arg]p2:
2311 // In a template-argument, an ambiguity between a type-id and
2312 // an expression is resolved to a type-id, regardless of the
2313 // form of the corresponding template-parameter.
2315 // We warn specifically about this case, since it can be rather
2316 // confusing for users.
2317 QualType T
= Arg
.getArgument().getAsType();
2318 SourceRange SR
= Arg
.getSourceRange();
2319 if (T
->isFunctionType())
2320 Diag(SR
.getBegin(), diag::err_template_arg_nontype_ambig
) << SR
<< T
;
2322 Diag(SR
.getBegin(), diag::err_template_arg_must_be_expr
) << SR
;
2323 Diag(Param
->getLocation(), diag::note_template_param_here
);
2327 case TemplateArgument::Pack
:
2328 llvm_unreachable("Caller must expand template argument packs");
2336 // Check template template parameters.
2337 TemplateTemplateParmDecl
*TempParm
= cast
<TemplateTemplateParmDecl
>(Param
);
2339 // Substitute into the template parameter list of the template
2340 // template parameter, since previously-supplied template arguments
2341 // may appear within the template template parameter.
2343 // Set up a template instantiation context.
2344 LocalInstantiationScope
Scope(*this);
2345 InstantiatingTemplate
Inst(*this, TemplateLoc
, Template
,
2346 TempParm
, Converted
.data(), Converted
.size(),
2347 SourceRange(TemplateLoc
, RAngleLoc
));
2349 TemplateArgumentList
TemplateArgs(TemplateArgumentList::OnStack
,
2350 Converted
.data(), Converted
.size());
2351 TempParm
= cast_or_null
<TemplateTemplateParmDecl
>(
2352 SubstDecl(TempParm
, CurContext
,
2353 MultiLevelTemplateArgumentList(TemplateArgs
)));
2358 switch (Arg
.getArgument().getKind()) {
2359 case TemplateArgument::Null
:
2360 assert(false && "Should never see a NULL template argument here");
2363 case TemplateArgument::Template
:
2364 case TemplateArgument::TemplateExpansion
:
2365 if (CheckTemplateArgument(TempParm
, Arg
))
2368 Converted
.push_back(Arg
.getArgument());
2371 case TemplateArgument::Expression
:
2372 case TemplateArgument::Type
:
2373 // We have a template template parameter but the template
2374 // argument does not refer to a template.
2375 Diag(Arg
.getLocation(), diag::err_template_arg_must_be_template
);
2378 case TemplateArgument::Declaration
:
2380 "Declaration argument with template template parameter");
2382 case TemplateArgument::Integral
:
2384 "Integral argument with template template parameter");
2387 case TemplateArgument::Pack
:
2388 llvm_unreachable("Caller must expand template argument packs");
2395 /// \brief Check that the given template argument list is well-formed
2396 /// for specializing the given template.
2397 bool Sema::CheckTemplateArgumentList(TemplateDecl
*Template
,
2398 SourceLocation TemplateLoc
,
2399 const TemplateArgumentListInfo
&TemplateArgs
,
2400 bool PartialTemplateArgs
,
2401 llvm::SmallVectorImpl
<TemplateArgument
> &Converted
) {
2402 TemplateParameterList
*Params
= Template
->getTemplateParameters();
2403 unsigned NumParams
= Params
->size();
2404 unsigned NumArgs
= TemplateArgs
.size();
2405 bool Invalid
= false;
2407 SourceLocation RAngleLoc
= TemplateArgs
.getRAngleLoc();
2409 bool HasParameterPack
=
2410 NumParams
> 0 && Params
->getParam(NumParams
- 1)->isTemplateParameterPack();
2412 if ((NumArgs
> NumParams
&& !HasParameterPack
) ||
2413 (NumArgs
< Params
->getMinRequiredArguments() &&
2414 !PartialTemplateArgs
)) {
2415 // FIXME: point at either the first arg beyond what we can handle,
2416 // or the '>', depending on whether we have too many or too few
2419 if (NumArgs
> NumParams
)
2420 Range
= SourceRange(TemplateArgs
[NumParams
].getLocation(), RAngleLoc
);
2421 Diag(TemplateLoc
, diag::err_template_arg_list_different_arity
)
2422 << (NumArgs
> NumParams
)
2423 << (isa
<ClassTemplateDecl
>(Template
)? 0 :
2424 isa
<FunctionTemplateDecl
>(Template
)? 1 :
2425 isa
<TemplateTemplateParmDecl
>(Template
)? 2 : 3)
2426 << Template
<< Range
;
2427 Diag(Template
->getLocation(), diag::note_template_decl_here
)
2428 << Params
->getSourceRange();
2432 // C++ [temp.arg]p1:
2433 // [...] The type and form of each template-argument specified in
2434 // a template-id shall match the type and form specified for the
2435 // corresponding parameter declared by the template in its
2436 // template-parameter-list.
2437 llvm::SmallVector
<TemplateArgument
, 2> ArgumentPack
;
2438 TemplateParameterList::iterator Param
= Params
->begin(),
2439 ParamEnd
= Params
->end();
2440 unsigned ArgIdx
= 0;
2441 while (Param
!= ParamEnd
) {
2442 if (ArgIdx
> NumArgs
&& PartialTemplateArgs
)
2445 if (ArgIdx
< NumArgs
) {
2446 // Check the template argument we were given.
2447 if (CheckTemplateArgument(*Param
, TemplateArgs
[ArgIdx
], Template
,
2448 TemplateLoc
, RAngleLoc
, Converted
))
2451 if ((*Param
)->isTemplateParameterPack()) {
2452 // The template parameter was a template parameter pack, so take the
2453 // deduced argument and place it on the argument pack. Note that we
2454 // stay on the same template parameter so that we can deduce more
2456 ArgumentPack
.push_back(Converted
.back());
2457 Converted
.pop_back();
2459 // Move to the next template parameter.
2466 // If we have a template parameter pack with no more corresponding
2467 // arguments, just break out now and we'll fill in the argument pack below.
2468 if ((*Param
)->isTemplateParameterPack())
2471 // We have a default template argument that we will use.
2472 TemplateArgumentLoc Arg
;
2474 // Retrieve the default template argument from the template
2475 // parameter. For each kind of template parameter, we substitute the
2476 // template arguments provided thus far and any "outer" template arguments
2477 // (when the template parameter was part of a nested template) into
2478 // the default argument.
2479 if (TemplateTypeParmDecl
*TTP
= dyn_cast
<TemplateTypeParmDecl
>(*Param
)) {
2480 if (!TTP
->hasDefaultArgument()) {
2481 assert((Invalid
|| PartialTemplateArgs
) && "Missing default argument");
2485 TypeSourceInfo
*ArgType
= SubstDefaultTemplateArgument(*this,
2494 Arg
= TemplateArgumentLoc(TemplateArgument(ArgType
->getType()),
2496 } else if (NonTypeTemplateParmDecl
*NTTP
2497 = dyn_cast
<NonTypeTemplateParmDecl
>(*Param
)) {
2498 if (!NTTP
->hasDefaultArgument()) {
2499 assert((Invalid
|| PartialTemplateArgs
) && "Missing default argument");
2503 ExprResult E
= SubstDefaultTemplateArgument(*this, Template
,
2511 Expr
*Ex
= E
.takeAs
<Expr
>();
2512 Arg
= TemplateArgumentLoc(TemplateArgument(Ex
), Ex
);
2514 TemplateTemplateParmDecl
*TempParm
2515 = cast
<TemplateTemplateParmDecl
>(*Param
);
2517 if (!TempParm
->hasDefaultArgument()) {
2518 assert((Invalid
|| PartialTemplateArgs
) && "Missing default argument");
2522 TemplateName Name
= SubstDefaultTemplateArgument(*this, Template
,
2530 Arg
= TemplateArgumentLoc(TemplateArgument(Name
),
2531 TempParm
->getDefaultArgument().getTemplateQualifierRange(),
2532 TempParm
->getDefaultArgument().getTemplateNameLoc());
2535 // Introduce an instantiation record that describes where we are using
2536 // the default template argument.
2537 InstantiatingTemplate
Instantiating(*this, RAngleLoc
, Template
, *Param
,
2538 Converted
.data(), Converted
.size(),
2539 SourceRange(TemplateLoc
, RAngleLoc
));
2541 // Check the default template argument.
2542 if (CheckTemplateArgument(*Param
, Arg
, Template
, TemplateLoc
,
2543 RAngleLoc
, Converted
))
2546 // Move to the next template parameter and argument.
2551 // Form argument packs for each of the parameter packs remaining.
2552 while (Param
!= ParamEnd
) {
2553 // If we're checking a partial list of template arguments, don't fill
2554 // in arguments for non-template parameter packs.
2556 if ((*Param
)->isTemplateParameterPack()) {
2557 if (PartialTemplateArgs
&& ArgumentPack
.empty()) {
2558 Converted
.push_back(TemplateArgument());
2559 } else if (ArgumentPack
.empty())
2560 Converted
.push_back(TemplateArgument(0, 0));
2562 Converted
.push_back(TemplateArgument::CreatePackCopy(Context
,
2563 ArgumentPack
.data(),
2564 ArgumentPack
.size()));
2565 ArgumentPack
.clear();
2576 class UnnamedLocalNoLinkageFinder
2577 : public TypeVisitor
<UnnamedLocalNoLinkageFinder
, bool>
2582 typedef TypeVisitor
<UnnamedLocalNoLinkageFinder
, bool> inherited
;
2585 UnnamedLocalNoLinkageFinder(Sema
&S
, SourceRange SR
) : S(S
), SR(SR
) { }
2587 bool Visit(QualType T
) {
2588 return inherited::Visit(T
.getTypePtr());
2591 #define TYPE(Class, Parent) \
2592 bool Visit##Class##Type(const Class##Type *);
2593 #define ABSTRACT_TYPE(Class, Parent) \
2594 bool Visit##Class##Type(const Class##Type *) { return false; }
2595 #define NON_CANONICAL_TYPE(Class, Parent) \
2596 bool Visit##Class##Type(const Class##Type *) { return false; }
2597 #include "clang/AST/TypeNodes.def"
2599 bool VisitTagDecl(const TagDecl
*Tag
);
2600 bool VisitNestedNameSpecifier(NestedNameSpecifier
*NNS
);
2604 bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(const BuiltinType
*) {
2608 bool UnnamedLocalNoLinkageFinder::VisitComplexType(const ComplexType
* T
) {
2609 return Visit(T
->getElementType());
2612 bool UnnamedLocalNoLinkageFinder::VisitPointerType(const PointerType
* T
) {
2613 return Visit(T
->getPointeeType());
2616 bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
2617 const BlockPointerType
* T
) {
2618 return Visit(T
->getPointeeType());
2621 bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
2622 const LValueReferenceType
* T
) {
2623 return Visit(T
->getPointeeType());
2626 bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
2627 const RValueReferenceType
* T
) {
2628 return Visit(T
->getPointeeType());
2631 bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
2632 const MemberPointerType
* T
) {
2633 return Visit(T
->getPointeeType()) || Visit(QualType(T
->getClass(), 0));
2636 bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
2637 const ConstantArrayType
* T
) {
2638 return Visit(T
->getElementType());
2641 bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
2642 const IncompleteArrayType
* T
) {
2643 return Visit(T
->getElementType());
2646 bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
2647 const VariableArrayType
* T
) {
2648 return Visit(T
->getElementType());
2651 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
2652 const DependentSizedArrayType
* T
) {
2653 return Visit(T
->getElementType());
2656 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
2657 const DependentSizedExtVectorType
* T
) {
2658 return Visit(T
->getElementType());
2661 bool UnnamedLocalNoLinkageFinder::VisitVectorType(const VectorType
* T
) {
2662 return Visit(T
->getElementType());
2665 bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(const ExtVectorType
* T
) {
2666 return Visit(T
->getElementType());
2669 bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
2670 const FunctionProtoType
* T
) {
2671 for (FunctionProtoType::arg_type_iterator A
= T
->arg_type_begin(),
2672 AEnd
= T
->arg_type_end();
2678 return Visit(T
->getResultType());
2681 bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
2682 const FunctionNoProtoType
* T
) {
2683 return Visit(T
->getResultType());
2686 bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
2687 const UnresolvedUsingType
*) {
2691 bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(const TypeOfExprType
*) {
2695 bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(const TypeOfType
* T
) {
2696 return Visit(T
->getUnderlyingType());
2699 bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType
*) {
2703 bool UnnamedLocalNoLinkageFinder::VisitRecordType(const RecordType
* T
) {
2704 return VisitTagDecl(T
->getDecl());
2707 bool UnnamedLocalNoLinkageFinder::VisitEnumType(const EnumType
* T
) {
2708 return VisitTagDecl(T
->getDecl());
2711 bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
2712 const TemplateTypeParmType
*) {
2716 bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
2717 const TemplateSpecializationType
*) {
2721 bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
2722 const InjectedClassNameType
* T
) {
2723 return VisitTagDecl(T
->getDecl());
2726 bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
2727 const DependentNameType
* T
) {
2728 return VisitNestedNameSpecifier(T
->getQualifier());
2731 bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
2732 const DependentTemplateSpecializationType
* T
) {
2733 return VisitNestedNameSpecifier(T
->getQualifier());
2736 bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
2737 const PackExpansionType
* T
) {
2738 return Visit(T
->getPattern());
2741 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType
*) {
2745 bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
2746 const ObjCInterfaceType
*) {
2750 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
2751 const ObjCObjectPointerType
*) {
2755 bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl
*Tag
) {
2756 if (Tag
->getDeclContext()->isFunctionOrMethod()) {
2757 S
.Diag(SR
.getBegin(), diag::ext_template_arg_local_type
)
2758 << S
.Context
.getTypeDeclType(Tag
) << SR
;
2762 if (!Tag
->getDeclName() && !Tag
->getTypedefForAnonDecl()) {
2763 S
.Diag(SR
.getBegin(), diag::ext_template_arg_unnamed_type
) << SR
;
2764 S
.Diag(Tag
->getLocation(), diag::note_template_unnamed_type_here
);
2771 bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
2772 NestedNameSpecifier
*NNS
) {
2773 if (NNS
->getPrefix() && VisitNestedNameSpecifier(NNS
->getPrefix()))
2776 switch (NNS
->getKind()) {
2777 case NestedNameSpecifier::Identifier
:
2778 case NestedNameSpecifier::Namespace
:
2779 case NestedNameSpecifier::Global
:
2782 case NestedNameSpecifier::TypeSpec
:
2783 case NestedNameSpecifier::TypeSpecWithTemplate
:
2784 return Visit(QualType(NNS
->getAsType(), 0));
2790 /// \brief Check a template argument against its corresponding
2791 /// template type parameter.
2793 /// This routine implements the semantics of C++ [temp.arg.type]. It
2794 /// returns true if an error occurred, and false otherwise.
2795 bool Sema::CheckTemplateArgument(TemplateTypeParmDecl
*Param
,
2796 TypeSourceInfo
*ArgInfo
) {
2797 assert(ArgInfo
&& "invalid TypeSourceInfo");
2798 QualType Arg
= ArgInfo
->getType();
2799 SourceRange SR
= ArgInfo
->getTypeLoc().getSourceRange();
2801 if (Arg
->isVariablyModifiedType()) {
2802 return Diag(SR
.getBegin(), diag::err_variably_modified_template_arg
) << Arg
;
2803 } else if (Context
.hasSameUnqualifiedType(Arg
, Context
.OverloadTy
)) {
2804 return Diag(SR
.getBegin(), diag::err_template_arg_overload_type
) << SR
;
2807 // C++03 [temp.arg.type]p2:
2808 // A local type, a type with no linkage, an unnamed type or a type
2809 // compounded from any of these types shall not be used as a
2810 // template-argument for a template type-parameter.
2812 // C++0x allows these, and even in C++03 we allow them as an extension with
2814 if (!LangOpts
.CPlusPlus0x
&& Arg
->hasUnnamedOrLocalType()) {
2815 UnnamedLocalNoLinkageFinder
Finder(*this, SR
);
2816 (void)Finder
.Visit(Context
.getCanonicalType(Arg
));
2822 /// \brief Checks whether the given template argument is the address
2823 /// of an object or function according to C++ [temp.arg.nontype]p1.
2825 CheckTemplateArgumentAddressOfObjectOrFunction(Sema
&S
,
2826 NonTypeTemplateParmDecl
*Param
,
2829 TemplateArgument
&Converted
) {
2830 bool Invalid
= false;
2832 QualType ArgType
= Arg
->getType();
2834 // See through any implicit casts we added to fix the type.
2835 while (ImplicitCastExpr
*Cast
= dyn_cast
<ImplicitCastExpr
>(Arg
))
2836 Arg
= Cast
->getSubExpr();
2838 // C++ [temp.arg.nontype]p1:
2840 // A template-argument for a non-type, non-template
2841 // template-parameter shall be one of: [...]
2843 // -- the address of an object or function with external
2844 // linkage, including function templates and function
2845 // template-ids but excluding non-static class members,
2846 // expressed as & id-expression where the & is optional if
2847 // the name refers to a function or array, or if the
2848 // corresponding template-parameter is a reference; or
2849 DeclRefExpr
*DRE
= 0;
2851 // In C++98/03 mode, give an extension warning on any extra parentheses.
2852 // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
2853 bool ExtraParens
= false;
2854 while (ParenExpr
*Parens
= dyn_cast
<ParenExpr
>(Arg
)) {
2855 if (!Invalid
&& !ExtraParens
&& !S
.getLangOptions().CPlusPlus0x
) {
2856 S
.Diag(Arg
->getSourceRange().getBegin(),
2857 diag::ext_template_arg_extra_parens
)
2858 << Arg
->getSourceRange();
2862 Arg
= Parens
->getSubExpr();
2865 bool AddressTaken
= false;
2866 SourceLocation AddrOpLoc
;
2867 if (UnaryOperator
*UnOp
= dyn_cast
<UnaryOperator
>(Arg
)) {
2868 if (UnOp
->getOpcode() == UO_AddrOf
) {
2869 DRE
= dyn_cast
<DeclRefExpr
>(UnOp
->getSubExpr());
2870 AddressTaken
= true;
2871 AddrOpLoc
= UnOp
->getOperatorLoc();
2874 DRE
= dyn_cast
<DeclRefExpr
>(Arg
);
2877 S
.Diag(Arg
->getLocStart(), diag::err_template_arg_not_decl_ref
)
2878 << Arg
->getSourceRange();
2879 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
2883 // Stop checking the precise nature of the argument if it is value dependent,
2884 // it should be checked when instantiated.
2885 if (Arg
->isValueDependent()) {
2886 Converted
= TemplateArgument(ArgIn
);
2890 if (!isa
<ValueDecl
>(DRE
->getDecl())) {
2891 S
.Diag(Arg
->getSourceRange().getBegin(),
2892 diag::err_template_arg_not_object_or_func_form
)
2893 << Arg
->getSourceRange();
2894 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
2898 NamedDecl
*Entity
= 0;
2900 // Cannot refer to non-static data members
2901 if (FieldDecl
*Field
= dyn_cast
<FieldDecl
>(DRE
->getDecl())) {
2902 S
.Diag(Arg
->getSourceRange().getBegin(), diag::err_template_arg_field
)
2903 << Field
<< Arg
->getSourceRange();
2904 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
2908 // Cannot refer to non-static member functions
2909 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(DRE
->getDecl()))
2910 if (!Method
->isStatic()) {
2911 S
.Diag(Arg
->getSourceRange().getBegin(), diag::err_template_arg_method
)
2912 << Method
<< Arg
->getSourceRange();
2913 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
2917 // Functions must have external linkage.
2918 if (FunctionDecl
*Func
= dyn_cast
<FunctionDecl
>(DRE
->getDecl())) {
2919 if (!isExternalLinkage(Func
->getLinkage())) {
2920 S
.Diag(Arg
->getSourceRange().getBegin(),
2921 diag::err_template_arg_function_not_extern
)
2922 << Func
<< Arg
->getSourceRange();
2923 S
.Diag(Func
->getLocation(), diag::note_template_arg_internal_object
)
2928 // Okay: we've named a function with external linkage.
2931 // If the template parameter has pointer type, the function decays.
2932 if (ParamType
->isPointerType() && !AddressTaken
)
2933 ArgType
= S
.Context
.getPointerType(Func
->getType());
2934 else if (AddressTaken
&& ParamType
->isReferenceType()) {
2935 // If we originally had an address-of operator, but the
2936 // parameter has reference type, complain and (if things look
2937 // like they will work) drop the address-of operator.
2938 if (!S
.Context
.hasSameUnqualifiedType(Func
->getType(),
2939 ParamType
.getNonReferenceType())) {
2940 S
.Diag(AddrOpLoc
, diag::err_template_arg_address_of_non_pointer
)
2942 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
2946 S
.Diag(AddrOpLoc
, diag::err_template_arg_address_of_non_pointer
)
2948 << FixItHint::CreateRemoval(AddrOpLoc
);
2949 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
2951 ArgType
= Func
->getType();
2953 } else if (VarDecl
*Var
= dyn_cast
<VarDecl
>(DRE
->getDecl())) {
2954 if (!isExternalLinkage(Var
->getLinkage())) {
2955 S
.Diag(Arg
->getSourceRange().getBegin(),
2956 diag::err_template_arg_object_not_extern
)
2957 << Var
<< Arg
->getSourceRange();
2958 S
.Diag(Var
->getLocation(), diag::note_template_arg_internal_object
)
2963 // A value of reference type is not an object.
2964 if (Var
->getType()->isReferenceType()) {
2965 S
.Diag(Arg
->getSourceRange().getBegin(),
2966 diag::err_template_arg_reference_var
)
2967 << Var
->getType() << Arg
->getSourceRange();
2968 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
2972 // Okay: we've named an object with external linkage
2975 // If the template parameter has pointer type, we must have taken
2976 // the address of this object.
2977 if (ParamType
->isReferenceType()) {
2979 // If we originally had an address-of operator, but the
2980 // parameter has reference type, complain and (if things look
2981 // like they will work) drop the address-of operator.
2982 if (!S
.Context
.hasSameUnqualifiedType(Var
->getType(),
2983 ParamType
.getNonReferenceType())) {
2984 S
.Diag(AddrOpLoc
, diag::err_template_arg_address_of_non_pointer
)
2986 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
2990 S
.Diag(AddrOpLoc
, diag::err_template_arg_address_of_non_pointer
)
2992 << FixItHint::CreateRemoval(AddrOpLoc
);
2993 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
2995 ArgType
= Var
->getType();
2997 } else if (!AddressTaken
&& ParamType
->isPointerType()) {
2998 if (Var
->getType()->isArrayType()) {
2999 // Array-to-pointer decay.
3000 ArgType
= S
.Context
.getArrayDecayedType(Var
->getType());
3002 // If the template parameter has pointer type but the address of
3003 // this object was not taken, complain and (possibly) recover by
3004 // taking the address of the entity.
3005 ArgType
= S
.Context
.getPointerType(Var
->getType());
3006 if (!S
.Context
.hasSameUnqualifiedType(ArgType
, ParamType
)) {
3007 S
.Diag(Arg
->getLocStart(), diag::err_template_arg_not_address_of
)
3009 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
3013 S
.Diag(Arg
->getLocStart(), diag::err_template_arg_not_address_of
)
3015 << FixItHint::CreateInsertion(Arg
->getLocStart(), "&");
3017 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
3021 // We found something else, but we don't know specifically what it is.
3022 S
.Diag(Arg
->getSourceRange().getBegin(),
3023 diag::err_template_arg_not_object_or_func
)
3024 << Arg
->getSourceRange();
3025 S
.Diag(DRE
->getDecl()->getLocation(), diag::note_template_arg_refers_here
);
3029 if (ParamType
->isPointerType() &&
3030 !ParamType
->getAs
<PointerType
>()->getPointeeType()->isFunctionType() &&
3031 S
.IsQualificationConversion(ArgType
, ParamType
)) {
3032 // For pointer-to-object types, qualification conversions are
3035 if (const ReferenceType
*ParamRef
= ParamType
->getAs
<ReferenceType
>()) {
3036 if (!ParamRef
->getPointeeType()->isFunctionType()) {
3037 // C++ [temp.arg.nontype]p5b3:
3038 // For a non-type template-parameter of type reference to
3039 // object, no conversions apply. The type referred to by the
3040 // reference may be more cv-qualified than the (otherwise
3041 // identical) type of the template- argument. The
3042 // template-parameter is bound directly to the
3043 // template-argument, which shall be an lvalue.
3045 // FIXME: Other qualifiers?
3046 unsigned ParamQuals
= ParamRef
->getPointeeType().getCVRQualifiers();
3047 unsigned ArgQuals
= ArgType
.getCVRQualifiers();
3049 if ((ParamQuals
| ArgQuals
) != ParamQuals
) {
3050 S
.Diag(Arg
->getSourceRange().getBegin(),
3051 diag::err_template_arg_ref_bind_ignores_quals
)
3052 << ParamType
<< Arg
->getType()
3053 << Arg
->getSourceRange();
3054 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
3060 // At this point, the template argument refers to an object or
3061 // function with external linkage. We now need to check whether the
3062 // argument and parameter types are compatible.
3063 if (!S
.Context
.hasSameUnqualifiedType(ArgType
,
3064 ParamType
.getNonReferenceType())) {
3065 // We can't perform this conversion or binding.
3066 if (ParamType
->isReferenceType())
3067 S
.Diag(Arg
->getLocStart(), diag::err_template_arg_no_ref_bind
)
3068 << ParamType
<< Arg
->getType() << Arg
->getSourceRange();
3070 S
.Diag(Arg
->getLocStart(), diag::err_template_arg_not_convertible
)
3071 << Arg
->getType() << ParamType
<< Arg
->getSourceRange();
3072 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
3077 // Create the template argument.
3078 Converted
= TemplateArgument(Entity
->getCanonicalDecl());
3079 S
.MarkDeclarationReferenced(Arg
->getLocStart(), Entity
);
3083 /// \brief Checks whether the given template argument is a pointer to
3084 /// member constant according to C++ [temp.arg.nontype]p1.
3085 bool Sema::CheckTemplateArgumentPointerToMember(Expr
*Arg
,
3086 TemplateArgument
&Converted
) {
3087 bool Invalid
= false;
3089 // See through any implicit casts we added to fix the type.
3090 while (ImplicitCastExpr
*Cast
= dyn_cast
<ImplicitCastExpr
>(Arg
))
3091 Arg
= Cast
->getSubExpr();
3093 // C++ [temp.arg.nontype]p1:
3095 // A template-argument for a non-type, non-template
3096 // template-parameter shall be one of: [...]
3098 // -- a pointer to member expressed as described in 5.3.1.
3099 DeclRefExpr
*DRE
= 0;
3101 // In C++98/03 mode, give an extension warning on any extra parentheses.
3102 // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
3103 bool ExtraParens
= false;
3104 while (ParenExpr
*Parens
= dyn_cast
<ParenExpr
>(Arg
)) {
3105 if (!Invalid
&& !ExtraParens
&& !getLangOptions().CPlusPlus0x
) {
3106 Diag(Arg
->getSourceRange().getBegin(),
3107 diag::ext_template_arg_extra_parens
)
3108 << Arg
->getSourceRange();
3112 Arg
= Parens
->getSubExpr();
3115 // A pointer-to-member constant written &Class::member.
3116 if (UnaryOperator
*UnOp
= dyn_cast
<UnaryOperator
>(Arg
)) {
3117 if (UnOp
->getOpcode() == UO_AddrOf
) {
3118 DRE
= dyn_cast
<DeclRefExpr
>(UnOp
->getSubExpr());
3119 if (DRE
&& !DRE
->getQualifier())
3123 // A constant of pointer-to-member type.
3124 else if ((DRE
= dyn_cast
<DeclRefExpr
>(Arg
))) {
3125 if (ValueDecl
*VD
= dyn_cast
<ValueDecl
>(DRE
->getDecl())) {
3126 if (VD
->getType()->isMemberPointerType()) {
3127 if (isa
<NonTypeTemplateParmDecl
>(VD
) ||
3128 (isa
<VarDecl
>(VD
) &&
3129 Context
.getCanonicalType(VD
->getType()).isConstQualified())) {
3130 if (Arg
->isTypeDependent() || Arg
->isValueDependent())
3131 Converted
= TemplateArgument(Arg
);
3133 Converted
= TemplateArgument(VD
->getCanonicalDecl());
3143 return Diag(Arg
->getSourceRange().getBegin(),
3144 diag::err_template_arg_not_pointer_to_member_form
)
3145 << Arg
->getSourceRange();
3147 if (isa
<FieldDecl
>(DRE
->getDecl()) || isa
<CXXMethodDecl
>(DRE
->getDecl())) {
3148 assert((isa
<FieldDecl
>(DRE
->getDecl()) ||
3149 !cast
<CXXMethodDecl
>(DRE
->getDecl())->isStatic()) &&
3150 "Only non-static member pointers can make it here");
3152 // Okay: this is the address of a non-static member, and therefore
3153 // a member pointer constant.
3154 if (Arg
->isTypeDependent() || Arg
->isValueDependent())
3155 Converted
= TemplateArgument(Arg
);
3157 Converted
= TemplateArgument(DRE
->getDecl()->getCanonicalDecl());
3161 // We found something else, but we don't know specifically what it is.
3162 Diag(Arg
->getSourceRange().getBegin(),
3163 diag::err_template_arg_not_pointer_to_member_form
)
3164 << Arg
->getSourceRange();
3165 Diag(DRE
->getDecl()->getLocation(),
3166 diag::note_template_arg_refers_here
);
3170 /// \brief Check a template argument against its corresponding
3171 /// non-type template parameter.
3173 /// This routine implements the semantics of C++ [temp.arg.nontype].
3174 /// It returns true if an error occurred, and false otherwise. \p
3175 /// InstantiatedParamType is the type of the non-type template
3176 /// parameter after it has been instantiated.
3178 /// If no error was detected, Converted receives the converted template argument.
3179 bool Sema::CheckTemplateArgument(NonTypeTemplateParmDecl
*Param
,
3180 QualType InstantiatedParamType
, Expr
*&Arg
,
3181 TemplateArgument
&Converted
,
3182 CheckTemplateArgumentKind CTAK
) {
3183 SourceLocation StartLoc
= Arg
->getSourceRange().getBegin();
3185 // If either the parameter has a dependent type or the argument is
3186 // type-dependent, there's nothing we can check now.
3187 if (InstantiatedParamType
->isDependentType() || Arg
->isTypeDependent()) {
3188 // FIXME: Produce a cloned, canonical expression?
3189 Converted
= TemplateArgument(Arg
);
3193 // C++ [temp.arg.nontype]p5:
3194 // The following conversions are performed on each expression used
3195 // as a non-type template-argument. If a non-type
3196 // template-argument cannot be converted to the type of the
3197 // corresponding template-parameter then the program is
3200 // -- for a non-type template-parameter of integral or
3201 // enumeration type, integral promotions (4.5) and integral
3202 // conversions (4.7) are applied.
3203 QualType ParamType
= InstantiatedParamType
;
3204 QualType ArgType
= Arg
->getType();
3205 if (ParamType
->isIntegralOrEnumerationType()) {
3206 // C++ [temp.arg.nontype]p1:
3207 // A template-argument for a non-type, non-template
3208 // template-parameter shall be one of:
3210 // -- an integral constant-expression of integral or enumeration
3212 // -- the name of a non-type template-parameter; or
3213 SourceLocation NonConstantLoc
;
3215 if (!ArgType
->isIntegralOrEnumerationType()) {
3216 Diag(Arg
->getSourceRange().getBegin(),
3217 diag::err_template_arg_not_integral_or_enumeral
)
3218 << ArgType
<< Arg
->getSourceRange();
3219 Diag(Param
->getLocation(), diag::note_template_param_here
);
3221 } else if (!Arg
->isValueDependent() &&
3222 !Arg
->isIntegerConstantExpr(Value
, Context
, &NonConstantLoc
)) {
3223 Diag(NonConstantLoc
, diag::err_template_arg_not_ice
)
3224 << ArgType
<< Arg
->getSourceRange();
3228 // From here on out, all we care about are the unqualified forms
3229 // of the parameter and argument types.
3230 ParamType
= ParamType
.getUnqualifiedType();
3231 ArgType
= ArgType
.getUnqualifiedType();
3233 // Try to convert the argument to the parameter's type.
3234 if (Context
.hasSameType(ParamType
, ArgType
)) {
3235 // Okay: no conversion necessary
3236 } else if (CTAK
== CTAK_Deduced
) {
3237 // C++ [temp.deduct.type]p17:
3238 // If, in the declaration of a function template with a non-type
3239 // template-parameter, the non-type template- parameter is used
3240 // in an expression in the function parameter-list and, if the
3241 // corresponding template-argument is deduced, the
3242 // template-argument type shall match the type of the
3243 // template-parameter exactly, except that a template-argument
3244 // deduced from an array bound may be of any integral type.
3245 Diag(StartLoc
, diag::err_deduced_non_type_template_arg_type_mismatch
)
3246 << ArgType
<< ParamType
;
3247 Diag(Param
->getLocation(), diag::note_template_param_here
);
3249 } else if (ParamType
->isBooleanType()) {
3250 // This is an integral-to-boolean conversion.
3251 ImpCastExprToType(Arg
, ParamType
, CK_IntegralToBoolean
);
3252 } else if (IsIntegralPromotion(Arg
, ArgType
, ParamType
) ||
3253 !ParamType
->isEnumeralType()) {
3254 // This is an integral promotion or conversion.
3255 ImpCastExprToType(Arg
, ParamType
, CK_IntegralCast
);
3257 // We can't perform this conversion.
3258 Diag(Arg
->getSourceRange().getBegin(),
3259 diag::err_template_arg_not_convertible
)
3260 << Arg
->getType() << InstantiatedParamType
<< Arg
->getSourceRange();
3261 Diag(Param
->getLocation(), diag::note_template_param_here
);
3265 QualType IntegerType
= Context
.getCanonicalType(ParamType
);
3266 if (const EnumType
*Enum
= IntegerType
->getAs
<EnumType
>())
3267 IntegerType
= Context
.getCanonicalType(Enum
->getDecl()->getIntegerType());
3269 if (!Arg
->isValueDependent()) {
3270 llvm::APSInt OldValue
= Value
;
3272 // Coerce the template argument's value to the value it will have
3273 // based on the template parameter's type.
3274 unsigned AllowedBits
= Context
.getTypeSize(IntegerType
);
3275 if (Value
.getBitWidth() != AllowedBits
)
3276 Value
= Value
.extOrTrunc(AllowedBits
);
3277 Value
.setIsSigned(IntegerType
->isSignedIntegerType());
3279 // Complain if an unsigned parameter received a negative value.
3280 if (IntegerType
->isUnsignedIntegerType()
3281 && (OldValue
.isSigned() && OldValue
.isNegative())) {
3282 Diag(Arg
->getSourceRange().getBegin(), diag::warn_template_arg_negative
)
3283 << OldValue
.toString(10) << Value
.toString(10) << Param
->getType()
3284 << Arg
->getSourceRange();
3285 Diag(Param
->getLocation(), diag::note_template_param_here
);
3288 // Complain if we overflowed the template parameter's type.
3289 unsigned RequiredBits
;
3290 if (IntegerType
->isUnsignedIntegerType())
3291 RequiredBits
= OldValue
.getActiveBits();
3292 else if (OldValue
.isUnsigned())
3293 RequiredBits
= OldValue
.getActiveBits() + 1;
3295 RequiredBits
= OldValue
.getMinSignedBits();
3296 if (RequiredBits
> AllowedBits
) {
3297 Diag(Arg
->getSourceRange().getBegin(),
3298 diag::warn_template_arg_too_large
)
3299 << OldValue
.toString(10) << Value
.toString(10) << Param
->getType()
3300 << Arg
->getSourceRange();
3301 Diag(Param
->getLocation(), diag::note_template_param_here
);
3305 // Add the value of this argument to the list of converted
3306 // arguments. We use the bitwidth and signedness of the template
3308 if (Arg
->isValueDependent()) {
3309 // The argument is value-dependent. Create a new
3310 // TemplateArgument with the converted expression.
3311 Converted
= TemplateArgument(Arg
);
3315 Converted
= TemplateArgument(Value
,
3316 ParamType
->isEnumeralType() ? ParamType
3321 DeclAccessPair FoundResult
; // temporary for ResolveOverloadedFunction
3323 // C++0x [temp.arg.nontype]p5 bullets 2, 4 and 6 permit conversion
3324 // from a template argument of type std::nullptr_t to a non-type
3325 // template parameter of type pointer to object, pointer to
3326 // function, or pointer-to-member, respectively.
3327 if (ArgType
->isNullPtrType() &&
3328 (ParamType
->isPointerType() || ParamType
->isMemberPointerType())) {
3329 Converted
= TemplateArgument((NamedDecl
*)0);
3333 // Handle pointer-to-function, reference-to-function, and
3334 // pointer-to-member-function all in (roughly) the same way.
3335 if (// -- For a non-type template-parameter of type pointer to
3336 // function, only the function-to-pointer conversion (4.3) is
3337 // applied. If the template-argument represents a set of
3338 // overloaded functions (or a pointer to such), the matching
3339 // function is selected from the set (13.4).
3340 (ParamType
->isPointerType() &&
3341 ParamType
->getAs
<PointerType
>()->getPointeeType()->isFunctionType()) ||
3342 // -- For a non-type template-parameter of type reference to
3343 // function, no conversions apply. If the template-argument
3344 // represents a set of overloaded functions, the matching
3345 // function is selected from the set (13.4).
3346 (ParamType
->isReferenceType() &&
3347 ParamType
->getAs
<ReferenceType
>()->getPointeeType()->isFunctionType()) ||
3348 // -- For a non-type template-parameter of type pointer to
3349 // member function, no conversions apply. If the
3350 // template-argument represents a set of overloaded member
3351 // functions, the matching member function is selected from
3353 (ParamType
->isMemberPointerType() &&
3354 ParamType
->getAs
<MemberPointerType
>()->getPointeeType()
3355 ->isFunctionType())) {
3357 if (Arg
->getType() == Context
.OverloadTy
) {
3358 if (FunctionDecl
*Fn
= ResolveAddressOfOverloadedFunction(Arg
, ParamType
,
3361 if (DiagnoseUseOfDecl(Fn
, Arg
->getSourceRange().getBegin()))
3364 Arg
= FixOverloadedFunctionReference(Arg
, FoundResult
, Fn
);
3365 ArgType
= Arg
->getType();
3370 if (!ParamType
->isMemberPointerType())
3371 return CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param
,
3375 if (IsQualificationConversion(ArgType
, ParamType
.getNonReferenceType())) {
3376 ImpCastExprToType(Arg
, ParamType
, CK_NoOp
, CastCategory(Arg
));
3377 } else if (!Context
.hasSameUnqualifiedType(ArgType
,
3378 ParamType
.getNonReferenceType())) {
3379 // We can't perform this conversion.
3380 Diag(Arg
->getSourceRange().getBegin(),
3381 diag::err_template_arg_not_convertible
)
3382 << Arg
->getType() << InstantiatedParamType
<< Arg
->getSourceRange();
3383 Diag(Param
->getLocation(), diag::note_template_param_here
);
3387 return CheckTemplateArgumentPointerToMember(Arg
, Converted
);
3390 if (ParamType
->isPointerType()) {
3391 // -- for a non-type template-parameter of type pointer to
3392 // object, qualification conversions (4.4) and the
3393 // array-to-pointer conversion (4.2) are applied.
3394 // C++0x also allows a value of std::nullptr_t.
3395 assert(ParamType
->getPointeeType()->isIncompleteOrObjectType() &&
3396 "Only object pointers allowed here");
3398 return CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param
,
3403 if (const ReferenceType
*ParamRefType
= ParamType
->getAs
<ReferenceType
>()) {
3404 // -- For a non-type template-parameter of type reference to
3405 // object, no conversions apply. The type referred to by the
3406 // reference may be more cv-qualified than the (otherwise
3407 // identical) type of the template-argument. The
3408 // template-parameter is bound directly to the
3409 // template-argument, which must be an lvalue.
3410 assert(ParamRefType
->getPointeeType()->isIncompleteOrObjectType() &&
3411 "Only object references allowed here");
3413 if (Arg
->getType() == Context
.OverloadTy
) {
3414 if (FunctionDecl
*Fn
= ResolveAddressOfOverloadedFunction(Arg
,
3415 ParamRefType
->getPointeeType(),
3418 if (DiagnoseUseOfDecl(Fn
, Arg
->getSourceRange().getBegin()))
3421 Arg
= FixOverloadedFunctionReference(Arg
, FoundResult
, Fn
);
3422 ArgType
= Arg
->getType();
3427 return CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param
,
3432 // -- For a non-type template-parameter of type pointer to data
3433 // member, qualification conversions (4.4) are applied.
3434 assert(ParamType
->isMemberPointerType() && "Only pointers to members remain");
3436 if (Context
.hasSameUnqualifiedType(ParamType
, ArgType
)) {
3437 // Types match exactly: nothing more to do here.
3438 } else if (IsQualificationConversion(ArgType
, ParamType
)) {
3439 ImpCastExprToType(Arg
, ParamType
, CK_NoOp
, CastCategory(Arg
));
3441 // We can't perform this conversion.
3442 Diag(Arg
->getSourceRange().getBegin(),
3443 diag::err_template_arg_not_convertible
)
3444 << Arg
->getType() << InstantiatedParamType
<< Arg
->getSourceRange();
3445 Diag(Param
->getLocation(), diag::note_template_param_here
);
3449 return CheckTemplateArgumentPointerToMember(Arg
, Converted
);
3452 /// \brief Check a template argument against its corresponding
3453 /// template template parameter.
3455 /// This routine implements the semantics of C++ [temp.arg.template].
3456 /// It returns true if an error occurred, and false otherwise.
3457 bool Sema::CheckTemplateArgument(TemplateTemplateParmDecl
*Param
,
3458 const TemplateArgumentLoc
&Arg
) {
3459 TemplateName Name
= Arg
.getArgument().getAsTemplate();
3460 TemplateDecl
*Template
= Name
.getAsTemplateDecl();
3462 // Any dependent template name is fine.
3463 assert(Name
.isDependent() && "Non-dependent template isn't a declaration?");
3467 // C++ [temp.arg.template]p1:
3468 // A template-argument for a template template-parameter shall be
3469 // the name of a class template, expressed as id-expression. Only
3470 // primary class templates are considered when matching the
3471 // template template argument with the corresponding parameter;
3472 // partial specializations are not considered even if their
3473 // parameter lists match that of the template template parameter.
3475 // Note that we also allow template template parameters here, which
3476 // will happen when we are dealing with, e.g., class template
3477 // partial specializations.
3478 if (!isa
<ClassTemplateDecl
>(Template
) &&
3479 !isa
<TemplateTemplateParmDecl
>(Template
)) {
3480 assert(isa
<FunctionTemplateDecl
>(Template
) &&
3481 "Only function templates are possible here");
3482 Diag(Arg
.getLocation(), diag::err_template_arg_not_class_template
);
3483 Diag(Template
->getLocation(), diag::note_template_arg_refers_here_func
)
3487 return !TemplateParameterListsAreEqual(Template
->getTemplateParameters(),
3488 Param
->getTemplateParameters(),
3490 TPL_TemplateTemplateArgumentMatch
,
3494 /// \brief Given a non-type template argument that refers to a
3495 /// declaration and the type of its corresponding non-type template
3496 /// parameter, produce an expression that properly refers to that
3499 Sema::BuildExpressionFromDeclTemplateArgument(const TemplateArgument
&Arg
,
3501 SourceLocation Loc
) {
3502 assert(Arg
.getKind() == TemplateArgument::Declaration
&&
3503 "Only declaration template arguments permitted here");
3504 ValueDecl
*VD
= cast
<ValueDecl
>(Arg
.getAsDecl());
3506 if (VD
->getDeclContext()->isRecord() &&
3507 (isa
<CXXMethodDecl
>(VD
) || isa
<FieldDecl
>(VD
))) {
3508 // If the value is a class member, we might have a pointer-to-member.
3509 // Determine whether the non-type template template parameter is of
3510 // pointer-to-member type. If so, we need to build an appropriate
3511 // expression for a pointer-to-member, since a "normal" DeclRefExpr
3512 // would refer to the member itself.
3513 if (ParamType
->isMemberPointerType()) {
3515 = Context
.getTypeDeclType(cast
<RecordDecl
>(VD
->getDeclContext()));
3516 NestedNameSpecifier
*Qualifier
3517 = NestedNameSpecifier::Create(Context
, 0, false,
3518 ClassType
.getTypePtr());
3520 SS
.setScopeRep(Qualifier
);
3522 // The actual value-ness of this is unimportant, but for
3523 // internal consistency's sake, references to instance methods
3525 ExprValueKind VK
= VK_LValue
;
3526 if (isa
<CXXMethodDecl
>(VD
) && cast
<CXXMethodDecl
>(VD
)->isInstance())
3529 ExprResult RefExpr
= BuildDeclRefExpr(VD
,
3530 VD
->getType().getNonReferenceType(),
3534 if (RefExpr
.isInvalid())
3537 RefExpr
= CreateBuiltinUnaryOp(Loc
, UO_AddrOf
, RefExpr
.get());
3539 // We might need to perform a trailing qualification conversion, since
3540 // the element type on the parameter could be more qualified than the
3541 // element type in the expression we constructed.
3542 if (IsQualificationConversion(((Expr
*) RefExpr
.get())->getType(),
3543 ParamType
.getUnqualifiedType())) {
3544 Expr
*RefE
= RefExpr
.takeAs
<Expr
>();
3545 ImpCastExprToType(RefE
, ParamType
.getUnqualifiedType(), CK_NoOp
);
3546 RefExpr
= Owned(RefE
);
3549 assert(!RefExpr
.isInvalid() &&
3550 Context
.hasSameType(((Expr
*) RefExpr
.get())->getType(),
3551 ParamType
.getUnqualifiedType()));
3552 return move(RefExpr
);
3556 QualType T
= VD
->getType().getNonReferenceType();
3557 if (ParamType
->isPointerType()) {
3558 // When the non-type template parameter is a pointer, take the
3559 // address of the declaration.
3560 ExprResult RefExpr
= BuildDeclRefExpr(VD
, T
, VK_LValue
, Loc
);
3561 if (RefExpr
.isInvalid())
3564 if (T
->isFunctionType() || T
->isArrayType()) {
3565 // Decay functions and arrays.
3566 Expr
*RefE
= (Expr
*)RefExpr
.get();
3567 DefaultFunctionArrayConversion(RefE
);
3568 if (RefE
!= RefExpr
.get()) {
3570 RefExpr
= Owned(RefE
);
3573 return move(RefExpr
);
3576 // Take the address of everything else
3577 return CreateBuiltinUnaryOp(Loc
, UO_AddrOf
, RefExpr
.get());
3580 ExprValueKind VK
= VK_RValue
;
3582 // If the non-type template parameter has reference type, qualify the
3583 // resulting declaration reference with the extra qualifiers on the
3584 // type that the reference refers to.
3585 if (const ReferenceType
*TargetRef
= ParamType
->getAs
<ReferenceType
>()) {
3587 T
= Context
.getQualifiedType(T
,
3588 TargetRef
->getPointeeType().getQualifiers());
3591 return BuildDeclRefExpr(VD
, T
, VK
, Loc
);
3594 /// \brief Construct a new expression that refers to the given
3595 /// integral template argument with the given source-location
3598 /// This routine takes care of the mapping from an integral template
3599 /// argument (which may have any integral type) to the appropriate
3602 Sema::BuildExpressionFromIntegralTemplateArgument(const TemplateArgument
&Arg
,
3603 SourceLocation Loc
) {
3604 assert(Arg
.getKind() == TemplateArgument::Integral
&&
3605 "Operation is only valid for integral template arguments");
3606 QualType T
= Arg
.getIntegralType();
3607 if (T
->isCharType() || T
->isWideCharType())
3608 return Owned(new (Context
) CharacterLiteral(
3609 Arg
.getAsIntegral()->getZExtValue(),
3610 T
->isWideCharType(),
3613 if (T
->isBooleanType())
3614 return Owned(new (Context
) CXXBoolLiteralExpr(
3615 Arg
.getAsIntegral()->getBoolValue(),
3620 if (const EnumType
*ET
= T
->getAs
<EnumType
>())
3621 BT
= ET
->getDecl()->getPromotionType();
3625 Expr
*E
= IntegerLiteral::Create(Context
, *Arg
.getAsIntegral(), BT
, Loc
);
3626 ImpCastExprToType(E
, T
, CK_IntegralCast
);
3631 /// \brief Match two template parameters within template parameter lists.
3632 static bool MatchTemplateParameterKind(Sema
&S
, NamedDecl
*New
, NamedDecl
*Old
,
3634 Sema::TemplateParameterListEqualKind Kind
,
3635 SourceLocation TemplateArgLoc
) {
3636 // Check the actual kind (type, non-type, template).
3637 if (Old
->getKind() != New
->getKind()) {
3639 unsigned NextDiag
= diag::err_template_param_different_kind
;
3640 if (TemplateArgLoc
.isValid()) {
3641 S
.Diag(TemplateArgLoc
, diag::err_template_arg_template_params_mismatch
);
3642 NextDiag
= diag::note_template_param_different_kind
;
3644 S
.Diag(New
->getLocation(), NextDiag
)
3645 << (Kind
!= Sema::TPL_TemplateMatch
);
3646 S
.Diag(Old
->getLocation(), diag::note_template_prev_declaration
)
3647 << (Kind
!= Sema::TPL_TemplateMatch
);
3653 // Check that both are parameter packs are neither are parameter packs.
3654 // However, if we are matching a template template argument to a
3655 // template template parameter, the template template parameter can have
3656 // a parameter pack where the template template argument does not.
3657 if (Old
->isTemplateParameterPack() != New
->isTemplateParameterPack() &&
3658 !(Kind
== Sema::TPL_TemplateTemplateArgumentMatch
&&
3659 Old
->isTemplateParameterPack())) {
3661 unsigned NextDiag
= diag::err_template_parameter_pack_non_pack
;
3662 if (TemplateArgLoc
.isValid()) {
3663 S
.Diag(TemplateArgLoc
,
3664 diag::err_template_arg_template_params_mismatch
);
3665 NextDiag
= diag::note_template_parameter_pack_non_pack
;
3668 unsigned ParamKind
= isa
<TemplateTypeParmDecl
>(New
)? 0
3669 : isa
<NonTypeTemplateParmDecl
>(New
)? 1
3671 S
.Diag(New
->getLocation(), NextDiag
)
3672 << ParamKind
<< New
->isParameterPack();
3673 S
.Diag(Old
->getLocation(), diag::note_template_parameter_pack_here
)
3674 << ParamKind
<< Old
->isParameterPack();
3680 // For non-type template parameters, check the type of the parameter.
3681 if (NonTypeTemplateParmDecl
*OldNTTP
3682 = dyn_cast
<NonTypeTemplateParmDecl
>(Old
)) {
3683 NonTypeTemplateParmDecl
*NewNTTP
= cast
<NonTypeTemplateParmDecl
>(New
);
3685 // If we are matching a template template argument to a template
3686 // template parameter and one of the non-type template parameter types
3687 // is dependent, then we must wait until template instantiation time
3688 // to actually compare the arguments.
3689 if (Kind
== Sema::TPL_TemplateTemplateArgumentMatch
&&
3690 (OldNTTP
->getType()->isDependentType() ||
3691 NewNTTP
->getType()->isDependentType()))
3694 if (!S
.Context
.hasSameType(OldNTTP
->getType(), NewNTTP
->getType())) {
3696 unsigned NextDiag
= diag::err_template_nontype_parm_different_type
;
3697 if (TemplateArgLoc
.isValid()) {
3698 S
.Diag(TemplateArgLoc
,
3699 diag::err_template_arg_template_params_mismatch
);
3700 NextDiag
= diag::note_template_nontype_parm_different_type
;
3702 S
.Diag(NewNTTP
->getLocation(), NextDiag
)
3703 << NewNTTP
->getType()
3704 << (Kind
!= Sema::TPL_TemplateMatch
);
3705 S
.Diag(OldNTTP
->getLocation(),
3706 diag::note_template_nontype_parm_prev_declaration
)
3707 << OldNTTP
->getType();
3716 // For template template parameters, check the template parameter types.
3717 // The template parameter lists of template template
3718 // parameters must agree.
3719 if (TemplateTemplateParmDecl
*OldTTP
3720 = dyn_cast
<TemplateTemplateParmDecl
>(Old
)) {
3721 TemplateTemplateParmDecl
*NewTTP
= cast
<TemplateTemplateParmDecl
>(New
);
3722 return S
.TemplateParameterListsAreEqual(NewTTP
->getTemplateParameters(),
3723 OldTTP
->getTemplateParameters(),
3725 (Kind
== Sema::TPL_TemplateMatch
3726 ? Sema::TPL_TemplateTemplateParmMatch
3734 /// \brief Diagnose a known arity mismatch when comparing template argument
3737 void DiagnoseTemplateParameterListArityMismatch(Sema
&S
,
3738 TemplateParameterList
*New
,
3739 TemplateParameterList
*Old
,
3740 Sema::TemplateParameterListEqualKind Kind
,
3741 SourceLocation TemplateArgLoc
) {
3742 unsigned NextDiag
= diag::err_template_param_list_different_arity
;
3743 if (TemplateArgLoc
.isValid()) {
3744 S
.Diag(TemplateArgLoc
, diag::err_template_arg_template_params_mismatch
);
3745 NextDiag
= diag::note_template_param_list_different_arity
;
3747 S
.Diag(New
->getTemplateLoc(), NextDiag
)
3748 << (New
->size() > Old
->size())
3749 << (Kind
!= Sema::TPL_TemplateMatch
)
3750 << SourceRange(New
->getTemplateLoc(), New
->getRAngleLoc());
3751 S
.Diag(Old
->getTemplateLoc(), diag::note_template_prev_declaration
)
3752 << (Kind
!= Sema::TPL_TemplateMatch
)
3753 << SourceRange(Old
->getTemplateLoc(), Old
->getRAngleLoc());
3756 /// \brief Determine whether the given template parameter lists are
3759 /// \param New The new template parameter list, typically written in the
3760 /// source code as part of a new template declaration.
3762 /// \param Old The old template parameter list, typically found via
3763 /// name lookup of the template declared with this template parameter
3766 /// \param Complain If true, this routine will produce a diagnostic if
3767 /// the template parameter lists are not equivalent.
3769 /// \param Kind describes how we are to match the template parameter lists.
3771 /// \param TemplateArgLoc If this source location is valid, then we
3772 /// are actually checking the template parameter list of a template
3773 /// argument (New) against the template parameter list of its
3774 /// corresponding template template parameter (Old). We produce
3775 /// slightly different diagnostics in this scenario.
3777 /// \returns True if the template parameter lists are equal, false
3780 Sema::TemplateParameterListsAreEqual(TemplateParameterList
*New
,
3781 TemplateParameterList
*Old
,
3783 TemplateParameterListEqualKind Kind
,
3784 SourceLocation TemplateArgLoc
) {
3785 if (Old
->size() != New
->size() && Kind
!= TPL_TemplateTemplateArgumentMatch
) {
3787 DiagnoseTemplateParameterListArityMismatch(*this, New
, Old
, Kind
,
3793 // C++0x [temp.arg.template]p3:
3794 // A template-argument matches a template template-parameter (call it P)
3795 // when each of the template parameters in the template-parameter-list of
3796 // the template-argument’s corresponding class template or template alias
3797 // (call it A) matches the corresponding template parameter in the
3798 // template-parameter-list of P. [...]
3799 TemplateParameterList::iterator NewParm
= New
->begin();
3800 TemplateParameterList::iterator NewParmEnd
= New
->end();
3801 for (TemplateParameterList::iterator OldParm
= Old
->begin(),
3802 OldParmEnd
= Old
->end();
3803 OldParm
!= OldParmEnd
; ++OldParm
) {
3804 if (Kind
!= TPL_TemplateTemplateArgumentMatch
||
3805 !(*OldParm
)->isTemplateParameterPack()) {
3806 if (NewParm
== NewParmEnd
) {
3808 DiagnoseTemplateParameterListArityMismatch(*this, New
, Old
, Kind
,
3814 if (!MatchTemplateParameterKind(*this, *NewParm
, *OldParm
, Complain
,
3815 Kind
, TemplateArgLoc
))
3822 // C++0x [temp.arg.template]p3:
3823 // [...] When P’s template- parameter-list contains a template parameter
3824 // pack (14.5.3), the template parameter pack will match zero or more
3825 // template parameters or template parameter packs in the
3826 // template-parameter-list of A with the same type and form as the
3827 // template parameter pack in P (ignoring whether those template
3828 // parameters are template parameter packs).
3829 for (; NewParm
!= NewParmEnd
; ++NewParm
) {
3830 if (!MatchTemplateParameterKind(*this, *NewParm
, *OldParm
, Complain
,
3831 Kind
, TemplateArgLoc
))
3836 // Make sure we exhausted all of the arguments.
3837 if (NewParm
!= NewParmEnd
) {
3839 DiagnoseTemplateParameterListArityMismatch(*this, New
, Old
, Kind
,
3848 /// \brief Check whether a template can be declared within this scope.
3850 /// If the template declaration is valid in this scope, returns
3851 /// false. Otherwise, issues a diagnostic and returns true.
3853 Sema::CheckTemplateDeclScope(Scope
*S
, TemplateParameterList
*TemplateParams
) {
3854 // Find the nearest enclosing declaration scope.
3855 while ((S
->getFlags() & Scope::DeclScope
) == 0 ||
3856 (S
->getFlags() & Scope::TemplateParamScope
) != 0)
3860 // A template-declaration can appear only as a namespace scope or
3861 // class scope declaration.
3862 DeclContext
*Ctx
= static_cast<DeclContext
*>(S
->getEntity());
3863 if (Ctx
&& isa
<LinkageSpecDecl
>(Ctx
) &&
3864 cast
<LinkageSpecDecl
>(Ctx
)->getLanguage() != LinkageSpecDecl::lang_cxx
)
3865 return Diag(TemplateParams
->getTemplateLoc(), diag::err_template_linkage
)
3866 << TemplateParams
->getSourceRange();
3868 while (Ctx
&& isa
<LinkageSpecDecl
>(Ctx
))
3869 Ctx
= Ctx
->getParent();
3871 if (Ctx
&& (Ctx
->isFileContext() || Ctx
->isRecord()))
3874 return Diag(TemplateParams
->getTemplateLoc(),
3875 diag::err_template_outside_namespace_or_class_scope
)
3876 << TemplateParams
->getSourceRange();
3879 /// \brief Determine what kind of template specialization the given declaration
3881 static TemplateSpecializationKind
getTemplateSpecializationKind(NamedDecl
*D
) {
3883 return TSK_Undeclared
;
3885 if (CXXRecordDecl
*Record
= dyn_cast
<CXXRecordDecl
>(D
))
3886 return Record
->getTemplateSpecializationKind();
3887 if (FunctionDecl
*Function
= dyn_cast
<FunctionDecl
>(D
))
3888 return Function
->getTemplateSpecializationKind();
3889 if (VarDecl
*Var
= dyn_cast
<VarDecl
>(D
))
3890 return Var
->getTemplateSpecializationKind();
3892 return TSK_Undeclared
;
3895 /// \brief Check whether a specialization is well-formed in the current
3898 /// This routine determines whether a template specialization can be declared
3899 /// in the current context (C++ [temp.expl.spec]p2).
3901 /// \param S the semantic analysis object for which this check is being
3904 /// \param Specialized the entity being specialized or instantiated, which
3905 /// may be a kind of template (class template, function template, etc.) or
3906 /// a member of a class template (member function, static data member,
3909 /// \param PrevDecl the previous declaration of this entity, if any.
3911 /// \param Loc the location of the explicit specialization or instantiation of
3914 /// \param IsPartialSpecialization whether this is a partial specialization of
3915 /// a class template.
3917 /// \returns true if there was an error that we cannot recover from, false
3919 static bool CheckTemplateSpecializationScope(Sema
&S
,
3920 NamedDecl
*Specialized
,
3921 NamedDecl
*PrevDecl
,
3923 bool IsPartialSpecialization
) {
3924 // Keep these "kind" numbers in sync with the %select statements in the
3925 // various diagnostics emitted by this routine.
3927 bool isTemplateSpecialization
= false;
3928 if (isa
<ClassTemplateDecl
>(Specialized
)) {
3929 EntityKind
= IsPartialSpecialization
? 1 : 0;
3930 isTemplateSpecialization
= true;
3931 } else if (isa
<FunctionTemplateDecl
>(Specialized
)) {
3933 isTemplateSpecialization
= true;
3934 } else if (isa
<CXXMethodDecl
>(Specialized
))
3936 else if (isa
<VarDecl
>(Specialized
))
3938 else if (isa
<RecordDecl
>(Specialized
))
3941 S
.Diag(Loc
, diag::err_template_spec_unknown_kind
);
3942 S
.Diag(Specialized
->getLocation(), diag::note_specialized_entity
);
3946 // C++ [temp.expl.spec]p2:
3947 // An explicit specialization shall be declared in the namespace
3948 // of which the template is a member, or, for member templates, in
3949 // the namespace of which the enclosing class or enclosing class
3950 // template is a member. An explicit specialization of a member
3951 // function, member class or static data member of a class
3952 // template shall be declared in the namespace of which the class
3953 // template is a member. Such a declaration may also be a
3954 // definition. If the declaration is not a definition, the
3955 // specialization may be defined later in the name- space in which
3956 // the explicit specialization was declared, or in a namespace
3957 // that encloses the one in which the explicit specialization was
3959 if (S
.CurContext
->getRedeclContext()->isFunctionOrMethod()) {
3960 S
.Diag(Loc
, diag::err_template_spec_decl_function_scope
)
3965 if (S
.CurContext
->isRecord() && !IsPartialSpecialization
) {
3966 S
.Diag(Loc
, diag::err_template_spec_decl_class_scope
)
3971 // C++ [temp.class.spec]p6:
3972 // A class template partial specialization may be declared or redeclared
3973 // in any namespace scope in which its definition may be defined (14.5.1
3975 bool ComplainedAboutScope
= false;
3976 DeclContext
*SpecializedContext
3977 = Specialized
->getDeclContext()->getEnclosingNamespaceContext();
3978 DeclContext
*DC
= S
.CurContext
->getEnclosingNamespaceContext();
3980 getTemplateSpecializationKind(PrevDecl
) == TSK_Undeclared
||
3981 getTemplateSpecializationKind(PrevDecl
) == TSK_ImplicitInstantiation
)){
3982 // C++ [temp.exp.spec]p2:
3983 // An explicit specialization shall be declared in the namespace of which
3984 // the template is a member, or, for member templates, in the namespace
3985 // of which the enclosing class or enclosing class template is a member.
3986 // An explicit specialization of a member function, member class or
3987 // static data member of a class template shall be declared in the
3988 // namespace of which the class template is a member.
3990 // C++0x [temp.expl.spec]p2:
3991 // An explicit specialization shall be declared in a namespace enclosing
3992 // the specialized template.
3993 if (!DC
->InEnclosingNamespaceSetOf(SpecializedContext
) &&
3994 !(S
.getLangOptions().CPlusPlus0x
&& DC
->Encloses(SpecializedContext
))) {
3995 bool IsCPlusPlus0xExtension
3996 = !S
.getLangOptions().CPlusPlus0x
&& DC
->Encloses(SpecializedContext
);
3997 if (isa
<TranslationUnitDecl
>(SpecializedContext
))
3998 S
.Diag(Loc
, IsCPlusPlus0xExtension
3999 ? diag::ext_template_spec_decl_out_of_scope_global
4000 : diag::err_template_spec_decl_out_of_scope_global
)
4001 << EntityKind
<< Specialized
;
4002 else if (isa
<NamespaceDecl
>(SpecializedContext
))
4003 S
.Diag(Loc
, IsCPlusPlus0xExtension
4004 ? diag::ext_template_spec_decl_out_of_scope
4005 : diag::err_template_spec_decl_out_of_scope
)
4006 << EntityKind
<< Specialized
4007 << cast
<NamedDecl
>(SpecializedContext
);
4009 S
.Diag(Specialized
->getLocation(), diag::note_specialized_entity
);
4010 ComplainedAboutScope
= true;
4014 // Make sure that this redeclaration (or definition) occurs in an enclosing
4016 // Note that HandleDeclarator() performs this check for explicit
4017 // specializations of function templates, static data members, and member
4018 // functions, so we skip the check here for those kinds of entities.
4019 // FIXME: HandleDeclarator's diagnostics aren't quite as good, though.
4020 // Should we refactor that check, so that it occurs later?
4021 if (!ComplainedAboutScope
&& !DC
->Encloses(SpecializedContext
) &&
4022 !(isa
<FunctionTemplateDecl
>(Specialized
) || isa
<VarDecl
>(Specialized
) ||
4023 isa
<FunctionDecl
>(Specialized
))) {
4024 if (isa
<TranslationUnitDecl
>(SpecializedContext
))
4025 S
.Diag(Loc
, diag::err_template_spec_redecl_global_scope
)
4026 << EntityKind
<< Specialized
;
4027 else if (isa
<NamespaceDecl
>(SpecializedContext
))
4028 S
.Diag(Loc
, diag::err_template_spec_redecl_out_of_scope
)
4029 << EntityKind
<< Specialized
4030 << cast
<NamedDecl
>(SpecializedContext
);
4032 S
.Diag(Specialized
->getLocation(), diag::note_specialized_entity
);
4035 // FIXME: check for specialization-after-instantiation errors and such.
4040 /// \brief Subroutine of Sema::CheckClassTemplatePartialSpecializationArgs
4041 /// that checks non-type template partial specialization arguments.
4042 static bool CheckNonTypeClassTemplatePartialSpecializationArgs(Sema
&S
,
4043 NonTypeTemplateParmDecl
*Param
,
4044 const TemplateArgument
*Args
,
4046 for (unsigned I
= 0; I
!= NumArgs
; ++I
) {
4047 if (Args
[I
].getKind() == TemplateArgument::Pack
) {
4048 if (CheckNonTypeClassTemplatePartialSpecializationArgs(S
, Param
,
4049 Args
[I
].pack_begin(),
4050 Args
[I
].pack_size()))
4056 Expr
*ArgExpr
= Args
[I
].getAsExpr();
4061 // We can have a pack expansion of any of the bullets below.
4062 if (PackExpansionExpr
*Expansion
= dyn_cast
<PackExpansionExpr
>(ArgExpr
))
4063 ArgExpr
= Expansion
->getPattern();
4065 // Strip off any implicit casts we added as part of type checking.
4066 while (ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(ArgExpr
))
4067 ArgExpr
= ICE
->getSubExpr();
4069 // C++ [temp.class.spec]p8:
4070 // A non-type argument is non-specialized if it is the name of a
4071 // non-type parameter. All other non-type arguments are
4074 // Below, we check the two conditions that only apply to
4075 // specialized non-type arguments, so skip any non-specialized
4077 if (DeclRefExpr
*DRE
= dyn_cast
<DeclRefExpr
>(ArgExpr
))
4078 if (isa
<NonTypeTemplateParmDecl
>(DRE
->getDecl()))
4081 // C++ [temp.class.spec]p9:
4082 // Within the argument list of a class template partial
4083 // specialization, the following restrictions apply:
4084 // -- A partially specialized non-type argument expression
4085 // shall not involve a template parameter of the partial
4086 // specialization except when the argument expression is a
4087 // simple identifier.
4088 if (ArgExpr
->isTypeDependent() || ArgExpr
->isValueDependent()) {
4089 S
.Diag(ArgExpr
->getLocStart(),
4090 diag::err_dependent_non_type_arg_in_partial_spec
)
4091 << ArgExpr
->getSourceRange();
4095 // -- The type of a template parameter corresponding to a
4096 // specialized non-type argument shall not be dependent on a
4097 // parameter of the specialization.
4098 if (Param
->getType()->isDependentType()) {
4099 S
.Diag(ArgExpr
->getLocStart(),
4100 diag::err_dependent_typed_non_type_arg_in_partial_spec
)
4102 << ArgExpr
->getSourceRange();
4103 S
.Diag(Param
->getLocation(), diag::note_template_param_here
);
4111 /// \brief Check the non-type template arguments of a class template
4112 /// partial specialization according to C++ [temp.class.spec]p9.
4114 /// \param TemplateParams the template parameters of the primary class
4117 /// \param TemplateArg the template arguments of the class template
4118 /// partial specialization.
4120 /// \returns true if there was an error, false otherwise.
4121 static bool CheckClassTemplatePartialSpecializationArgs(Sema
&S
,
4122 TemplateParameterList
*TemplateParams
,
4123 llvm::SmallVectorImpl
<TemplateArgument
> &TemplateArgs
) {
4124 const TemplateArgument
*ArgList
= TemplateArgs
.data();
4126 for (unsigned I
= 0, N
= TemplateParams
->size(); I
!= N
; ++I
) {
4127 NonTypeTemplateParmDecl
*Param
4128 = dyn_cast
<NonTypeTemplateParmDecl
>(TemplateParams
->getParam(I
));
4132 if (CheckNonTypeClassTemplatePartialSpecializationArgs(S
, Param
,
4140 /// \brief Retrieve the previous declaration of the given declaration.
4141 static NamedDecl
*getPreviousDecl(NamedDecl
*ND
) {
4142 if (VarDecl
*VD
= dyn_cast
<VarDecl
>(ND
))
4143 return VD
->getPreviousDeclaration();
4144 if (FunctionDecl
*FD
= dyn_cast
<FunctionDecl
>(ND
))
4145 return FD
->getPreviousDeclaration();
4146 if (TagDecl
*TD
= dyn_cast
<TagDecl
>(ND
))
4147 return TD
->getPreviousDeclaration();
4148 if (TypedefDecl
*TD
= dyn_cast
<TypedefDecl
>(ND
))
4149 return TD
->getPreviousDeclaration();
4150 if (FunctionTemplateDecl
*FTD
= dyn_cast
<FunctionTemplateDecl
>(ND
))
4151 return FTD
->getPreviousDeclaration();
4152 if (ClassTemplateDecl
*CTD
= dyn_cast
<ClassTemplateDecl
>(ND
))
4153 return CTD
->getPreviousDeclaration();
4158 Sema::ActOnClassTemplateSpecialization(Scope
*S
, unsigned TagSpec
,
4160 SourceLocation KWLoc
,
4162 TemplateTy TemplateD
,
4163 SourceLocation TemplateNameLoc
,
4164 SourceLocation LAngleLoc
,
4165 ASTTemplateArgsPtr TemplateArgsIn
,
4166 SourceLocation RAngleLoc
,
4167 AttributeList
*Attr
,
4168 MultiTemplateParamsArg TemplateParameterLists
) {
4169 assert(TUK
!= TUK_Reference
&& "References are not specializations");
4171 // Find the class template we're specializing
4172 TemplateName Name
= TemplateD
.getAsVal
<TemplateName
>();
4173 ClassTemplateDecl
*ClassTemplate
4174 = dyn_cast_or_null
<ClassTemplateDecl
>(Name
.getAsTemplateDecl());
4176 if (!ClassTemplate
) {
4177 Diag(TemplateNameLoc
, diag::err_not_class_template_specialization
)
4178 << (Name
.getAsTemplateDecl() &&
4179 isa
<TemplateTemplateParmDecl
>(Name
.getAsTemplateDecl()));
4183 bool isExplicitSpecialization
= false;
4184 bool isPartialSpecialization
= false;
4186 // Check the validity of the template headers that introduce this
4188 // FIXME: We probably shouldn't complain about these headers for
4189 // friend declarations.
4190 bool Invalid
= false;
4191 TemplateParameterList
*TemplateParams
4192 = MatchTemplateParametersToScopeSpecifier(TemplateNameLoc
, SS
,
4193 (TemplateParameterList
**)TemplateParameterLists
.get(),
4194 TemplateParameterLists
.size(),
4196 isExplicitSpecialization
,
4201 unsigned NumMatchedTemplateParamLists
= TemplateParameterLists
.size();
4203 --NumMatchedTemplateParamLists
;
4205 if (TemplateParams
&& TemplateParams
->size() > 0) {
4206 isPartialSpecialization
= true;
4208 if (TUK
== TUK_Friend
) {
4209 Diag(KWLoc
, diag::err_partial_specialization_friend
)
4210 << SourceRange(LAngleLoc
, RAngleLoc
);
4214 // C++ [temp.class.spec]p10:
4215 // The template parameter list of a specialization shall not
4216 // contain default template argument values.
4217 for (unsigned I
= 0, N
= TemplateParams
->size(); I
!= N
; ++I
) {
4218 Decl
*Param
= TemplateParams
->getParam(I
);
4219 if (TemplateTypeParmDecl
*TTP
= dyn_cast
<TemplateTypeParmDecl
>(Param
)) {
4220 if (TTP
->hasDefaultArgument()) {
4221 Diag(TTP
->getDefaultArgumentLoc(),
4222 diag::err_default_arg_in_partial_spec
);
4223 TTP
->removeDefaultArgument();
4225 } else if (NonTypeTemplateParmDecl
*NTTP
4226 = dyn_cast
<NonTypeTemplateParmDecl
>(Param
)) {
4227 if (Expr
*DefArg
= NTTP
->getDefaultArgument()) {
4228 Diag(NTTP
->getDefaultArgumentLoc(),
4229 diag::err_default_arg_in_partial_spec
)
4230 << DefArg
->getSourceRange();
4231 NTTP
->removeDefaultArgument();
4234 TemplateTemplateParmDecl
*TTP
= cast
<TemplateTemplateParmDecl
>(Param
);
4235 if (TTP
->hasDefaultArgument()) {
4236 Diag(TTP
->getDefaultArgument().getLocation(),
4237 diag::err_default_arg_in_partial_spec
)
4238 << TTP
->getDefaultArgument().getSourceRange();
4239 TTP
->removeDefaultArgument();
4243 } else if (TemplateParams
) {
4244 if (TUK
== TUK_Friend
)
4245 Diag(KWLoc
, diag::err_template_spec_friend
)
4246 << FixItHint::CreateRemoval(
4247 SourceRange(TemplateParams
->getTemplateLoc(),
4248 TemplateParams
->getRAngleLoc()))
4249 << SourceRange(LAngleLoc
, RAngleLoc
);
4251 isExplicitSpecialization
= true;
4252 } else if (TUK
!= TUK_Friend
) {
4253 Diag(KWLoc
, diag::err_template_spec_needs_header
)
4254 << FixItHint::CreateInsertion(KWLoc
, "template<> ");
4255 isExplicitSpecialization
= true;
4258 // Check that the specialization uses the same tag kind as the
4259 // original template.
4260 TagTypeKind Kind
= TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec
);
4261 assert(Kind
!= TTK_Enum
&& "Invalid enum tag in class template spec!");
4262 if (!isAcceptableTagRedeclaration(ClassTemplate
->getTemplatedDecl(),
4264 *ClassTemplate
->getIdentifier())) {
4265 Diag(KWLoc
, diag::err_use_with_wrong_tag
)
4267 << FixItHint::CreateReplacement(KWLoc
,
4268 ClassTemplate
->getTemplatedDecl()->getKindName());
4269 Diag(ClassTemplate
->getTemplatedDecl()->getLocation(),
4270 diag::note_previous_use
);
4271 Kind
= ClassTemplate
->getTemplatedDecl()->getTagKind();
4274 // Translate the parser's template argument list in our AST format.
4275 TemplateArgumentListInfo TemplateArgs
;
4276 TemplateArgs
.setLAngleLoc(LAngleLoc
);
4277 TemplateArgs
.setRAngleLoc(RAngleLoc
);
4278 translateTemplateArguments(TemplateArgsIn
, TemplateArgs
);
4280 // Check for unexpanded parameter packs in any of the template arguments.
4281 for (unsigned I
= 0, N
= TemplateArgs
.size(); I
!= N
; ++I
)
4282 if (DiagnoseUnexpandedParameterPack(TemplateArgs
[I
],
4283 UPPC_PartialSpecialization
))
4286 // Check that the template argument list is well-formed for this
4288 llvm::SmallVector
<TemplateArgument
, 4> Converted
;
4289 if (CheckTemplateArgumentList(ClassTemplate
, TemplateNameLoc
,
4290 TemplateArgs
, false, Converted
))
4293 assert((Converted
.size() == ClassTemplate
->getTemplateParameters()->size()) &&
4294 "Converted template argument list is too short!");
4296 // Find the class template (partial) specialization declaration that
4297 // corresponds to these arguments.
4298 if (isPartialSpecialization
) {
4299 if (CheckClassTemplatePartialSpecializationArgs(*this,
4300 ClassTemplate
->getTemplateParameters(),
4304 if (!Name
.isDependent() &&
4305 !TemplateSpecializationType::anyDependentTemplateArguments(
4306 TemplateArgs
.getArgumentArray(),
4307 TemplateArgs
.size())) {
4308 Diag(TemplateNameLoc
, diag::err_partial_spec_fully_specialized
)
4309 << ClassTemplate
->getDeclName();
4310 isPartialSpecialization
= false;
4314 void *InsertPos
= 0;
4315 ClassTemplateSpecializationDecl
*PrevDecl
= 0;
4317 if (isPartialSpecialization
)
4318 // FIXME: Template parameter list matters, too
4320 = ClassTemplate
->findPartialSpecialization(Converted
.data(),
4325 = ClassTemplate
->findSpecialization(Converted
.data(),
4326 Converted
.size(), InsertPos
);
4328 ClassTemplateSpecializationDecl
*Specialization
= 0;
4330 // Check whether we can declare a class template specialization in
4331 // the current scope.
4332 if (TUK
!= TUK_Friend
&&
4333 CheckTemplateSpecializationScope(*this, ClassTemplate
, PrevDecl
,
4335 isPartialSpecialization
))
4338 // The canonical type
4341 (PrevDecl
->getSpecializationKind() == TSK_Undeclared
||
4342 TUK
== TUK_Friend
)) {
4343 // Since the only prior class template specialization with these
4344 // arguments was referenced but not declared, or we're only
4345 // referencing this specialization as a friend, reuse that
4346 // declaration node as our own, updating its source location to
4347 // reflect our new declaration.
4348 Specialization
= PrevDecl
;
4349 Specialization
->setLocation(TemplateNameLoc
);
4351 CanonType
= Context
.getTypeDeclType(Specialization
);
4352 } else if (isPartialSpecialization
) {
4353 // Build the canonical type that describes the converted template
4354 // arguments of the class template partial specialization.
4355 TemplateName CanonTemplate
= Context
.getCanonicalTemplateName(Name
);
4356 CanonType
= Context
.getTemplateSpecializationType(CanonTemplate
,
4360 if (Context
.hasSameType(CanonType
,
4361 ClassTemplate
->getInjectedClassNameSpecialization())) {
4362 // C++ [temp.class.spec]p9b3:
4364 // -- The argument list of the specialization shall not be identical
4365 // to the implicit argument list of the primary template.
4366 Diag(TemplateNameLoc
, diag::err_partial_spec_args_match_primary_template
)
4367 << (TUK
== TUK_Definition
)
4368 << FixItHint::CreateRemoval(SourceRange(LAngleLoc
, RAngleLoc
));
4369 return CheckClassTemplate(S
, TagSpec
, TUK
, KWLoc
, SS
,
4370 ClassTemplate
->getIdentifier(),
4377 // Create a new class template partial specialization declaration node.
4378 ClassTemplatePartialSpecializationDecl
*PrevPartial
4379 = cast_or_null
<ClassTemplatePartialSpecializationDecl
>(PrevDecl
);
4380 unsigned SequenceNumber
= PrevPartial
? PrevPartial
->getSequenceNumber()
4381 : ClassTemplate
->getNextPartialSpecSequenceNumber();
4382 ClassTemplatePartialSpecializationDecl
*Partial
4383 = ClassTemplatePartialSpecializationDecl::Create(Context
, Kind
,
4384 ClassTemplate
->getDeclContext(),
4394 SetNestedNameSpecifier(Partial
, SS
);
4395 if (NumMatchedTemplateParamLists
> 0 && SS
.isSet()) {
4396 Partial
->setTemplateParameterListsInfo(Context
,
4397 NumMatchedTemplateParamLists
,
4398 (TemplateParameterList
**) TemplateParameterLists
.release());
4402 ClassTemplate
->AddPartialSpecialization(Partial
, InsertPos
);
4403 Specialization
= Partial
;
4405 // If we are providing an explicit specialization of a member class
4406 // template specialization, make a note of that.
4407 if (PrevPartial
&& PrevPartial
->getInstantiatedFromMember())
4408 PrevPartial
->setMemberSpecialization();
4410 // Check that all of the template parameters of the class template
4411 // partial specialization are deducible from the template
4412 // arguments. If not, this class template partial specialization
4413 // will never be used.
4414 llvm::SmallVector
<bool, 8> DeducibleParams
;
4415 DeducibleParams
.resize(TemplateParams
->size());
4416 MarkUsedTemplateParameters(Partial
->getTemplateArgs(), true,
4417 TemplateParams
->getDepth(),
4419 unsigned NumNonDeducible
= 0;
4420 for (unsigned I
= 0, N
= DeducibleParams
.size(); I
!= N
; ++I
)
4421 if (!DeducibleParams
[I
])
4424 if (NumNonDeducible
) {
4425 Diag(TemplateNameLoc
, diag::warn_partial_specs_not_deducible
)
4426 << (NumNonDeducible
> 1)
4427 << SourceRange(TemplateNameLoc
, RAngleLoc
);
4428 for (unsigned I
= 0, N
= DeducibleParams
.size(); I
!= N
; ++I
) {
4429 if (!DeducibleParams
[I
]) {
4430 NamedDecl
*Param
= cast
<NamedDecl
>(TemplateParams
->getParam(I
));
4431 if (Param
->getDeclName())
4432 Diag(Param
->getLocation(),
4433 diag::note_partial_spec_unused_parameter
)
4434 << Param
->getDeclName();
4436 Diag(Param
->getLocation(),
4437 diag::note_partial_spec_unused_parameter
)
4443 // Create a new class template specialization declaration node for
4444 // this explicit specialization or friend declaration.
4446 = ClassTemplateSpecializationDecl::Create(Context
, Kind
,
4447 ClassTemplate
->getDeclContext(),
4453 SetNestedNameSpecifier(Specialization
, SS
);
4454 if (NumMatchedTemplateParamLists
> 0 && SS
.isSet()) {
4455 Specialization
->setTemplateParameterListsInfo(Context
,
4456 NumMatchedTemplateParamLists
,
4457 (TemplateParameterList
**) TemplateParameterLists
.release());
4461 ClassTemplate
->AddSpecialization(Specialization
, InsertPos
);
4463 CanonType
= Context
.getTypeDeclType(Specialization
);
4466 // C++ [temp.expl.spec]p6:
4467 // If a template, a member template or the member of a class template is
4468 // explicitly specialized then that specialization shall be declared
4469 // before the first use of that specialization that would cause an implicit
4470 // instantiation to take place, in every translation unit in which such a
4471 // use occurs; no diagnostic is required.
4472 if (PrevDecl
&& PrevDecl
->getPointOfInstantiation().isValid()) {
4474 for (NamedDecl
*Prev
= PrevDecl
; Prev
; Prev
= getPreviousDecl(Prev
)) {
4475 // Is there any previous explicit specialization declaration?
4476 if (getTemplateSpecializationKind(Prev
) == TSK_ExplicitSpecialization
) {
4483 SourceRange
Range(TemplateNameLoc
, RAngleLoc
);
4484 Diag(TemplateNameLoc
, diag::err_specialization_after_instantiation
)
4485 << Context
.getTypeDeclType(Specialization
) << Range
;
4487 Diag(PrevDecl
->getPointOfInstantiation(),
4488 diag::note_instantiation_required_here
)
4489 << (PrevDecl
->getTemplateSpecializationKind()
4490 != TSK_ImplicitInstantiation
);
4495 // If this is not a friend, note that this is an explicit specialization.
4496 if (TUK
!= TUK_Friend
)
4497 Specialization
->setSpecializationKind(TSK_ExplicitSpecialization
);
4499 // Check that this isn't a redefinition of this specialization.
4500 if (TUK
== TUK_Definition
) {
4501 if (RecordDecl
*Def
= Specialization
->getDefinition()) {
4502 SourceRange
Range(TemplateNameLoc
, RAngleLoc
);
4503 Diag(TemplateNameLoc
, diag::err_redefinition
)
4504 << Context
.getTypeDeclType(Specialization
) << Range
;
4505 Diag(Def
->getLocation(), diag::note_previous_definition
);
4506 Specialization
->setInvalidDecl();
4512 ProcessDeclAttributeList(S
, Specialization
, Attr
);
4514 // Build the fully-sugared type for this class template
4515 // specialization as the user wrote in the specialization
4516 // itself. This means that we'll pretty-print the type retrieved
4517 // from the specialization's declaration the way that the user
4518 // actually wrote the specialization, rather than formatting the
4519 // name based on the "canonical" representation used to store the
4520 // template arguments in the specialization.
4521 TypeSourceInfo
*WrittenTy
4522 = Context
.getTemplateSpecializationTypeInfo(Name
, TemplateNameLoc
,
4523 TemplateArgs
, CanonType
);
4524 if (TUK
!= TUK_Friend
) {
4525 Specialization
->setTypeAsWritten(WrittenTy
);
4527 Specialization
->setTemplateKeywordLoc(TemplateParams
->getTemplateLoc());
4529 TemplateArgsIn
.release();
4531 // C++ [temp.expl.spec]p9:
4532 // A template explicit specialization is in the scope of the
4533 // namespace in which the template was defined.
4535 // We actually implement this paragraph where we set the semantic
4536 // context (in the creation of the ClassTemplateSpecializationDecl),
4537 // but we also maintain the lexical context where the actual
4538 // definition occurs.
4539 Specialization
->setLexicalDeclContext(CurContext
);
4541 // We may be starting the definition of this specialization.
4542 if (TUK
== TUK_Definition
)
4543 Specialization
->startDefinition();
4545 if (TUK
== TUK_Friend
) {
4546 FriendDecl
*Friend
= FriendDecl::Create(Context
, CurContext
,
4550 Friend
->setAccess(AS_public
);
4551 CurContext
->addDecl(Friend
);
4553 // Add the specialization into its lexical context, so that it can
4554 // be seen when iterating through the list of declarations in that
4555 // context. However, specializations are not found by name lookup.
4556 CurContext
->addDecl(Specialization
);
4558 return Specialization
;
4561 Decl
*Sema::ActOnTemplateDeclarator(Scope
*S
,
4562 MultiTemplateParamsArg TemplateParameterLists
,
4564 return HandleDeclarator(S
, D
, move(TemplateParameterLists
), false);
4567 Decl
*Sema::ActOnStartOfFunctionTemplateDef(Scope
*FnBodyScope
,
4568 MultiTemplateParamsArg TemplateParameterLists
,
4570 assert(getCurFunctionDecl() == 0 && "Function parsing confused");
4571 DeclaratorChunk::FunctionTypeInfo
&FTI
= D
.getFunctionTypeInfo();
4573 if (FTI
.hasPrototype
) {
4574 // FIXME: Diagnose arguments without names in C.
4577 Scope
*ParentScope
= FnBodyScope
->getParent();
4579 Decl
*DP
= HandleDeclarator(ParentScope
, D
,
4580 move(TemplateParameterLists
),
4581 /*IsFunctionDefinition=*/true);
4582 if (FunctionTemplateDecl
*FunctionTemplate
4583 = dyn_cast_or_null
<FunctionTemplateDecl
>(DP
))
4584 return ActOnStartOfFunctionDef(FnBodyScope
,
4585 FunctionTemplate
->getTemplatedDecl());
4586 if (FunctionDecl
*Function
= dyn_cast_or_null
<FunctionDecl
>(DP
))
4587 return ActOnStartOfFunctionDef(FnBodyScope
, Function
);
4591 /// \brief Strips various properties off an implicit instantiation
4592 /// that has just been explicitly specialized.
4593 static void StripImplicitInstantiation(NamedDecl
*D
) {
4596 if (FunctionDecl
*FD
= dyn_cast
<FunctionDecl
>(D
)) {
4597 FD
->setInlineSpecified(false);
4601 /// \brief Diagnose cases where we have an explicit template specialization
4602 /// before/after an explicit template instantiation, producing diagnostics
4603 /// for those cases where they are required and determining whether the
4604 /// new specialization/instantiation will have any effect.
4606 /// \param NewLoc the location of the new explicit specialization or
4609 /// \param NewTSK the kind of the new explicit specialization or instantiation.
4611 /// \param PrevDecl the previous declaration of the entity.
4613 /// \param PrevTSK the kind of the old explicit specialization or instantiatin.
4615 /// \param PrevPointOfInstantiation if valid, indicates where the previus
4616 /// declaration was instantiated (either implicitly or explicitly).
4618 /// \param HasNoEffect will be set to true to indicate that the new
4619 /// specialization or instantiation has no effect and should be ignored.
4621 /// \returns true if there was an error that should prevent the introduction of
4622 /// the new declaration into the AST, false otherwise.
4624 Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc
,
4625 TemplateSpecializationKind NewTSK
,
4626 NamedDecl
*PrevDecl
,
4627 TemplateSpecializationKind PrevTSK
,
4628 SourceLocation PrevPointOfInstantiation
,
4629 bool &HasNoEffect
) {
4630 HasNoEffect
= false;
4633 case TSK_Undeclared
:
4634 case TSK_ImplicitInstantiation
:
4635 assert(false && "Don't check implicit instantiations here");
4638 case TSK_ExplicitSpecialization
:
4640 case TSK_Undeclared
:
4641 case TSK_ExplicitSpecialization
:
4642 // Okay, we're just specializing something that is either already
4643 // explicitly specialized or has merely been mentioned without any
4647 case TSK_ImplicitInstantiation
:
4648 if (PrevPointOfInstantiation
.isInvalid()) {
4649 // The declaration itself has not actually been instantiated, so it is
4650 // still okay to specialize it.
4651 StripImplicitInstantiation(PrevDecl
);
4656 case TSK_ExplicitInstantiationDeclaration
:
4657 case TSK_ExplicitInstantiationDefinition
:
4658 assert((PrevTSK
== TSK_ImplicitInstantiation
||
4659 PrevPointOfInstantiation
.isValid()) &&
4660 "Explicit instantiation without point of instantiation?");
4662 // C++ [temp.expl.spec]p6:
4663 // If a template, a member template or the member of a class template
4664 // is explicitly specialized then that specialization shall be declared
4665 // before the first use of that specialization that would cause an
4666 // implicit instantiation to take place, in every translation unit in
4667 // which such a use occurs; no diagnostic is required.
4668 for (NamedDecl
*Prev
= PrevDecl
; Prev
; Prev
= getPreviousDecl(Prev
)) {
4669 // Is there any previous explicit specialization declaration?
4670 if (getTemplateSpecializationKind(Prev
) == TSK_ExplicitSpecialization
)
4674 Diag(NewLoc
, diag::err_specialization_after_instantiation
)
4676 Diag(PrevPointOfInstantiation
, diag::note_instantiation_required_here
)
4677 << (PrevTSK
!= TSK_ImplicitInstantiation
);
4683 case TSK_ExplicitInstantiationDeclaration
:
4685 case TSK_ExplicitInstantiationDeclaration
:
4686 // This explicit instantiation declaration is redundant (that's okay).
4690 case TSK_Undeclared
:
4691 case TSK_ImplicitInstantiation
:
4692 // We're explicitly instantiating something that may have already been
4693 // implicitly instantiated; that's fine.
4696 case TSK_ExplicitSpecialization
:
4697 // C++0x [temp.explicit]p4:
4698 // For a given set of template parameters, if an explicit instantiation
4699 // of a template appears after a declaration of an explicit
4700 // specialization for that template, the explicit instantiation has no
4705 case TSK_ExplicitInstantiationDefinition
:
4706 // C++0x [temp.explicit]p10:
4707 // If an entity is the subject of both an explicit instantiation
4708 // declaration and an explicit instantiation definition in the same
4709 // translation unit, the definition shall follow the declaration.
4711 diag::err_explicit_instantiation_declaration_after_definition
);
4712 Diag(PrevPointOfInstantiation
,
4713 diag::note_explicit_instantiation_definition_here
);
4714 assert(PrevPointOfInstantiation
.isValid() &&
4715 "Explicit instantiation without point of instantiation?");
4721 case TSK_ExplicitInstantiationDefinition
:
4723 case TSK_Undeclared
:
4724 case TSK_ImplicitInstantiation
:
4725 // We're explicitly instantiating something that may have already been
4726 // implicitly instantiated; that's fine.
4729 case TSK_ExplicitSpecialization
:
4730 // C++ DR 259, C++0x [temp.explicit]p4:
4731 // For a given set of template parameters, if an explicit
4732 // instantiation of a template appears after a declaration of
4733 // an explicit specialization for that template, the explicit
4734 // instantiation has no effect.
4736 // In C++98/03 mode, we only give an extension warning here, because it
4737 // is not harmful to try to explicitly instantiate something that
4738 // has been explicitly specialized.
4739 if (!getLangOptions().CPlusPlus0x
) {
4740 Diag(NewLoc
, diag::ext_explicit_instantiation_after_specialization
)
4742 Diag(PrevDecl
->getLocation(),
4743 diag::note_previous_template_specialization
);
4748 case TSK_ExplicitInstantiationDeclaration
:
4749 // We're explicity instantiating a definition for something for which we
4750 // were previously asked to suppress instantiations. That's fine.
4753 case TSK_ExplicitInstantiationDefinition
:
4754 // C++0x [temp.spec]p5:
4755 // For a given template and a given set of template-arguments,
4756 // - an explicit instantiation definition shall appear at most once
4758 Diag(NewLoc
, diag::err_explicit_instantiation_duplicate
)
4760 Diag(PrevPointOfInstantiation
,
4761 diag::note_previous_explicit_instantiation
);
4768 assert(false && "Missing specialization/instantiation case?");
4773 /// \brief Perform semantic analysis for the given dependent function
4774 /// template specialization. The only possible way to get a dependent
4775 /// function template specialization is with a friend declaration,
4778 /// template <class T> void foo(T);
4779 /// template <class T> class A {
4780 /// friend void foo<>(T);
4783 /// There really isn't any useful analysis we can do here, so we
4784 /// just store the information.
4786 Sema::CheckDependentFunctionTemplateSpecialization(FunctionDecl
*FD
,
4787 const TemplateArgumentListInfo
&ExplicitTemplateArgs
,
4788 LookupResult
&Previous
) {
4789 // Remove anything from Previous that isn't a function template in
4790 // the correct context.
4791 DeclContext
*FDLookupContext
= FD
->getDeclContext()->getRedeclContext();
4792 LookupResult::Filter F
= Previous
.makeFilter();
4793 while (F
.hasNext()) {
4794 NamedDecl
*D
= F
.next()->getUnderlyingDecl();
4795 if (!isa
<FunctionTemplateDecl
>(D
) ||
4796 !FDLookupContext
->InEnclosingNamespaceSetOf(
4797 D
->getDeclContext()->getRedeclContext()))
4802 // Should this be diagnosed here?
4803 if (Previous
.empty()) return true;
4805 FD
->setDependentTemplateSpecialization(Context
, Previous
.asUnresolvedSet(),
4806 ExplicitTemplateArgs
);
4810 /// \brief Perform semantic analysis for the given function template
4813 /// This routine performs all of the semantic analysis required for an
4814 /// explicit function template specialization. On successful completion,
4815 /// the function declaration \p FD will become a function template
4818 /// \param FD the function declaration, which will be updated to become a
4819 /// function template specialization.
4821 /// \param ExplicitTemplateArgs the explicitly-provided template arguments,
4822 /// if any. Note that this may be valid info even when 0 arguments are
4823 /// explicitly provided as in, e.g., \c void sort<>(char*, char*);
4824 /// as it anyway contains info on the angle brackets locations.
4826 /// \param PrevDecl the set of declarations that may be specialized by
4827 /// this function specialization.
4829 Sema::CheckFunctionTemplateSpecialization(FunctionDecl
*FD
,
4830 const TemplateArgumentListInfo
*ExplicitTemplateArgs
,
4831 LookupResult
&Previous
) {
4832 // The set of function template specializations that could match this
4833 // explicit function template specialization.
4834 UnresolvedSet
<8> Candidates
;
4836 DeclContext
*FDLookupContext
= FD
->getDeclContext()->getRedeclContext();
4837 for (LookupResult::iterator I
= Previous
.begin(), E
= Previous
.end();
4839 NamedDecl
*Ovl
= (*I
)->getUnderlyingDecl();
4840 if (FunctionTemplateDecl
*FunTmpl
= dyn_cast
<FunctionTemplateDecl
>(Ovl
)) {
4841 // Only consider templates found within the same semantic lookup scope as
4843 if (!FDLookupContext
->InEnclosingNamespaceSetOf(
4844 Ovl
->getDeclContext()->getRedeclContext()))
4847 // C++ [temp.expl.spec]p11:
4848 // A trailing template-argument can be left unspecified in the
4849 // template-id naming an explicit function template specialization
4850 // provided it can be deduced from the function argument type.
4851 // Perform template argument deduction to determine whether we may be
4852 // specializing this template.
4853 // FIXME: It is somewhat wasteful to build
4854 TemplateDeductionInfo
Info(Context
, FD
->getLocation());
4855 FunctionDecl
*Specialization
= 0;
4856 if (TemplateDeductionResult TDK
4857 = DeduceTemplateArguments(FunTmpl
, ExplicitTemplateArgs
,
4861 // FIXME: Template argument deduction failed; record why it failed, so
4862 // that we can provide nifty diagnostics.
4867 // Record this candidate.
4868 Candidates
.addDecl(Specialization
, I
.getAccess());
4872 // Find the most specialized function template.
4873 UnresolvedSetIterator Result
4874 = getMostSpecialized(Candidates
.begin(), Candidates
.end(),
4875 TPOC_Other
, 0, FD
->getLocation(),
4876 PDiag(diag::err_function_template_spec_no_match
)
4877 << FD
->getDeclName(),
4878 PDiag(diag::err_function_template_spec_ambiguous
)
4879 << FD
->getDeclName() << (ExplicitTemplateArgs
!= 0),
4880 PDiag(diag::note_function_template_spec_matched
));
4881 if (Result
== Candidates
.end())
4884 // Ignore access information; it doesn't figure into redeclaration checking.
4885 FunctionDecl
*Specialization
= cast
<FunctionDecl
>(*Result
);
4886 Specialization
->setLocation(FD
->getLocation());
4888 // FIXME: Check if the prior specialization has a point of instantiation.
4889 // If so, we have run afoul of .
4891 // If this is a friend declaration, then we're not really declaring
4892 // an explicit specialization.
4893 bool isFriend
= (FD
->getFriendObjectKind() != Decl::FOK_None
);
4895 // Check the scope of this explicit specialization.
4897 CheckTemplateSpecializationScope(*this,
4898 Specialization
->getPrimaryTemplate(),
4899 Specialization
, FD
->getLocation(),
4903 // C++ [temp.expl.spec]p6:
4904 // If a template, a member template or the member of a class template is
4905 // explicitly specialized then that specialization shall be declared
4906 // before the first use of that specialization that would cause an implicit
4907 // instantiation to take place, in every translation unit in which such a
4908 // use occurs; no diagnostic is required.
4909 FunctionTemplateSpecializationInfo
*SpecInfo
4910 = Specialization
->getTemplateSpecializationInfo();
4911 assert(SpecInfo
&& "Function template specialization info missing?");
4913 bool HasNoEffect
= false;
4915 CheckSpecializationInstantiationRedecl(FD
->getLocation(),
4916 TSK_ExplicitSpecialization
,
4918 SpecInfo
->getTemplateSpecializationKind(),
4919 SpecInfo
->getPointOfInstantiation(),
4923 // Mark the prior declaration as an explicit specialization, so that later
4924 // clients know that this is an explicit specialization.
4926 SpecInfo
->setTemplateSpecializationKind(TSK_ExplicitSpecialization
);
4927 MarkUnusedFileScopedDecl(Specialization
);
4930 // Turn the given function declaration into a function template
4931 // specialization, with the template arguments from the previous
4933 // Take copies of (semantic and syntactic) template argument lists.
4934 const TemplateArgumentList
* TemplArgs
= new (Context
)
4935 TemplateArgumentList(Specialization
->getTemplateSpecializationArgs());
4936 const TemplateArgumentListInfo
* TemplArgsAsWritten
= ExplicitTemplateArgs
4937 ? new (Context
) TemplateArgumentListInfo(*ExplicitTemplateArgs
) : 0;
4938 FD
->setFunctionTemplateSpecialization(Specialization
->getPrimaryTemplate(),
4939 TemplArgs
, /*InsertPos=*/0,
4940 SpecInfo
->getTemplateSpecializationKind(),
4941 TemplArgsAsWritten
);
4943 // The "previous declaration" for this function template specialization is
4944 // the prior function template specialization.
4946 Previous
.addDecl(Specialization
);
4950 /// \brief Perform semantic analysis for the given non-template member
4953 /// This routine performs all of the semantic analysis required for an
4954 /// explicit member function specialization. On successful completion,
4955 /// the function declaration \p FD will become a member function
4958 /// \param Member the member declaration, which will be updated to become a
4961 /// \param Previous the set of declarations, one of which may be specialized
4962 /// by this function specialization; the set will be modified to contain the
4963 /// redeclared member.
4965 Sema::CheckMemberSpecialization(NamedDecl
*Member
, LookupResult
&Previous
) {
4966 assert(!isa
<TemplateDecl
>(Member
) && "Only for non-template members");
4968 // Try to find the member we are instantiating.
4969 NamedDecl
*Instantiation
= 0;
4970 NamedDecl
*InstantiatedFrom
= 0;
4971 MemberSpecializationInfo
*MSInfo
= 0;
4973 if (Previous
.empty()) {
4974 // Nowhere to look anyway.
4975 } else if (FunctionDecl
*Function
= dyn_cast
<FunctionDecl
>(Member
)) {
4976 for (LookupResult::iterator I
= Previous
.begin(), E
= Previous
.end();
4978 NamedDecl
*D
= (*I
)->getUnderlyingDecl();
4979 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(D
)) {
4980 if (Context
.hasSameType(Function
->getType(), Method
->getType())) {
4981 Instantiation
= Method
;
4982 InstantiatedFrom
= Method
->getInstantiatedFromMemberFunction();
4983 MSInfo
= Method
->getMemberSpecializationInfo();
4988 } else if (isa
<VarDecl
>(Member
)) {
4990 if (Previous
.isSingleResult() &&
4991 (PrevVar
= dyn_cast
<VarDecl
>(Previous
.getFoundDecl())))
4992 if (PrevVar
->isStaticDataMember()) {
4993 Instantiation
= PrevVar
;
4994 InstantiatedFrom
= PrevVar
->getInstantiatedFromStaticDataMember();
4995 MSInfo
= PrevVar
->getMemberSpecializationInfo();
4997 } else if (isa
<RecordDecl
>(Member
)) {
4998 CXXRecordDecl
*PrevRecord
;
4999 if (Previous
.isSingleResult() &&
5000 (PrevRecord
= dyn_cast
<CXXRecordDecl
>(Previous
.getFoundDecl()))) {
5001 Instantiation
= PrevRecord
;
5002 InstantiatedFrom
= PrevRecord
->getInstantiatedFromMemberClass();
5003 MSInfo
= PrevRecord
->getMemberSpecializationInfo();
5007 if (!Instantiation
) {
5008 // There is no previous declaration that matches. Since member
5009 // specializations are always out-of-line, the caller will complain about
5010 // this mismatch later.
5014 // If this is a friend, just bail out here before we start turning
5015 // things into explicit specializations.
5016 if (Member
->getFriendObjectKind() != Decl::FOK_None
) {
5017 // Preserve instantiation information.
5018 if (InstantiatedFrom
&& isa
<CXXMethodDecl
>(Member
)) {
5019 cast
<CXXMethodDecl
>(Member
)->setInstantiationOfMemberFunction(
5020 cast
<CXXMethodDecl
>(InstantiatedFrom
),
5021 cast
<CXXMethodDecl
>(Instantiation
)->getTemplateSpecializationKind());
5022 } else if (InstantiatedFrom
&& isa
<CXXRecordDecl
>(Member
)) {
5023 cast
<CXXRecordDecl
>(Member
)->setInstantiationOfMemberClass(
5024 cast
<CXXRecordDecl
>(InstantiatedFrom
),
5025 cast
<CXXRecordDecl
>(Instantiation
)->getTemplateSpecializationKind());
5029 Previous
.addDecl(Instantiation
);
5033 // Make sure that this is a specialization of a member.
5034 if (!InstantiatedFrom
) {
5035 Diag(Member
->getLocation(), diag::err_spec_member_not_instantiated
)
5037 Diag(Instantiation
->getLocation(), diag::note_specialized_decl
);
5041 // C++ [temp.expl.spec]p6:
5042 // If a template, a member template or the member of a class template is
5043 // explicitly specialized then that spe- cialization shall be declared
5044 // before the first use of that specialization that would cause an implicit
5045 // instantiation to take place, in every translation unit in which such a
5046 // use occurs; no diagnostic is required.
5047 assert(MSInfo
&& "Member specialization info missing?");
5049 bool HasNoEffect
= false;
5050 if (CheckSpecializationInstantiationRedecl(Member
->getLocation(),
5051 TSK_ExplicitSpecialization
,
5053 MSInfo
->getTemplateSpecializationKind(),
5054 MSInfo
->getPointOfInstantiation(),
5058 // Check the scope of this explicit specialization.
5059 if (CheckTemplateSpecializationScope(*this,
5061 Instantiation
, Member
->getLocation(),
5065 // Note that this is an explicit instantiation of a member.
5066 // the original declaration to note that it is an explicit specialization
5067 // (if it was previously an implicit instantiation). This latter step
5068 // makes bookkeeping easier.
5069 if (isa
<FunctionDecl
>(Member
)) {
5070 FunctionDecl
*InstantiationFunction
= cast
<FunctionDecl
>(Instantiation
);
5071 if (InstantiationFunction
->getTemplateSpecializationKind() ==
5072 TSK_ImplicitInstantiation
) {
5073 InstantiationFunction
->setTemplateSpecializationKind(
5074 TSK_ExplicitSpecialization
);
5075 InstantiationFunction
->setLocation(Member
->getLocation());
5078 cast
<FunctionDecl
>(Member
)->setInstantiationOfMemberFunction(
5079 cast
<CXXMethodDecl
>(InstantiatedFrom
),
5080 TSK_ExplicitSpecialization
);
5081 MarkUnusedFileScopedDecl(InstantiationFunction
);
5082 } else if (isa
<VarDecl
>(Member
)) {
5083 VarDecl
*InstantiationVar
= cast
<VarDecl
>(Instantiation
);
5084 if (InstantiationVar
->getTemplateSpecializationKind() ==
5085 TSK_ImplicitInstantiation
) {
5086 InstantiationVar
->setTemplateSpecializationKind(
5087 TSK_ExplicitSpecialization
);
5088 InstantiationVar
->setLocation(Member
->getLocation());
5091 Context
.setInstantiatedFromStaticDataMember(cast
<VarDecl
>(Member
),
5092 cast
<VarDecl
>(InstantiatedFrom
),
5093 TSK_ExplicitSpecialization
);
5094 MarkUnusedFileScopedDecl(InstantiationVar
);
5096 assert(isa
<CXXRecordDecl
>(Member
) && "Only member classes remain");
5097 CXXRecordDecl
*InstantiationClass
= cast
<CXXRecordDecl
>(Instantiation
);
5098 if (InstantiationClass
->getTemplateSpecializationKind() ==
5099 TSK_ImplicitInstantiation
) {
5100 InstantiationClass
->setTemplateSpecializationKind(
5101 TSK_ExplicitSpecialization
);
5102 InstantiationClass
->setLocation(Member
->getLocation());
5105 cast
<CXXRecordDecl
>(Member
)->setInstantiationOfMemberClass(
5106 cast
<CXXRecordDecl
>(InstantiatedFrom
),
5107 TSK_ExplicitSpecialization
);
5110 // Save the caller the trouble of having to figure out which declaration
5111 // this specialization matches.
5113 Previous
.addDecl(Instantiation
);
5117 /// \brief Check the scope of an explicit instantiation.
5119 /// \returns true if a serious error occurs, false otherwise.
5120 static bool CheckExplicitInstantiationScope(Sema
&S
, NamedDecl
*D
,
5121 SourceLocation InstLoc
,
5122 bool WasQualifiedName
) {
5123 DeclContext
*OrigContext
= D
->getDeclContext()->getEnclosingNamespaceContext();
5124 DeclContext
*CurContext
= S
.CurContext
->getRedeclContext();
5126 if (CurContext
->isRecord()) {
5127 S
.Diag(InstLoc
, diag::err_explicit_instantiation_in_class
)
5132 // C++0x [temp.explicit]p2:
5133 // An explicit instantiation shall appear in an enclosing namespace of its
5136 // This is DR275, which we do not retroactively apply to C++98/03.
5137 if (S
.getLangOptions().CPlusPlus0x
&&
5138 !CurContext
->Encloses(OrigContext
)) {
5139 if (NamespaceDecl
*NS
= dyn_cast
<NamespaceDecl
>(OrigContext
))
5141 S
.getLangOptions().CPlusPlus0x
?
5142 diag::err_explicit_instantiation_out_of_scope
5143 : diag::warn_explicit_instantiation_out_of_scope_0x
)
5147 S
.getLangOptions().CPlusPlus0x
?
5148 diag::err_explicit_instantiation_must_be_global
5149 : diag::warn_explicit_instantiation_out_of_scope_0x
)
5151 S
.Diag(D
->getLocation(), diag::note_explicit_instantiation_here
);
5155 // C++0x [temp.explicit]p2:
5156 // If the name declared in the explicit instantiation is an unqualified
5157 // name, the explicit instantiation shall appear in the namespace where
5158 // its template is declared or, if that namespace is inline (7.3.1), any
5159 // namespace from its enclosing namespace set.
5160 if (WasQualifiedName
)
5163 if (CurContext
->InEnclosingNamespaceSetOf(OrigContext
))
5167 S
.getLangOptions().CPlusPlus0x
?
5168 diag::err_explicit_instantiation_unqualified_wrong_namespace
5169 : diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x
)
5170 << D
<< OrigContext
;
5171 S
.Diag(D
->getLocation(), diag::note_explicit_instantiation_here
);
5175 /// \brief Determine whether the given scope specifier has a template-id in it.
5176 static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec
&SS
) {
5180 // C++0x [temp.explicit]p2:
5181 // If the explicit instantiation is for a member function, a member class
5182 // or a static data member of a class template specialization, the name of
5183 // the class template specialization in the qualified-id for the member
5184 // name shall be a simple-template-id.
5186 // C++98 has the same restriction, just worded differently.
5187 for (NestedNameSpecifier
*NNS
= (NestedNameSpecifier
*)SS
.getScopeRep();
5188 NNS
; NNS
= NNS
->getPrefix())
5189 if (Type
*T
= NNS
->getAsType())
5190 if (isa
<TemplateSpecializationType
>(T
))
5196 // Explicit instantiation of a class template specialization
5198 Sema::ActOnExplicitInstantiation(Scope
*S
,
5199 SourceLocation ExternLoc
,
5200 SourceLocation TemplateLoc
,
5202 SourceLocation KWLoc
,
5203 const CXXScopeSpec
&SS
,
5204 TemplateTy TemplateD
,
5205 SourceLocation TemplateNameLoc
,
5206 SourceLocation LAngleLoc
,
5207 ASTTemplateArgsPtr TemplateArgsIn
,
5208 SourceLocation RAngleLoc
,
5209 AttributeList
*Attr
) {
5210 // Find the class template we're specializing
5211 TemplateName Name
= TemplateD
.getAsVal
<TemplateName
>();
5212 ClassTemplateDecl
*ClassTemplate
5213 = cast
<ClassTemplateDecl
>(Name
.getAsTemplateDecl());
5215 // Check that the specialization uses the same tag kind as the
5216 // original template.
5217 TagTypeKind Kind
= TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec
);
5218 assert(Kind
!= TTK_Enum
&&
5219 "Invalid enum tag in class template explicit instantiation!");
5220 if (!isAcceptableTagRedeclaration(ClassTemplate
->getTemplatedDecl(),
5222 *ClassTemplate
->getIdentifier())) {
5223 Diag(KWLoc
, diag::err_use_with_wrong_tag
)
5225 << FixItHint::CreateReplacement(KWLoc
,
5226 ClassTemplate
->getTemplatedDecl()->getKindName());
5227 Diag(ClassTemplate
->getTemplatedDecl()->getLocation(),
5228 diag::note_previous_use
);
5229 Kind
= ClassTemplate
->getTemplatedDecl()->getTagKind();
5232 // C++0x [temp.explicit]p2:
5233 // There are two forms of explicit instantiation: an explicit instantiation
5234 // definition and an explicit instantiation declaration. An explicit
5235 // instantiation declaration begins with the extern keyword. [...]
5236 TemplateSpecializationKind TSK
5237 = ExternLoc
.isInvalid()? TSK_ExplicitInstantiationDefinition
5238 : TSK_ExplicitInstantiationDeclaration
;
5240 // Translate the parser's template argument list in our AST format.
5241 TemplateArgumentListInfo
TemplateArgs(LAngleLoc
, RAngleLoc
);
5242 translateTemplateArguments(TemplateArgsIn
, TemplateArgs
);
5244 // Check that the template argument list is well-formed for this
5246 llvm::SmallVector
<TemplateArgument
, 4> Converted
;
5247 if (CheckTemplateArgumentList(ClassTemplate
, TemplateNameLoc
,
5248 TemplateArgs
, false, Converted
))
5251 assert((Converted
.size() == ClassTemplate
->getTemplateParameters()->size()) &&
5252 "Converted template argument list is too short!");
5254 // Find the class template specialization declaration that
5255 // corresponds to these arguments.
5256 void *InsertPos
= 0;
5257 ClassTemplateSpecializationDecl
*PrevDecl
5258 = ClassTemplate
->findSpecialization(Converted
.data(),
5259 Converted
.size(), InsertPos
);
5261 TemplateSpecializationKind PrevDecl_TSK
5262 = PrevDecl
? PrevDecl
->getTemplateSpecializationKind() : TSK_Undeclared
;
5264 // C++0x [temp.explicit]p2:
5265 // [...] An explicit instantiation shall appear in an enclosing
5266 // namespace of its template. [...]
5268 // This is C++ DR 275.
5269 if (CheckExplicitInstantiationScope(*this, ClassTemplate
, TemplateNameLoc
,
5273 ClassTemplateSpecializationDecl
*Specialization
= 0;
5275 bool ReusedDecl
= false;
5276 bool HasNoEffect
= false;
5278 if (CheckSpecializationInstantiationRedecl(TemplateNameLoc
, TSK
,
5279 PrevDecl
, PrevDecl_TSK
,
5280 PrevDecl
->getPointOfInstantiation(),
5284 // Even though HasNoEffect == true means that this explicit instantiation
5285 // has no effect on semantics, we go on to put its syntax in the AST.
5287 if (PrevDecl_TSK
== TSK_ImplicitInstantiation
||
5288 PrevDecl_TSK
== TSK_Undeclared
) {
5289 // Since the only prior class template specialization with these
5290 // arguments was referenced but not declared, reuse that
5291 // declaration node as our own, updating the source location
5292 // for the template name to reflect our new declaration.
5293 // (Other source locations will be updated later.)
5294 Specialization
= PrevDecl
;
5295 Specialization
->setLocation(TemplateNameLoc
);
5301 if (!Specialization
) {
5302 // Create a new class template specialization declaration node for
5303 // this explicit specialization.
5305 = ClassTemplateSpecializationDecl::Create(Context
, Kind
,
5306 ClassTemplate
->getDeclContext(),
5312 SetNestedNameSpecifier(Specialization
, SS
);
5314 if (!HasNoEffect
&& !PrevDecl
) {
5315 // Insert the new specialization.
5316 ClassTemplate
->AddSpecialization(Specialization
, InsertPos
);
5320 // Build the fully-sugared type for this explicit instantiation as
5321 // the user wrote in the explicit instantiation itself. This means
5322 // that we'll pretty-print the type retrieved from the
5323 // specialization's declaration the way that the user actually wrote
5324 // the explicit instantiation, rather than formatting the name based
5325 // on the "canonical" representation used to store the template
5326 // arguments in the specialization.
5327 TypeSourceInfo
*WrittenTy
5328 = Context
.getTemplateSpecializationTypeInfo(Name
, TemplateNameLoc
,
5330 Context
.getTypeDeclType(Specialization
));
5331 Specialization
->setTypeAsWritten(WrittenTy
);
5332 TemplateArgsIn
.release();
5334 // Set source locations for keywords.
5335 Specialization
->setExternLoc(ExternLoc
);
5336 Specialization
->setTemplateKeywordLoc(TemplateLoc
);
5338 // Add the explicit instantiation into its lexical context. However,
5339 // since explicit instantiations are never found by name lookup, we
5340 // just put it into the declaration context directly.
5341 Specialization
->setLexicalDeclContext(CurContext
);
5342 CurContext
->addDecl(Specialization
);
5344 // Syntax is now OK, so return if it has no other effect on semantics.
5346 // Set the template specialization kind.
5347 Specialization
->setTemplateSpecializationKind(TSK
);
5348 return Specialization
;
5351 // C++ [temp.explicit]p3:
5352 // A definition of a class template or class member template
5353 // shall be in scope at the point of the explicit instantiation of
5354 // the class template or class member template.
5356 // This check comes when we actually try to perform the
5358 ClassTemplateSpecializationDecl
*Def
5359 = cast_or_null
<ClassTemplateSpecializationDecl
>(
5360 Specialization
->getDefinition());
5362 InstantiateClassTemplateSpecialization(TemplateNameLoc
, Specialization
, TSK
);
5363 else if (TSK
== TSK_ExplicitInstantiationDefinition
) {
5364 MarkVTableUsed(TemplateNameLoc
, Specialization
, true);
5365 Specialization
->setPointOfInstantiation(Def
->getPointOfInstantiation());
5368 // Instantiate the members of this class template specialization.
5369 Def
= cast_or_null
<ClassTemplateSpecializationDecl
>(
5370 Specialization
->getDefinition());
5372 TemplateSpecializationKind Old_TSK
= Def
->getTemplateSpecializationKind();
5374 // Fix a TSK_ExplicitInstantiationDeclaration followed by a
5375 // TSK_ExplicitInstantiationDefinition
5376 if (Old_TSK
== TSK_ExplicitInstantiationDeclaration
&&
5377 TSK
== TSK_ExplicitInstantiationDefinition
)
5378 Def
->setTemplateSpecializationKind(TSK
);
5380 InstantiateClassTemplateSpecializationMembers(TemplateNameLoc
, Def
, TSK
);
5383 // Set the template specialization kind.
5384 Specialization
->setTemplateSpecializationKind(TSK
);
5385 return Specialization
;
5388 // Explicit instantiation of a member class of a class template.
5390 Sema::ActOnExplicitInstantiation(Scope
*S
,
5391 SourceLocation ExternLoc
,
5392 SourceLocation TemplateLoc
,
5394 SourceLocation KWLoc
,
5396 IdentifierInfo
*Name
,
5397 SourceLocation NameLoc
,
5398 AttributeList
*Attr
) {
5401 bool IsDependent
= false;
5402 Decl
*TagD
= ActOnTag(S
, TagSpec
, Sema::TUK_Reference
,
5403 KWLoc
, SS
, Name
, NameLoc
, Attr
, AS_none
,
5404 MultiTemplateParamsArg(*this, 0, 0),
5405 Owned
, IsDependent
, false, false,
5407 assert(!IsDependent
&& "explicit instantiation of dependent name not yet handled");
5412 TagDecl
*Tag
= cast
<TagDecl
>(TagD
);
5413 if (Tag
->isEnum()) {
5414 Diag(TemplateLoc
, diag::err_explicit_instantiation_enum
)
5415 << Context
.getTypeDeclType(Tag
);
5419 if (Tag
->isInvalidDecl())
5422 CXXRecordDecl
*Record
= cast
<CXXRecordDecl
>(Tag
);
5423 CXXRecordDecl
*Pattern
= Record
->getInstantiatedFromMemberClass();
5425 Diag(TemplateLoc
, diag::err_explicit_instantiation_nontemplate_type
)
5426 << Context
.getTypeDeclType(Record
);
5427 Diag(Record
->getLocation(), diag::note_nontemplate_decl_here
);
5431 // C++0x [temp.explicit]p2:
5432 // If the explicit instantiation is for a class or member class, the
5433 // elaborated-type-specifier in the declaration shall include a
5434 // simple-template-id.
5436 // C++98 has the same restriction, just worded differently.
5437 if (!ScopeSpecifierHasTemplateId(SS
))
5438 Diag(TemplateLoc
, diag::ext_explicit_instantiation_without_qualified_id
)
5439 << Record
<< SS
.getRange();
5441 // C++0x [temp.explicit]p2:
5442 // There are two forms of explicit instantiation: an explicit instantiation
5443 // definition and an explicit instantiation declaration. An explicit
5444 // instantiation declaration begins with the extern keyword. [...]
5445 TemplateSpecializationKind TSK
5446 = ExternLoc
.isInvalid()? TSK_ExplicitInstantiationDefinition
5447 : TSK_ExplicitInstantiationDeclaration
;
5449 // C++0x [temp.explicit]p2:
5450 // [...] An explicit instantiation shall appear in an enclosing
5451 // namespace of its template. [...]
5453 // This is C++ DR 275.
5454 CheckExplicitInstantiationScope(*this, Record
, NameLoc
, true);
5456 // Verify that it is okay to explicitly instantiate here.
5457 CXXRecordDecl
*PrevDecl
5458 = cast_or_null
<CXXRecordDecl
>(Record
->getPreviousDeclaration());
5459 if (!PrevDecl
&& Record
->getDefinition())
5462 MemberSpecializationInfo
*MSInfo
= PrevDecl
->getMemberSpecializationInfo();
5463 bool HasNoEffect
= false;
5464 assert(MSInfo
&& "No member specialization information?");
5465 if (CheckSpecializationInstantiationRedecl(TemplateLoc
, TSK
,
5467 MSInfo
->getTemplateSpecializationKind(),
5468 MSInfo
->getPointOfInstantiation(),
5475 CXXRecordDecl
*RecordDef
5476 = cast_or_null
<CXXRecordDecl
>(Record
->getDefinition());
5478 // C++ [temp.explicit]p3:
5479 // A definition of a member class of a class template shall be in scope
5480 // at the point of an explicit instantiation of the member class.
5482 = cast_or_null
<CXXRecordDecl
>(Pattern
->getDefinition());
5484 Diag(TemplateLoc
, diag::err_explicit_instantiation_undefined_member
)
5485 << 0 << Record
->getDeclName() << Record
->getDeclContext();
5486 Diag(Pattern
->getLocation(), diag::note_forward_declaration
)
5490 if (InstantiateClass(NameLoc
, Record
, Def
,
5491 getTemplateInstantiationArgs(Record
),
5495 RecordDef
= cast_or_null
<CXXRecordDecl
>(Record
->getDefinition());
5501 // Instantiate all of the members of the class.
5502 InstantiateClassMembers(NameLoc
, RecordDef
,
5503 getTemplateInstantiationArgs(Record
), TSK
);
5505 if (TSK
== TSK_ExplicitInstantiationDefinition
)
5506 MarkVTableUsed(NameLoc
, RecordDef
, true);
5508 // FIXME: We don't have any representation for explicit instantiations of
5509 // member classes. Such a representation is not needed for compilation, but it
5510 // should be available for clients that want to see all of the declarations in
5515 DeclResult
Sema::ActOnExplicitInstantiation(Scope
*S
,
5516 SourceLocation ExternLoc
,
5517 SourceLocation TemplateLoc
,
5519 // Explicit instantiations always require a name.
5520 // TODO: check if/when DNInfo should replace Name.
5521 DeclarationNameInfo NameInfo
= GetNameForDeclarator(D
);
5522 DeclarationName Name
= NameInfo
.getName();
5524 if (!D
.isInvalidType())
5525 Diag(D
.getDeclSpec().getSourceRange().getBegin(),
5526 diag::err_explicit_instantiation_requires_name
)
5527 << D
.getDeclSpec().getSourceRange()
5528 << D
.getSourceRange();
5533 // The scope passed in may not be a decl scope. Zip up the scope tree until
5534 // we find one that is.
5535 while ((S
->getFlags() & Scope::DeclScope
) == 0 ||
5536 (S
->getFlags() & Scope::TemplateParamScope
) != 0)
5539 // Determine the type of the declaration.
5540 TypeSourceInfo
*T
= GetTypeForDeclarator(D
, S
);
5541 QualType R
= T
->getType();
5545 if (D
.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef
) {
5546 // Cannot explicitly instantiate a typedef.
5547 Diag(D
.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef
)
5552 // C++0x [temp.explicit]p1:
5553 // [...] An explicit instantiation of a function template shall not use the
5554 // inline or constexpr specifiers.
5555 // Presumably, this also applies to member functions of class templates as
5557 if (D
.getDeclSpec().isInlineSpecified() && getLangOptions().CPlusPlus0x
)
5558 Diag(D
.getDeclSpec().getInlineSpecLoc(),
5559 diag::err_explicit_instantiation_inline
)
5560 <<FixItHint::CreateRemoval(D
.getDeclSpec().getInlineSpecLoc());
5562 // FIXME: check for constexpr specifier.
5564 // C++0x [temp.explicit]p2:
5565 // There are two forms of explicit instantiation: an explicit instantiation
5566 // definition and an explicit instantiation declaration. An explicit
5567 // instantiation declaration begins with the extern keyword. [...]
5568 TemplateSpecializationKind TSK
5569 = ExternLoc
.isInvalid()? TSK_ExplicitInstantiationDefinition
5570 : TSK_ExplicitInstantiationDeclaration
;
5572 LookupResult
Previous(*this, NameInfo
, LookupOrdinaryName
);
5573 LookupParsedName(Previous
, S
, &D
.getCXXScopeSpec());
5575 if (!R
->isFunctionType()) {
5576 // C++ [temp.explicit]p1:
5577 // A [...] static data member of a class template can be explicitly
5578 // instantiated from the member definition associated with its class
5580 if (Previous
.isAmbiguous())
5583 VarDecl
*Prev
= Previous
.getAsSingle
<VarDecl
>();
5584 if (!Prev
|| !Prev
->isStaticDataMember()) {
5585 // We expect to see a data data member here.
5586 Diag(D
.getIdentifierLoc(), diag::err_explicit_instantiation_not_known
)
5588 for (LookupResult::iterator P
= Previous
.begin(), PEnd
= Previous
.end();
5590 Diag((*P
)->getLocation(), diag::note_explicit_instantiation_here
);
5594 if (!Prev
->getInstantiatedFromStaticDataMember()) {
5595 // FIXME: Check for explicit specialization?
5596 Diag(D
.getIdentifierLoc(),
5597 diag::err_explicit_instantiation_data_member_not_instantiated
)
5599 Diag(Prev
->getLocation(), diag::note_explicit_instantiation_here
);
5600 // FIXME: Can we provide a note showing where this was declared?
5604 // C++0x [temp.explicit]p2:
5605 // If the explicit instantiation is for a member function, a member class
5606 // or a static data member of a class template specialization, the name of
5607 // the class template specialization in the qualified-id for the member
5608 // name shall be a simple-template-id.
5610 // C++98 has the same restriction, just worded differently.
5611 if (!ScopeSpecifierHasTemplateId(D
.getCXXScopeSpec()))
5612 Diag(D
.getIdentifierLoc(),
5613 diag::ext_explicit_instantiation_without_qualified_id
)
5614 << Prev
<< D
.getCXXScopeSpec().getRange();
5616 // Check the scope of this explicit instantiation.
5617 CheckExplicitInstantiationScope(*this, Prev
, D
.getIdentifierLoc(), true);
5619 // Verify that it is okay to explicitly instantiate here.
5620 MemberSpecializationInfo
*MSInfo
= Prev
->getMemberSpecializationInfo();
5621 assert(MSInfo
&& "Missing static data member specialization info?");
5622 bool HasNoEffect
= false;
5623 if (CheckSpecializationInstantiationRedecl(D
.getIdentifierLoc(), TSK
, Prev
,
5624 MSInfo
->getTemplateSpecializationKind(),
5625 MSInfo
->getPointOfInstantiation(),
5631 // Instantiate static data member.
5632 Prev
->setTemplateSpecializationKind(TSK
, D
.getIdentifierLoc());
5633 if (TSK
== TSK_ExplicitInstantiationDefinition
)
5634 InstantiateStaticDataMemberDefinition(D
.getIdentifierLoc(), Prev
);
5636 // FIXME: Create an ExplicitInstantiation node?
5640 // If the declarator is a template-id, translate the parser's template
5641 // argument list into our AST format.
5642 bool HasExplicitTemplateArgs
= false;
5643 TemplateArgumentListInfo TemplateArgs
;
5644 if (D
.getName().getKind() == UnqualifiedId::IK_TemplateId
) {
5645 TemplateIdAnnotation
*TemplateId
= D
.getName().TemplateId
;
5646 TemplateArgs
.setLAngleLoc(TemplateId
->LAngleLoc
);
5647 TemplateArgs
.setRAngleLoc(TemplateId
->RAngleLoc
);
5648 ASTTemplateArgsPtr
TemplateArgsPtr(*this,
5649 TemplateId
->getTemplateArgs(),
5650 TemplateId
->NumArgs
);
5651 translateTemplateArguments(TemplateArgsPtr
, TemplateArgs
);
5652 HasExplicitTemplateArgs
= true;
5653 TemplateArgsPtr
.release();
5656 // C++ [temp.explicit]p1:
5657 // A [...] function [...] can be explicitly instantiated from its template.
5658 // A member function [...] of a class template can be explicitly
5659 // instantiated from the member definition associated with its class
5661 UnresolvedSet
<8> Matches
;
5662 for (LookupResult::iterator P
= Previous
.begin(), PEnd
= Previous
.end();
5664 NamedDecl
*Prev
= *P
;
5665 if (!HasExplicitTemplateArgs
) {
5666 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(Prev
)) {
5667 if (Context
.hasSameUnqualifiedType(Method
->getType(), R
)) {
5670 Matches
.addDecl(Method
, P
.getAccess());
5671 if (Method
->getTemplateSpecializationKind() == TSK_Undeclared
)
5677 FunctionTemplateDecl
*FunTmpl
= dyn_cast
<FunctionTemplateDecl
>(Prev
);
5681 TemplateDeductionInfo
Info(Context
, D
.getIdentifierLoc());
5682 FunctionDecl
*Specialization
= 0;
5683 if (TemplateDeductionResult TDK
5684 = DeduceTemplateArguments(FunTmpl
,
5685 (HasExplicitTemplateArgs
? &TemplateArgs
: 0),
5686 R
, Specialization
, Info
)) {
5687 // FIXME: Keep track of almost-matches?
5692 Matches
.addDecl(Specialization
, P
.getAccess());
5695 // Find the most specialized function template specialization.
5696 UnresolvedSetIterator Result
5697 = getMostSpecialized(Matches
.begin(), Matches
.end(), TPOC_Other
, 0,
5698 D
.getIdentifierLoc(),
5699 PDiag(diag::err_explicit_instantiation_not_known
) << Name
,
5700 PDiag(diag::err_explicit_instantiation_ambiguous
) << Name
,
5701 PDiag(diag::note_explicit_instantiation_candidate
));
5703 if (Result
== Matches
.end())
5706 // Ignore access control bits, we don't need them for redeclaration checking.
5707 FunctionDecl
*Specialization
= cast
<FunctionDecl
>(*Result
);
5709 if (Specialization
->getTemplateSpecializationKind() == TSK_Undeclared
) {
5710 Diag(D
.getIdentifierLoc(),
5711 diag::err_explicit_instantiation_member_function_not_instantiated
)
5713 << (Specialization
->getTemplateSpecializationKind() ==
5714 TSK_ExplicitSpecialization
);
5715 Diag(Specialization
->getLocation(), diag::note_explicit_instantiation_here
);
5719 FunctionDecl
*PrevDecl
= Specialization
->getPreviousDeclaration();
5720 if (!PrevDecl
&& Specialization
->isThisDeclarationADefinition())
5721 PrevDecl
= Specialization
;
5724 bool HasNoEffect
= false;
5725 if (CheckSpecializationInstantiationRedecl(D
.getIdentifierLoc(), TSK
,
5727 PrevDecl
->getTemplateSpecializationKind(),
5728 PrevDecl
->getPointOfInstantiation(),
5732 // FIXME: We may still want to build some representation of this
5733 // explicit specialization.
5738 Specialization
->setTemplateSpecializationKind(TSK
, D
.getIdentifierLoc());
5740 if (TSK
== TSK_ExplicitInstantiationDefinition
)
5741 InstantiateFunctionDefinition(D
.getIdentifierLoc(), Specialization
);
5743 // C++0x [temp.explicit]p2:
5744 // If the explicit instantiation is for a member function, a member class
5745 // or a static data member of a class template specialization, the name of
5746 // the class template specialization in the qualified-id for the member
5747 // name shall be a simple-template-id.
5749 // C++98 has the same restriction, just worded differently.
5750 FunctionTemplateDecl
*FunTmpl
= Specialization
->getPrimaryTemplate();
5751 if (D
.getName().getKind() != UnqualifiedId::IK_TemplateId
&& !FunTmpl
&&
5752 D
.getCXXScopeSpec().isSet() &&
5753 !ScopeSpecifierHasTemplateId(D
.getCXXScopeSpec()))
5754 Diag(D
.getIdentifierLoc(),
5755 diag::ext_explicit_instantiation_without_qualified_id
)
5756 << Specialization
<< D
.getCXXScopeSpec().getRange();
5758 CheckExplicitInstantiationScope(*this,
5759 FunTmpl
? (NamedDecl
*)FunTmpl
5760 : Specialization
->getInstantiatedFromMemberFunction(),
5761 D
.getIdentifierLoc(),
5762 D
.getCXXScopeSpec().isSet());
5764 // FIXME: Create some kind of ExplicitInstantiationDecl here.
5769 Sema::ActOnDependentTag(Scope
*S
, unsigned TagSpec
, TagUseKind TUK
,
5770 const CXXScopeSpec
&SS
, IdentifierInfo
*Name
,
5771 SourceLocation TagLoc
, SourceLocation NameLoc
) {
5772 // This has to hold, because SS is expected to be defined.
5773 assert(Name
&& "Expected a name in a dependent tag");
5775 NestedNameSpecifier
*NNS
5776 = static_cast<NestedNameSpecifier
*>(SS
.getScopeRep());
5780 TagTypeKind Kind
= TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec
);
5782 if (TUK
== TUK_Declaration
|| TUK
== TUK_Definition
) {
5783 Diag(NameLoc
, diag::err_dependent_tag_decl
)
5784 << (TUK
== TUK_Definition
) << Kind
<< SS
.getRange();
5788 ElaboratedTypeKeyword Kwd
= TypeWithKeyword::getKeywordForTagTypeKind(Kind
);
5789 return ParsedType::make(Context
.getDependentNameType(Kwd
, NNS
, Name
));
5793 Sema::ActOnTypenameType(Scope
*S
, SourceLocation TypenameLoc
,
5794 const CXXScopeSpec
&SS
, const IdentifierInfo
&II
,
5795 SourceLocation IdLoc
) {
5796 NestedNameSpecifier
*NNS
5797 = static_cast<NestedNameSpecifier
*>(SS
.getScopeRep());
5801 if (TypenameLoc
.isValid() && S
&& !S
->getTemplateParamParent() &&
5802 !getLangOptions().CPlusPlus0x
)
5803 Diag(TypenameLoc
, diag::ext_typename_outside_of_template
)
5804 << FixItHint::CreateRemoval(TypenameLoc
);
5806 QualType T
= CheckTypenameType(ETK_Typename
, NNS
, II
,
5807 TypenameLoc
, SS
.getRange(), IdLoc
);
5811 TypeSourceInfo
*TSI
= Context
.CreateTypeSourceInfo(T
);
5812 if (isa
<DependentNameType
>(T
)) {
5813 DependentNameTypeLoc TL
= cast
<DependentNameTypeLoc
>(TSI
->getTypeLoc());
5814 TL
.setKeywordLoc(TypenameLoc
);
5815 TL
.setQualifierRange(SS
.getRange());
5816 TL
.setNameLoc(IdLoc
);
5818 ElaboratedTypeLoc TL
= cast
<ElaboratedTypeLoc
>(TSI
->getTypeLoc());
5819 TL
.setKeywordLoc(TypenameLoc
);
5820 TL
.setQualifierRange(SS
.getRange());
5821 cast
<TypeSpecTypeLoc
>(TL
.getNamedTypeLoc()).setNameLoc(IdLoc
);
5824 return CreateParsedType(T
, TSI
);
5828 Sema::ActOnTypenameType(Scope
*S
, SourceLocation TypenameLoc
,
5829 const CXXScopeSpec
&SS
, SourceLocation TemplateLoc
,
5831 if (TypenameLoc
.isValid() && S
&& !S
->getTemplateParamParent() &&
5832 !getLangOptions().CPlusPlus0x
)
5833 Diag(TypenameLoc
, diag::ext_typename_outside_of_template
)
5834 << FixItHint::CreateRemoval(TypenameLoc
);
5836 TypeSourceInfo
*InnerTSI
= 0;
5837 QualType T
= GetTypeFromParser(Ty
, &InnerTSI
);
5839 assert(isa
<TemplateSpecializationType
>(T
) &&
5840 "Expected a template specialization type");
5842 if (computeDeclContext(SS
, false)) {
5843 // If we can compute a declaration context, then the "typename"
5844 // keyword was superfluous. Just build an ElaboratedType to keep
5845 // track of the nested-name-specifier.
5847 // Push the inner type, preserving its source locations if possible.
5848 TypeLocBuilder Builder
;
5850 Builder
.pushFullCopy(InnerTSI
->getTypeLoc());
5852 Builder
.push
<TemplateSpecializationTypeLoc
>(T
).initialize(TemplateLoc
);
5854 /* Note: NNS already embedded in template specialization type T. */
5855 T
= Context
.getElaboratedType(ETK_Typename
, /*NNS=*/0, T
);
5856 ElaboratedTypeLoc TL
= Builder
.push
<ElaboratedTypeLoc
>(T
);
5857 TL
.setKeywordLoc(TypenameLoc
);
5858 TL
.setQualifierRange(SS
.getRange());
5860 TypeSourceInfo
*TSI
= Builder
.getTypeSourceInfo(Context
, T
);
5861 return CreateParsedType(T
, TSI
);
5864 // TODO: it's really silly that we make a template specialization
5865 // type earlier only to drop it again here.
5866 TemplateSpecializationType
*TST
= cast
<TemplateSpecializationType
>(T
);
5867 DependentTemplateName
*DTN
=
5868 TST
->getTemplateName().getAsDependentTemplateName();
5869 assert(DTN
&& "dependent template has non-dependent name?");
5870 assert(DTN
->getQualifier()
5871 == static_cast<NestedNameSpecifier
*>(SS
.getScopeRep()));
5872 T
= Context
.getDependentTemplateSpecializationType(ETK_Typename
,
5873 DTN
->getQualifier(),
5874 DTN
->getIdentifier(),
5877 TypeSourceInfo
*TSI
= Context
.CreateTypeSourceInfo(T
);
5878 DependentTemplateSpecializationTypeLoc TL
=
5879 cast
<DependentTemplateSpecializationTypeLoc
>(TSI
->getTypeLoc());
5881 TemplateSpecializationTypeLoc TSTL
=
5882 cast
<TemplateSpecializationTypeLoc
>(InnerTSI
->getTypeLoc());
5883 TL
.setLAngleLoc(TSTL
.getLAngleLoc());
5884 TL
.setRAngleLoc(TSTL
.getRAngleLoc());
5885 for (unsigned I
= 0, E
= TST
->getNumArgs(); I
!= E
; ++I
)
5886 TL
.setArgLocInfo(I
, TSTL
.getArgLocInfo(I
));
5888 TL
.initializeLocal(SourceLocation());
5890 TL
.setKeywordLoc(TypenameLoc
);
5891 TL
.setQualifierRange(SS
.getRange());
5892 return CreateParsedType(T
, TSI
);
5895 /// \brief Build the type that describes a C++ typename specifier,
5896 /// e.g., "typename T::type".
5898 Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword
,
5899 NestedNameSpecifier
*NNS
, const IdentifierInfo
&II
,
5900 SourceLocation KeywordLoc
, SourceRange NNSRange
,
5901 SourceLocation IILoc
) {
5903 SS
.setScopeRep(NNS
);
5904 SS
.setRange(NNSRange
);
5906 DeclContext
*Ctx
= computeDeclContext(SS
);
5908 // If the nested-name-specifier is dependent and couldn't be
5909 // resolved to a type, build a typename type.
5910 assert(NNS
->isDependent());
5911 return Context
.getDependentNameType(Keyword
, NNS
, &II
);
5914 // If the nested-name-specifier refers to the current instantiation,
5915 // the "typename" keyword itself is superfluous. In C++03, the
5916 // program is actually ill-formed. However, DR 382 (in C++0x CD1)
5917 // allows such extraneous "typename" keywords, and we retroactively
5918 // apply this DR to C++03 code with only a warning. In any case we continue.
5920 if (RequireCompleteDeclContext(SS
, Ctx
))
5923 DeclarationName
Name(&II
);
5924 LookupResult
Result(*this, Name
, IILoc
, LookupOrdinaryName
);
5925 LookupQualifiedName(Result
, Ctx
);
5926 unsigned DiagID
= 0;
5927 Decl
*Referenced
= 0;
5928 switch (Result
.getResultKind()) {
5929 case LookupResult::NotFound
:
5930 DiagID
= diag::err_typename_nested_not_found
;
5933 case LookupResult::FoundUnresolvedValue
: {
5934 // We found a using declaration that is a value. Most likely, the using
5935 // declaration itself is meant to have the 'typename' keyword.
5936 SourceRange
FullRange(KeywordLoc
.isValid() ? KeywordLoc
: NNSRange
.getBegin(),
5938 Diag(IILoc
, diag::err_typename_refers_to_using_value_decl
)
5939 << Name
<< Ctx
<< FullRange
;
5940 if (UnresolvedUsingValueDecl
*Using
5941 = dyn_cast
<UnresolvedUsingValueDecl
>(Result
.getRepresentativeDecl())){
5942 SourceLocation Loc
= Using
->getTargetNestedNameRange().getBegin();
5943 Diag(Loc
, diag::note_using_value_decl_missing_typename
)
5944 << FixItHint::CreateInsertion(Loc
, "typename ");
5947 // Fall through to create a dependent typename type, from which we can recover
5950 case LookupResult::NotFoundInCurrentInstantiation
:
5951 // Okay, it's a member of an unknown instantiation.
5952 return Context
.getDependentNameType(Keyword
, NNS
, &II
);
5954 case LookupResult::Found
:
5955 if (TypeDecl
*Type
= dyn_cast
<TypeDecl
>(Result
.getFoundDecl())) {
5956 // We found a type. Build an ElaboratedType, since the
5957 // typename-specifier was just sugar.
5958 return Context
.getElaboratedType(ETK_Typename
, NNS
,
5959 Context
.getTypeDeclType(Type
));
5962 DiagID
= diag::err_typename_nested_not_type
;
5963 Referenced
= Result
.getFoundDecl();
5967 llvm_unreachable("unresolved using decl in non-dependent context");
5970 case LookupResult::FoundOverloaded
:
5971 DiagID
= diag::err_typename_nested_not_type
;
5972 Referenced
= *Result
.begin();
5975 case LookupResult::Ambiguous
:
5979 // If we get here, it's because name lookup did not find a
5980 // type. Emit an appropriate diagnostic and return an error.
5981 SourceRange
FullRange(KeywordLoc
.isValid() ? KeywordLoc
: NNSRange
.getBegin(),
5983 Diag(IILoc
, DiagID
) << FullRange
<< Name
<< Ctx
;
5985 Diag(Referenced
->getLocation(), diag::note_typename_refers_here
)
5991 // See Sema::RebuildTypeInCurrentInstantiation
5992 class CurrentInstantiationRebuilder
5993 : public TreeTransform
<CurrentInstantiationRebuilder
> {
5995 DeclarationName Entity
;
5998 typedef TreeTransform
<CurrentInstantiationRebuilder
> inherited
;
6000 CurrentInstantiationRebuilder(Sema
&SemaRef
,
6002 DeclarationName Entity
)
6003 : TreeTransform
<CurrentInstantiationRebuilder
>(SemaRef
),
6004 Loc(Loc
), Entity(Entity
) { }
6006 /// \brief Determine whether the given type \p T has already been
6009 /// For the purposes of type reconstruction, a type has already been
6010 /// transformed if it is NULL or if it is not dependent.
6011 bool AlreadyTransformed(QualType T
) {
6012 return T
.isNull() || !T
->isDependentType();
6015 /// \brief Returns the location of the entity whose type is being
6017 SourceLocation
getBaseLocation() { return Loc
; }
6019 /// \brief Returns the name of the entity whose type is being rebuilt.
6020 DeclarationName
getBaseEntity() { return Entity
; }
6022 /// \brief Sets the "base" location and entity when that
6023 /// information is known based on another transformation.
6024 void setBase(SourceLocation Loc
, DeclarationName Entity
) {
6026 this->Entity
= Entity
;
6031 /// \brief Rebuilds a type within the context of the current instantiation.
6033 /// The type \p T is part of the type of an out-of-line member definition of
6034 /// a class template (or class template partial specialization) that was parsed
6035 /// and constructed before we entered the scope of the class template (or
6036 /// partial specialization thereof). This routine will rebuild that type now
6037 /// that we have entered the declarator's scope, which may produce different
6038 /// canonical types, e.g.,
6041 /// template<typename T>
6043 /// typedef T* pointer;
6047 /// template<typename T>
6048 /// typename X<T>::pointer X<T>::data() { ... }
6051 /// Here, the type "typename X<T>::pointer" will be created as a DependentNameType,
6052 /// since we do not know that we can look into X<T> when we parsed the type.
6053 /// This function will rebuild the type, performing the lookup of "pointer"
6054 /// in X<T> and returning an ElaboratedType whose canonical type is the same
6055 /// as the canonical type of T*, allowing the return types of the out-of-line
6056 /// definition and the declaration to match.
6057 TypeSourceInfo
*Sema::RebuildTypeInCurrentInstantiation(TypeSourceInfo
*T
,
6059 DeclarationName Name
) {
6060 if (!T
|| !T
->getType()->isDependentType())
6063 CurrentInstantiationRebuilder
Rebuilder(*this, Loc
, Name
);
6064 return Rebuilder
.TransformType(T
);
6067 ExprResult
Sema::RebuildExprInCurrentInstantiation(Expr
*E
) {
6068 CurrentInstantiationRebuilder
Rebuilder(*this, E
->getExprLoc(),
6070 return Rebuilder
.TransformExpr(E
);
6073 bool Sema::RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec
&SS
) {
6074 if (SS
.isInvalid()) return true;
6076 NestedNameSpecifier
*NNS
= static_cast<NestedNameSpecifier
*>(SS
.getScopeRep());
6077 CurrentInstantiationRebuilder
Rebuilder(*this, SS
.getRange().getBegin(),
6079 NestedNameSpecifier
*Rebuilt
=
6080 Rebuilder
.TransformNestedNameSpecifier(NNS
, SS
.getRange());
6081 if (!Rebuilt
) return true;
6083 SS
.setScopeRep(Rebuilt
);
6087 /// \brief Produces a formatted string that describes the binding of
6088 /// template parameters to template arguments.
6090 Sema::getTemplateArgumentBindingsText(const TemplateParameterList
*Params
,
6091 const TemplateArgumentList
&Args
) {
6092 return getTemplateArgumentBindingsText(Params
, Args
.data(), Args
.size());
6096 Sema::getTemplateArgumentBindingsText(const TemplateParameterList
*Params
,
6097 const TemplateArgument
*Args
,
6099 llvm::SmallString
<128> Str
;
6100 llvm::raw_svector_ostream
Out(Str
);
6102 if (!Params
|| Params
->size() == 0 || NumArgs
== 0)
6103 return std::string();
6105 for (unsigned I
= 0, N
= Params
->size(); I
!= N
; ++I
) {
6114 if (const IdentifierInfo
*Id
= Params
->getParam(I
)->getIdentifier()) {
6115 Out
<< Id
->getName();
6121 Args
[I
].print(Context
.PrintingPolicy
, Out
);