clang  3.9.0
SemaTemplate.cpp
Go to the documentation of this file.
1 //===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements semantic analysis for C++ templates.
10 //===----------------------------------------------------------------------===//
11 
12 #include "TreeTransform.h"
13 #include "clang/AST/ASTConsumer.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/DeclFriend.h"
16 #include "clang/AST/DeclTemplate.h"
17 #include "clang/AST/Expr.h"
18 #include "clang/AST/ExprCXX.h"
20 #include "clang/AST/TypeVisitor.h"
21 #include "clang/Basic/Builtins.h"
24 #include "clang/Basic/TargetInfo.h"
25 #include "clang/Sema/DeclSpec.h"
26 #include "clang/Sema/Lookup.h"
28 #include "clang/Sema/Scope.h"
30 #include "clang/Sema/Template.h"
32 #include "llvm/ADT/SmallBitVector.h"
33 #include "llvm/ADT/SmallString.h"
34 #include "llvm/ADT/StringExtras.h"
35 
36 #include <iterator>
37 using namespace clang;
38 using namespace sema;
39 
40 // Exported for use by Parser.
43  unsigned N) {
44  if (!N) return SourceRange();
45  return SourceRange(Ps[0]->getTemplateLoc(), Ps[N-1]->getRAngleLoc());
46 }
47 
48 /// \brief Determine whether the declaration found is acceptable as the name
49 /// of a template and, if so, return that template declaration. Otherwise,
50 /// returns NULL.
52  NamedDecl *Orig,
53  bool AllowFunctionTemplates) {
54  NamedDecl *D = Orig->getUnderlyingDecl();
55 
56  if (isa<TemplateDecl>(D)) {
57  if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(D))
58  return nullptr;
59 
60  return Orig;
61  }
62 
63  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
64  // C++ [temp.local]p1:
65  // Like normal (non-template) classes, class templates have an
66  // injected-class-name (Clause 9). The injected-class-name
67  // can be used with or without a template-argument-list. When
68  // it is used without a template-argument-list, it is
69  // equivalent to the injected-class-name followed by the
70  // template-parameters of the class template enclosed in
71  // <>. When it is used with a template-argument-list, it
72  // refers to the specified class template specialization,
73  // which could be the current specialization or another
74  // specialization.
75  if (Record->isInjectedClassName()) {
76  Record = cast<CXXRecordDecl>(Record->getDeclContext());
77  if (Record->getDescribedClassTemplate())
78  return Record->getDescribedClassTemplate();
79 
81  = dyn_cast<ClassTemplateSpecializationDecl>(Record))
82  return Spec->getSpecializedTemplate();
83  }
84 
85  return nullptr;
86  }
87 
88  return nullptr;
89 }
90 
92  bool AllowFunctionTemplates) {
93  // The set of class templates we've already seen.
94  llvm::SmallPtrSet<ClassTemplateDecl *, 8> ClassTemplates;
95  LookupResult::Filter filter = R.makeFilter();
96  while (filter.hasNext()) {
97  NamedDecl *Orig = filter.next();
99  AllowFunctionTemplates);
100  if (!Repl)
101  filter.erase();
102  else if (Repl != Orig) {
103 
104  // C++ [temp.local]p3:
105  // A lookup that finds an injected-class-name (10.2) can result in an
106  // ambiguity in certain cases (for example, if it is found in more than
107  // one base class). If all of the injected-class-names that are found
108  // refer to specializations of the same class template, and if the name
109  // is used as a template-name, the reference refers to the class
110  // template itself and not a specialization thereof, and is not
111  // ambiguous.
112  if (ClassTemplateDecl *ClassTmpl = dyn_cast<ClassTemplateDecl>(Repl))
113  if (!ClassTemplates.insert(ClassTmpl).second) {
114  filter.erase();
115  continue;
116  }
117 
118  // FIXME: we promote access to public here as a workaround to
119  // the fact that LookupResult doesn't let us remember that we
120  // found this template through a particular injected class name,
121  // which means we end up doing nasty things to the invariants.
122  // Pretending that access is public is *much* safer.
123  filter.replace(Repl, AS_public);
124  }
125  }
126  filter.done();
127 }
128 
130  bool AllowFunctionTemplates) {
131  for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I)
132  if (isAcceptableTemplateName(Context, *I, AllowFunctionTemplates))
133  return true;
134 
135  return false;
136 }
137 
139  CXXScopeSpec &SS,
140  bool hasTemplateKeyword,
142  ParsedType ObjectTypePtr,
143  bool EnteringContext,
144  TemplateTy &TemplateResult,
145  bool &MemberOfUnknownSpecialization) {
146  assert(getLangOpts().CPlusPlus && "No template names in C!");
147 
148  DeclarationName TName;
149  MemberOfUnknownSpecialization = false;
150 
151  switch (Name.getKind()) {
153  TName = DeclarationName(Name.Identifier);
154  break;
155 
159  break;
160 
163  break;
164 
165  default:
166  return TNK_Non_template;
167  }
168 
169  QualType ObjectType = ObjectTypePtr.get();
170 
171  LookupResult R(*this, TName, Name.getLocStart(), LookupOrdinaryName);
172  LookupTemplateName(R, S, SS, ObjectType, EnteringContext,
173  MemberOfUnknownSpecialization);
174  if (R.empty()) return TNK_Non_template;
175  if (R.isAmbiguous()) {
176  // Suppress diagnostics; we'll redo this lookup later.
177  R.suppressDiagnostics();
178 
179  // FIXME: we might have ambiguous templates, in which case we
180  // should at least parse them properly!
181  return TNK_Non_template;
182  }
183 
184  TemplateName Template;
185  TemplateNameKind TemplateKind;
186 
187  unsigned ResultCount = R.end() - R.begin();
188  if (ResultCount > 1) {
189  // We assume that we'll preserve the qualifier from a function
190  // template name in other ways.
191  Template = Context.getOverloadedTemplateName(R.begin(), R.end());
192  TemplateKind = TNK_Function_template;
193 
194  // We'll do this lookup again later.
195  R.suppressDiagnostics();
196  } else {
197  TemplateDecl *TD = cast<TemplateDecl>((*R.begin())->getUnderlyingDecl());
198 
199  if (SS.isSet() && !SS.isInvalid()) {
200  NestedNameSpecifier *Qualifier = SS.getScopeRep();
201  Template = Context.getQualifiedTemplateName(Qualifier,
202  hasTemplateKeyword, TD);
203  } else {
204  Template = TemplateName(TD);
205  }
206 
207  if (isa<FunctionTemplateDecl>(TD)) {
208  TemplateKind = TNK_Function_template;
209 
210  // We'll do this lookup again later.
211  R.suppressDiagnostics();
212  } else {
213  assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
214  isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||
215  isa<BuiltinTemplateDecl>(TD));
216  TemplateKind =
217  isa<VarTemplateDecl>(TD) ? TNK_Var_template : TNK_Type_template;
218  }
219  }
220 
221  TemplateResult = TemplateTy::make(Template);
222  return TemplateKind;
223 }
224 
226  SourceLocation IILoc,
227  Scope *S,
228  const CXXScopeSpec *SS,
229  TemplateTy &SuggestedTemplate,
230  TemplateNameKind &SuggestedKind) {
231  // We can't recover unless there's a dependent scope specifier preceding the
232  // template name.
233  // FIXME: Typo correction?
234  if (!SS || !SS->isSet() || !isDependentScopeSpecifier(*SS) ||
235  computeDeclContext(*SS))
236  return false;
237 
238  // The code is missing a 'template' keyword prior to the dependent template
239  // name.
241  Diag(IILoc, diag::err_template_kw_missing)
242  << Qualifier << II.getName()
243  << FixItHint::CreateInsertion(IILoc, "template ");
244  SuggestedTemplate
245  = TemplateTy::make(Context.getDependentTemplateName(Qualifier, &II));
246  SuggestedKind = TNK_Dependent_template_name;
247  return true;
248 }
249 
251  Scope *S, CXXScopeSpec &SS,
252  QualType ObjectType,
253  bool EnteringContext,
254  bool &MemberOfUnknownSpecialization) {
255  // Determine where to perform name lookup
256  MemberOfUnknownSpecialization = false;
257  DeclContext *LookupCtx = nullptr;
258  bool isDependent = false;
259  if (!ObjectType.isNull()) {
260  // This nested-name-specifier occurs in a member access expression, e.g.,
261  // x->B::f, and we are looking into the type of the object.
262  assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
263  LookupCtx = computeDeclContext(ObjectType);
264  isDependent = ObjectType->isDependentType();
265  assert((isDependent || !ObjectType->isIncompleteType() ||
266  ObjectType->castAs<TagType>()->isBeingDefined()) &&
267  "Caller should have completed object type");
268 
269  // Template names cannot appear inside an Objective-C class or object type.
270  if (ObjectType->isObjCObjectOrInterfaceType()) {
271  Found.clear();
272  return;
273  }
274  } else if (SS.isSet()) {
275  // This nested-name-specifier occurs after another nested-name-specifier,
276  // so long into the context associated with the prior nested-name-specifier.
277  LookupCtx = computeDeclContext(SS, EnteringContext);
278  isDependent = isDependentScopeSpecifier(SS);
279 
280  // The declaration context must be complete.
281  if (LookupCtx && RequireCompleteDeclContext(SS, LookupCtx))
282  return;
283  }
284 
285  bool ObjectTypeSearchedInScope = false;
286  bool AllowFunctionTemplatesInLookup = true;
287  if (LookupCtx) {
288  // Perform "qualified" name lookup into the declaration context we
289  // computed, which is either the type of the base of a member access
290  // expression or the declaration context associated with a prior
291  // nested-name-specifier.
292  LookupQualifiedName(Found, LookupCtx);
293  if (!ObjectType.isNull() && Found.empty()) {
294  // C++ [basic.lookup.classref]p1:
295  // In a class member access expression (5.2.5), if the . or -> token is
296  // immediately followed by an identifier followed by a <, the
297  // identifier must be looked up to determine whether the < is the
298  // beginning of a template argument list (14.2) or a less-than operator.
299  // The identifier is first looked up in the class of the object
300  // expression. If the identifier is not found, it is then looked up in
301  // the context of the entire postfix-expression and shall name a class
302  // or function template.
303  if (S) LookupName(Found, S);
304  ObjectTypeSearchedInScope = true;
305  AllowFunctionTemplatesInLookup = false;
306  }
307  } else if (isDependent && (!S || ObjectType.isNull())) {
308  // We cannot look into a dependent object type or nested nme
309  // specifier.
310  MemberOfUnknownSpecialization = true;
311  return;
312  } else {
313  // Perform unqualified name lookup in the current scope.
314  LookupName(Found, S);
315 
316  if (!ObjectType.isNull())
317  AllowFunctionTemplatesInLookup = false;
318  }
319 
320  if (Found.empty() && !isDependent) {
321  // If we did not find any names, attempt to correct any typos.
323  Found.clear();
324  // Simple filter callback that, for keywords, only accepts the C++ *_cast
325  auto FilterCCC = llvm::make_unique<CorrectionCandidateCallback>();
326  FilterCCC->WantTypeSpecifiers = false;
327  FilterCCC->WantExpressionKeywords = false;
328  FilterCCC->WantRemainingKeywords = false;
329  FilterCCC->WantCXXNamedCasts = true;
330  if (TypoCorrection Corrected = CorrectTypo(
331  Found.getLookupNameInfo(), Found.getLookupKind(), S, &SS,
332  std::move(FilterCCC), CTK_ErrorRecovery, LookupCtx)) {
333  Found.setLookupName(Corrected.getCorrection());
334  if (auto *ND = Corrected.getFoundDecl())
335  Found.addDecl(ND);
336  FilterAcceptableTemplateNames(Found);
337  if (!Found.empty()) {
338  if (LookupCtx) {
339  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
340  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
341  Name.getAsString() == CorrectedStr;
342  diagnoseTypo(Corrected, PDiag(diag::err_no_member_template_suggest)
343  << Name << LookupCtx << DroppedSpecifier
344  << SS.getRange());
345  } else {
346  diagnoseTypo(Corrected, PDiag(diag::err_no_template_suggest) << Name);
347  }
348  }
349  } else {
350  Found.setLookupName(Name);
351  }
352  }
353 
354  FilterAcceptableTemplateNames(Found, AllowFunctionTemplatesInLookup);
355  if (Found.empty()) {
356  if (isDependent)
357  MemberOfUnknownSpecialization = true;
358  return;
359  }
360 
361  if (S && !ObjectType.isNull() && !ObjectTypeSearchedInScope &&
362  !getLangOpts().CPlusPlus11) {
363  // C++03 [basic.lookup.classref]p1:
364  // [...] If the lookup in the class of the object expression finds a
365  // template, the name is also looked up in the context of the entire
366  // postfix-expression and [...]
367  //
368  // Note: C++11 does not perform this second lookup.
369  LookupResult FoundOuter(*this, Found.getLookupName(), Found.getNameLoc(),
370  LookupOrdinaryName);
371  LookupName(FoundOuter, S);
372  FilterAcceptableTemplateNames(FoundOuter, /*AllowFunctionTemplates=*/false);
373 
374  if (FoundOuter.empty()) {
375  // - if the name is not found, the name found in the class of the
376  // object expression is used, otherwise
377  } else if (!FoundOuter.getAsSingle<ClassTemplateDecl>() ||
378  FoundOuter.isAmbiguous()) {
379  // - if the name is found in the context of the entire
380  // postfix-expression and does not name a class template, the name
381  // found in the class of the object expression is used, otherwise
382  FoundOuter.clear();
383  } else if (!Found.isSuppressingDiagnostics()) {
384  // - if the name found is a class template, it must refer to the same
385  // entity as the one found in the class of the object expression,
386  // otherwise the program is ill-formed.
387  if (!Found.isSingleResult() ||
388  Found.getFoundDecl()->getCanonicalDecl()
389  != FoundOuter.getFoundDecl()->getCanonicalDecl()) {
390  Diag(Found.getNameLoc(),
391  diag::ext_nested_name_member_ref_lookup_ambiguous)
392  << Found.getLookupName()
393  << ObjectType;
394  Diag(Found.getRepresentativeDecl()->getLocation(),
395  diag::note_ambig_member_ref_object_type)
396  << ObjectType;
397  Diag(FoundOuter.getFoundDecl()->getLocation(),
398  diag::note_ambig_member_ref_scope);
399 
400  // Recover by taking the template that we found in the object
401  // expression's type.
402  }
403  }
404  }
405 }
406 
407 /// ActOnDependentIdExpression - Handle a dependent id-expression that
408 /// was just parsed. This is only possible with an explicit scope
409 /// specifier naming a dependent type.
412  SourceLocation TemplateKWLoc,
413  const DeclarationNameInfo &NameInfo,
414  bool isAddressOfOperand,
415  const TemplateArgumentListInfo *TemplateArgs) {
416  DeclContext *DC = getFunctionLevelDeclContext();
417 
418  // C++11 [expr.prim.general]p12:
419  // An id-expression that denotes a non-static data member or non-static
420  // member function of a class can only be used:
421  // (...)
422  // - if that id-expression denotes a non-static data member and it
423  // appears in an unevaluated operand.
424  //
425  // If this might be the case, form a DependentScopeDeclRefExpr instead of a
426  // CXXDependentScopeMemberExpr. The former can instantiate to either
427  // DeclRefExpr or MemberExpr depending on lookup results, while the latter is
428  // always a MemberExpr.
429  bool MightBeCxx11UnevalField =
430  getLangOpts().CPlusPlus11 && isUnevaluatedContext();
431 
432  if (!MightBeCxx11UnevalField && !isAddressOfOperand &&
433  isa<CXXMethodDecl>(DC) && cast<CXXMethodDecl>(DC)->isInstance()) {
434  QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType(Context);
435 
436  // Since the 'this' expression is synthesized, we don't need to
437  // perform the double-lookup check.
438  NamedDecl *FirstQualifierInScope = nullptr;
439 
441  Context, /*This*/ nullptr, ThisType, /*IsArrow*/ true,
442  /*Op*/ SourceLocation(), SS.getWithLocInContext(Context), TemplateKWLoc,
443  FirstQualifierInScope, NameInfo, TemplateArgs);
444  }
445 
446  return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
447 }
448 
451  SourceLocation TemplateKWLoc,
452  const DeclarationNameInfo &NameInfo,
453  const TemplateArgumentListInfo *TemplateArgs) {
455  Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
456  TemplateArgs);
457 }
458 
459 /// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining
460 /// that the template parameter 'PrevDecl' is being shadowed by a new
461 /// declaration at location Loc. Returns true to indicate that this is
462 /// an error, and false otherwise.
464  assert(PrevDecl->isTemplateParameter() && "Not a template parameter");
465 
466  // Microsoft Visual C++ permits template parameters to be shadowed.
467  if (getLangOpts().MicrosoftExt)
468  return;
469 
470  // C++ [temp.local]p4:
471  // A template-parameter shall not be redeclared within its
472  // scope (including nested scopes).
473  Diag(Loc, diag::err_template_param_shadow)
474  << cast<NamedDecl>(PrevDecl)->getDeclName();
475  Diag(PrevDecl->getLocation(), diag::note_template_param_here);
476 }
477 
478 /// AdjustDeclIfTemplate - If the given decl happens to be a template, reset
479 /// the parameter D to reference the templated declaration and return a pointer
480 /// to the template declaration. Otherwise, do nothing to D and return null.
482  if (TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
483  D = Temp->getTemplatedDecl();
484  return Temp;
485  }
486  return nullptr;
487 }
488 
490  SourceLocation EllipsisLoc) const {
491  assert(Kind == Template &&
492  "Only template template arguments can be pack expansions here");
493  assert(getAsTemplate().get().containsUnexpandedParameterPack() &&
494  "Template template argument pack expansion without packs");
496  Result.EllipsisLoc = EllipsisLoc;
497  return Result;
498 }
499 
501  const ParsedTemplateArgument &Arg) {
502 
503  switch (Arg.getKind()) {
505  TypeSourceInfo *DI;
506  QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &DI);
507  if (!DI)
508  DI = SemaRef.Context.getTrivialTypeSourceInfo(T, Arg.getLocation());
509  return TemplateArgumentLoc(TemplateArgument(T), DI);
510  }
511 
513  Expr *E = static_cast<Expr *>(Arg.getAsExpr());
515  }
516 
518  TemplateName Template = Arg.getAsTemplate().get();
519  TemplateArgument TArg;
520  if (Arg.getEllipsisLoc().isValid())
521  TArg = TemplateArgument(Template, Optional<unsigned int>());
522  else
523  TArg = Template;
524  return TemplateArgumentLoc(TArg,
526  SemaRef.Context),
527  Arg.getLocation(),
528  Arg.getEllipsisLoc());
529  }
530  }
531 
532  llvm_unreachable("Unhandled parsed template argument");
533 }
534 
535 /// \brief Translates template arguments as provided by the parser
536 /// into template arguments used by semantic analysis.
538  TemplateArgumentListInfo &TemplateArgs) {
539  for (unsigned I = 0, Last = TemplateArgsIn.size(); I != Last; ++I)
540  TemplateArgs.addArgument(translateTemplateArgument(*this,
541  TemplateArgsIn[I]));
542 }
543 
545  SourceLocation Loc,
546  IdentifierInfo *Name) {
547  NamedDecl *PrevDecl = SemaRef.LookupSingleName(
549  if (PrevDecl && PrevDecl->isTemplateParameter())
550  SemaRef.DiagnoseTemplateParameterShadow(Loc, PrevDecl);
551 }
552 
553 /// ActOnTypeParameter - Called when a C++ template type parameter
554 /// (e.g., "typename T") has been parsed. Typename specifies whether
555 /// the keyword "typename" was used to declare the type parameter
556 /// (otherwise, "class" was used), and KeyLoc is the location of the
557 /// "class" or "typename" keyword. ParamName is the name of the
558 /// parameter (NULL indicates an unnamed template parameter) and
559 /// ParamNameLoc is the location of the parameter name (if any).
560 /// If the type parameter has a default argument, it will be added
561 /// later via ActOnTypeParameterDefault.
563  SourceLocation EllipsisLoc,
564  SourceLocation KeyLoc,
565  IdentifierInfo *ParamName,
566  SourceLocation ParamNameLoc,
567  unsigned Depth, unsigned Position,
568  SourceLocation EqualLoc,
569  ParsedType DefaultArg) {
570  assert(S->isTemplateParamScope() &&
571  "Template type parameter not in template parameter scope!");
572 
573  SourceLocation Loc = ParamNameLoc;
574  if (!ParamName)
575  Loc = KeyLoc;
576 
577  bool IsParameterPack = EllipsisLoc.isValid();
578  TemplateTypeParmDecl *Param
580  KeyLoc, Loc, Depth, Position, ParamName,
581  Typename, IsParameterPack);
582  Param->setAccess(AS_public);
583 
584  if (ParamName) {
585  maybeDiagnoseTemplateParameterShadow(*this, S, ParamNameLoc, ParamName);
586 
587  // Add the template parameter into the current scope.
588  S->AddDecl(Param);
589  IdResolver.AddDecl(Param);
590  }
591 
592  // C++0x [temp.param]p9:
593  // A default template-argument may be specified for any kind of
594  // template-parameter that is not a template parameter pack.
595  if (DefaultArg && IsParameterPack) {
596  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
597  DefaultArg = nullptr;
598  }
599 
600  // Handle the default argument, if provided.
601  if (DefaultArg) {
602  TypeSourceInfo *DefaultTInfo;
603  GetTypeFromParser(DefaultArg, &DefaultTInfo);
604 
605  assert(DefaultTInfo && "expected source information for type");
606 
607  // Check for unexpanded parameter packs.
608  if (DiagnoseUnexpandedParameterPack(Loc, DefaultTInfo,
609  UPPC_DefaultArgument))
610  return Param;
611 
612  // Check the template argument itself.
613  if (CheckTemplateArgument(Param, DefaultTInfo)) {
614  Param->setInvalidDecl();
615  return Param;
616  }
617 
618  Param->setDefaultArgument(DefaultTInfo);
619  }
620 
621  return Param;
622 }
623 
624 /// \brief Check that the type of a non-type template parameter is
625 /// well-formed.
626 ///
627 /// \returns the (possibly-promoted) parameter type if valid;
628 /// otherwise, produces a diagnostic and returns a NULL type.
629 QualType
631  // We don't allow variably-modified types as the type of non-type template
632  // parameters.
633  if (T->isVariablyModifiedType()) {
634  Diag(Loc, diag::err_variably_modified_nontype_template_param)
635  << T;
636  return QualType();
637  }
638 
639  // C++ [temp.param]p4:
640  //
641  // A non-type template-parameter shall have one of the following
642  // (optionally cv-qualified) types:
643  //
644  // -- integral or enumeration type,
645  if (T->isIntegralOrEnumerationType() ||
646  // -- pointer to object or pointer to function,
647  T->isPointerType() ||
648  // -- reference to object or reference to function,
649  T->isReferenceType() ||
650  // -- pointer to member,
651  T->isMemberPointerType() ||
652  // -- std::nullptr_t.
653  T->isNullPtrType() ||
654  // If T is a dependent type, we can't do the check now, so we
655  // assume that it is well-formed.
656  T->isDependentType()) {
657  // C++ [temp.param]p5: The top-level cv-qualifiers on the template-parameter
658  // are ignored when determining its type.
659  return T.getUnqualifiedType();
660  }
661 
662  // C++ [temp.param]p8:
663  //
664  // A non-type template-parameter of type "array of T" or
665  // "function returning T" is adjusted to be of type "pointer to
666  // T" or "pointer to function returning T", respectively.
667  else if (T->isArrayType() || T->isFunctionType())
668  return Context.getDecayedType(T);
669 
670  Diag(Loc, diag::err_template_nontype_parm_bad_type)
671  << T;
672 
673  return QualType();
674 }
675 
677  unsigned Depth,
678  unsigned Position,
679  SourceLocation EqualLoc,
680  Expr *Default) {
681  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
682  QualType T = TInfo->getType();
683 
684  assert(S->isTemplateParamScope() &&
685  "Non-type template parameter not in template parameter scope!");
686  bool Invalid = false;
687 
688  T = CheckNonTypeTemplateParameterType(T, D.getIdentifierLoc());
689  if (T.isNull()) {
690  T = Context.IntTy; // Recover with an 'int' type.
691  Invalid = true;
692  }
693 
694  IdentifierInfo *ParamName = D.getIdentifier();
695  bool IsParameterPack = D.hasEllipsis();
698  D.getLocStart(),
699  D.getIdentifierLoc(),
700  Depth, Position, ParamName, T,
701  IsParameterPack, TInfo);
702  Param->setAccess(AS_public);
703 
704  if (Invalid)
705  Param->setInvalidDecl();
706 
707  if (ParamName) {
709  ParamName);
710 
711  // Add the template parameter into the current scope.
712  S->AddDecl(Param);
713  IdResolver.AddDecl(Param);
714  }
715 
716  // C++0x [temp.param]p9:
717  // A default template-argument may be specified for any kind of
718  // template-parameter that is not a template parameter pack.
719  if (Default && IsParameterPack) {
720  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
721  Default = nullptr;
722  }
723 
724  // Check the well-formedness of the default template argument, if provided.
725  if (Default) {
726  // Check for unexpanded parameter packs.
727  if (DiagnoseUnexpandedParameterPack(Default, UPPC_DefaultArgument))
728  return Param;
729 
730  TemplateArgument Converted;
731  ExprResult DefaultRes =
732  CheckTemplateArgument(Param, Param->getType(), Default, Converted);
733  if (DefaultRes.isInvalid()) {
734  Param->setInvalidDecl();
735  return Param;
736  }
737  Default = DefaultRes.get();
738 
739  Param->setDefaultArgument(Default);
740  }
741 
742  return Param;
743 }
744 
745 /// ActOnTemplateTemplateParameter - Called when a C++ template template
746 /// parameter (e.g. T in template <template <typename> class T> class array)
747 /// has been parsed. S is the current scope.
749  SourceLocation TmpLoc,
750  TemplateParameterList *Params,
751  SourceLocation EllipsisLoc,
753  SourceLocation NameLoc,
754  unsigned Depth,
755  unsigned Position,
756  SourceLocation EqualLoc,
757  ParsedTemplateArgument Default) {
758  assert(S->isTemplateParamScope() &&
759  "Template template parameter not in template parameter scope!");
760 
761  // Construct the parameter object.
762  bool IsParameterPack = EllipsisLoc.isValid();
763  TemplateTemplateParmDecl *Param =
765  NameLoc.isInvalid()? TmpLoc : NameLoc,
766  Depth, Position, IsParameterPack,
767  Name, Params);
768  Param->setAccess(AS_public);
769 
770  // If the template template parameter has a name, then link the identifier
771  // into the scope and lookup mechanisms.
772  if (Name) {
773  maybeDiagnoseTemplateParameterShadow(*this, S, NameLoc, Name);
774 
775  S->AddDecl(Param);
776  IdResolver.AddDecl(Param);
777  }
778 
779  if (Params->size() == 0) {
780  Diag(Param->getLocation(), diag::err_template_template_parm_no_parms)
781  << SourceRange(Params->getLAngleLoc(), Params->getRAngleLoc());
782  Param->setInvalidDecl();
783  }
784 
785  // C++0x [temp.param]p9:
786  // A default template-argument may be specified for any kind of
787  // template-parameter that is not a template parameter pack.
788  if (IsParameterPack && !Default.isInvalid()) {
789  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
790  Default = ParsedTemplateArgument();
791  }
792 
793  if (!Default.isInvalid()) {
794  // Check only that we have a template template argument. We don't want to
795  // try to check well-formedness now, because our template template parameter
796  // might have dependent types in its template parameters, which we wouldn't
797  // be able to match now.
798  //
799  // If none of the template template parameter's template arguments mention
800  // other template parameters, we could actually perform more checking here.
801  // However, it isn't worth doing.
802  TemplateArgumentLoc DefaultArg = translateTemplateArgument(*this, Default);
803  if (DefaultArg.getArgument().getAsTemplate().isNull()) {
804  Diag(DefaultArg.getLocation(), diag::err_template_arg_not_valid_template)
805  << DefaultArg.getSourceRange();
806  return Param;
807  }
808 
809  // Check for unexpanded parameter packs.
810  if (DiagnoseUnexpandedParameterPack(DefaultArg.getLocation(),
811  DefaultArg.getArgument().getAsTemplate(),
812  UPPC_DefaultArgument))
813  return Param;
814 
815  Param->setDefaultArgument(Context, DefaultArg);
816  }
817 
818  return Param;
819 }
820 
821 /// ActOnTemplateParameterList - Builds a TemplateParameterList, optionally
822 /// constrained by RequiresClause, that contains the template parameters in
823 /// Params.
826  SourceLocation ExportLoc,
827  SourceLocation TemplateLoc,
828  SourceLocation LAngleLoc,
829  ArrayRef<Decl *> Params,
830  SourceLocation RAngleLoc,
831  Expr *RequiresClause) {
832  if (ExportLoc.isValid())
833  Diag(ExportLoc, diag::warn_template_export_unsupported);
834 
835  // FIXME: store RequiresClause
837  Context, TemplateLoc, LAngleLoc,
838  llvm::makeArrayRef((NamedDecl *const *)Params.data(), Params.size()),
839  RAngleLoc);
840 }
841 
842 static void SetNestedNameSpecifier(TagDecl *T, const CXXScopeSpec &SS) {
843  if (SS.isSet())
844  T->setQualifierInfo(SS.getWithLocInContext(T->getASTContext()));
845 }
846 
848 Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
849  SourceLocation KWLoc, CXXScopeSpec &SS,
852  TemplateParameterList *TemplateParams,
853  AccessSpecifier AS, SourceLocation ModulePrivateLoc,
854  SourceLocation FriendLoc,
855  unsigned NumOuterTemplateParamLists,
856  TemplateParameterList** OuterTemplateParamLists,
857  SkipBodyInfo *SkipBody) {
858  assert(TemplateParams && TemplateParams->size() > 0 &&
859  "No template parameters");
860  assert(TUK != TUK_Reference && "Can only declare or define class templates");
861  bool Invalid = false;
862 
863  // Check that we can declare a template here.
864  if (CheckTemplateDeclScope(S, TemplateParams))
865  return true;
866 
868  assert(Kind != TTK_Enum && "can't build template of enumerated type");
869 
870  // There is no such thing as an unnamed class template.
871  if (!Name) {
872  Diag(KWLoc, diag::err_template_unnamed_class);
873  return true;
874  }
875 
876  // Find any previous declaration with this name. For a friend with no
877  // scope explicitly specified, we only look for tag declarations (per
878  // C++11 [basic.lookup.elab]p2).
879  DeclContext *SemanticContext;
880  LookupResult Previous(*this, Name, NameLoc,
881  (SS.isEmpty() && TUK == TUK_Friend)
882  ? LookupTagName : LookupOrdinaryName,
883  ForRedeclaration);
884  if (SS.isNotEmpty() && !SS.isInvalid()) {
885  SemanticContext = computeDeclContext(SS, true);
886  if (!SemanticContext) {
887  // FIXME: Horrible, horrible hack! We can't currently represent this
888  // in the AST, and historically we have just ignored such friend
889  // class templates, so don't complain here.
890  Diag(NameLoc, TUK == TUK_Friend
891  ? diag::warn_template_qualified_friend_ignored
892  : diag::err_template_qualified_declarator_no_match)
893  << SS.getScopeRep() << SS.getRange();
894  return TUK != TUK_Friend;
895  }
896 
897  if (RequireCompleteDeclContext(SS, SemanticContext))
898  return true;
899 
900  // If we're adding a template to a dependent context, we may need to
901  // rebuilding some of the types used within the template parameter list,
902  // now that we know what the current instantiation is.
903  if (SemanticContext->isDependentContext()) {
904  ContextRAII SavedContext(*this, SemanticContext);
905  if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
906  Invalid = true;
907  } else if (TUK != TUK_Friend && TUK != TUK_Reference)
908  diagnoseQualifiedDeclaration(SS, SemanticContext, Name, NameLoc);
909 
910  LookupQualifiedName(Previous, SemanticContext);
911  } else {
912  SemanticContext = CurContext;
913 
914  // C++14 [class.mem]p14:
915  // If T is the name of a class, then each of the following shall have a
916  // name different from T:
917  // -- every member template of class T
918  if (TUK != TUK_Friend &&
919  DiagnoseClassNameShadow(SemanticContext,
920  DeclarationNameInfo(Name, NameLoc)))
921  return true;
922 
923  LookupName(Previous, S);
924  }
925 
926  if (Previous.isAmbiguous())
927  return true;
928 
929  NamedDecl *PrevDecl = nullptr;
930  if (Previous.begin() != Previous.end())
931  PrevDecl = (*Previous.begin())->getUnderlyingDecl();
932 
933  if (PrevDecl && PrevDecl->isTemplateParameter()) {
934  // Maybe we will complain about the shadowed template parameter.
935  DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
936  // Just pretend that we didn't see the previous declaration.
937  PrevDecl = nullptr;
938  }
939 
940  // If there is a previous declaration with the same name, check
941  // whether this is a valid redeclaration.
942  ClassTemplateDecl *PrevClassTemplate
943  = dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
944 
945  // We may have found the injected-class-name of a class template,
946  // class template partial specialization, or class template specialization.
947  // In these cases, grab the template that is being defined or specialized.
948  if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) &&
949  cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
950  PrevDecl = cast<CXXRecordDecl>(PrevDecl->getDeclContext());
951  PrevClassTemplate
952  = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
953  if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
954  PrevClassTemplate
955  = cast<ClassTemplateSpecializationDecl>(PrevDecl)
956  ->getSpecializedTemplate();
957  }
958  }
959 
960  if (TUK == TUK_Friend) {
961  // C++ [namespace.memdef]p3:
962  // [...] When looking for a prior declaration of a class or a function
963  // declared as a friend, and when the name of the friend class or
964  // function is neither a qualified name nor a template-id, scopes outside
965  // the innermost enclosing namespace scope are not considered.
966  if (!SS.isSet()) {
967  DeclContext *OutermostContext = CurContext;
968  while (!OutermostContext->isFileContext())
969  OutermostContext = OutermostContext->getLookupParent();
970 
971  if (PrevDecl &&
972  (OutermostContext->Equals(PrevDecl->getDeclContext()) ||
973  OutermostContext->Encloses(PrevDecl->getDeclContext()))) {
974  SemanticContext = PrevDecl->getDeclContext();
975  } else {
976  // Declarations in outer scopes don't matter. However, the outermost
977  // context we computed is the semantic context for our new
978  // declaration.
979  PrevDecl = PrevClassTemplate = nullptr;
980  SemanticContext = OutermostContext;
981 
982  // Check that the chosen semantic context doesn't already contain a
983  // declaration of this name as a non-tag type.
984  Previous.clear(LookupOrdinaryName);
985  DeclContext *LookupContext = SemanticContext;
986  while (LookupContext->isTransparentContext())
987  LookupContext = LookupContext->getLookupParent();
988  LookupQualifiedName(Previous, LookupContext);
989 
990  if (Previous.isAmbiguous())
991  return true;
992 
993  if (Previous.begin() != Previous.end())
994  PrevDecl = (*Previous.begin())->getUnderlyingDecl();
995  }
996  }
997  } else if (PrevDecl &&
998  !isDeclInScope(Previous.getRepresentativeDecl(), SemanticContext,
999  S, SS.isValid()))
1000  PrevDecl = PrevClassTemplate = nullptr;
1001 
1002  if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
1003  PrevDecl ? Previous.getRepresentativeDecl() : nullptr)) {
1004  if (SS.isEmpty() &&
1005  !(PrevClassTemplate &&
1006  PrevClassTemplate->getDeclContext()->getRedeclContext()->Equals(
1007  SemanticContext->getRedeclContext()))) {
1008  Diag(KWLoc, diag::err_using_decl_conflict_reverse);
1009  Diag(Shadow->getTargetDecl()->getLocation(),
1010  diag::note_using_decl_target);
1011  Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
1012  // Recover by ignoring the old declaration.
1013  PrevDecl = PrevClassTemplate = nullptr;
1014  }
1015  }
1016 
1017  if (PrevClassTemplate) {
1018  // Ensure that the template parameter lists are compatible. Skip this check
1019  // for a friend in a dependent context: the template parameter list itself
1020  // could be dependent.
1021  if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1022  !TemplateParameterListsAreEqual(TemplateParams,
1023  PrevClassTemplate->getTemplateParameters(),
1024  /*Complain=*/true,
1025  TPL_TemplateMatch))
1026  return true;
1027 
1028  // C++ [temp.class]p4:
1029  // In a redeclaration, partial specialization, explicit
1030  // specialization or explicit instantiation of a class template,
1031  // the class-key shall agree in kind with the original class
1032  // template declaration (7.1.5.3).
1033  RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl();
1034  if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind,
1035  TUK == TUK_Definition, KWLoc, Name)) {
1036  Diag(KWLoc, diag::err_use_with_wrong_tag)
1037  << Name
1038  << FixItHint::CreateReplacement(KWLoc, PrevRecordDecl->getKindName());
1039  Diag(PrevRecordDecl->getLocation(), diag::note_previous_use);
1040  Kind = PrevRecordDecl->getTagKind();
1041  }
1042 
1043  // Check for redefinition of this class template.
1044  if (TUK == TUK_Definition) {
1045  if (TagDecl *Def = PrevRecordDecl->getDefinition()) {
1046  // If we have a prior definition that is not visible, treat this as
1047  // simply making that previous definition visible.
1048  NamedDecl *Hidden = nullptr;
1049  if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
1050  SkipBody->ShouldSkip = true;
1051  auto *Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();
1052  assert(Tmpl && "original definition of a class template is not a "
1053  "class template?");
1054  makeMergedDefinitionVisible(Hidden, KWLoc);
1055  makeMergedDefinitionVisible(Tmpl, KWLoc);
1056  return Def;
1057  }
1058 
1059  Diag(NameLoc, diag::err_redefinition) << Name;
1060  Diag(Def->getLocation(), diag::note_previous_definition);
1061  // FIXME: Would it make sense to try to "forget" the previous
1062  // definition, as part of error recovery?
1063  return true;
1064  }
1065  }
1066  } else if (PrevDecl) {
1067  // C++ [temp]p5:
1068  // A class template shall not have the same name as any other
1069  // template, class, function, object, enumeration, enumerator,
1070  // namespace, or type in the same scope (3.3), except as specified
1071  // in (14.5.4).
1072  Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
1073  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1074  return true;
1075  }
1076 
1077  // Check the template parameter list of this declaration, possibly
1078  // merging in the template parameter list from the previous class
1079  // template declaration. Skip this check for a friend in a dependent
1080  // context, because the template parameter list might be dependent.
1081  if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1082  CheckTemplateParameterList(
1083  TemplateParams,
1084  PrevClassTemplate ? PrevClassTemplate->getTemplateParameters()
1085  : nullptr,
1086  (SS.isSet() && SemanticContext && SemanticContext->isRecord() &&
1087  SemanticContext->isDependentContext())
1088  ? TPC_ClassTemplateMember
1089  : TUK == TUK_Friend ? TPC_FriendClassTemplate
1090  : TPC_ClassTemplate))
1091  Invalid = true;
1092 
1093  if (SS.isSet()) {
1094  // If the name of the template was qualified, we must be defining the
1095  // template out-of-line.
1096  if (!SS.isInvalid() && !Invalid && !PrevClassTemplate) {
1097  Diag(NameLoc, TUK == TUK_Friend ? diag::err_friend_decl_does_not_match
1098  : diag::err_member_decl_does_not_match)
1099  << Name << SemanticContext << /*IsDefinition*/true << SS.getRange();
1100  Invalid = true;
1101  }
1102  }
1103 
1104  CXXRecordDecl *NewClass =
1105  CXXRecordDecl::Create(Context, Kind, SemanticContext, KWLoc, NameLoc, Name,
1106  PrevClassTemplate?
1107  PrevClassTemplate->getTemplatedDecl() : nullptr,
1108  /*DelayTypeCreation=*/true);
1109  SetNestedNameSpecifier(NewClass, SS);
1110  if (NumOuterTemplateParamLists > 0)
1112  Context, llvm::makeArrayRef(OuterTemplateParamLists,
1113  NumOuterTemplateParamLists));
1114 
1115  // Add alignment attributes if necessary; these attributes are checked when
1116  // the ASTContext lays out the structure.
1117  if (TUK == TUK_Definition) {
1118  AddAlignmentAttributesForRecord(NewClass);
1119  AddMsStructLayoutForRecord(NewClass);
1120  }
1121 
1122  ClassTemplateDecl *NewTemplate
1123  = ClassTemplateDecl::Create(Context, SemanticContext, NameLoc,
1124  DeclarationName(Name), TemplateParams,
1125  NewClass, PrevClassTemplate);
1126  NewClass->setDescribedClassTemplate(NewTemplate);
1127 
1128  if (ModulePrivateLoc.isValid())
1129  NewTemplate->setModulePrivate();
1130 
1131  // Build the type for the class template declaration now.
1132  QualType T = NewTemplate->getInjectedClassNameSpecialization();
1133  T = Context.getInjectedClassNameType(NewClass, T);
1134  assert(T->isDependentType() && "Class template type is not dependent?");
1135  (void)T;
1136 
1137  // If we are providing an explicit specialization of a member that is a
1138  // class template, make a note of that.
1139  if (PrevClassTemplate &&
1140  PrevClassTemplate->getInstantiatedFromMemberTemplate())
1141  PrevClassTemplate->setMemberSpecialization();
1142 
1143  // Set the access specifier.
1144  if (!Invalid && TUK != TUK_Friend && NewTemplate->getDeclContext()->isRecord())
1145  SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS);
1146 
1147  // Set the lexical context of these templates
1148  NewClass->setLexicalDeclContext(CurContext);
1149  NewTemplate->setLexicalDeclContext(CurContext);
1150 
1151  if (TUK == TUK_Definition)
1152  NewClass->startDefinition();
1153 
1154  if (Attr)
1155  ProcessDeclAttributeList(S, NewClass, Attr);
1156 
1157  if (PrevClassTemplate)
1158  mergeDeclAttributes(NewClass, PrevClassTemplate->getTemplatedDecl());
1159 
1160  AddPushedVisibilityAttribute(NewClass);
1161 
1162  if (TUK != TUK_Friend) {
1163  // Per C++ [basic.scope.temp]p2, skip the template parameter scopes.
1164  Scope *Outer = S;
1165  while ((Outer->getFlags() & Scope::TemplateParamScope) != 0)
1166  Outer = Outer->getParent();
1167  PushOnScopeChains(NewTemplate, Outer);
1168  } else {
1169  if (PrevClassTemplate && PrevClassTemplate->getAccess() != AS_none) {
1170  NewTemplate->setAccess(PrevClassTemplate->getAccess());
1171  NewClass->setAccess(PrevClassTemplate->getAccess());
1172  }
1173 
1174  NewTemplate->setObjectOfFriendDecl();
1175 
1176  // Friend templates are visible in fairly strange ways.
1177  if (!CurContext->isDependentContext()) {
1178  DeclContext *DC = SemanticContext->getRedeclContext();
1179  DC->makeDeclVisibleInContext(NewTemplate);
1180  if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
1181  PushOnScopeChains(NewTemplate, EnclosingScope,
1182  /* AddToContext = */ false);
1183  }
1184 
1185  FriendDecl *Friend = FriendDecl::Create(
1186  Context, CurContext, NewClass->getLocation(), NewTemplate, FriendLoc);
1187  Friend->setAccess(AS_public);
1188  CurContext->addDecl(Friend);
1189  }
1190 
1191  if (Invalid) {
1192  NewTemplate->setInvalidDecl();
1193  NewClass->setInvalidDecl();
1194  }
1195 
1196  ActOnDocumentableDecl(NewTemplate);
1197 
1198  return NewTemplate;
1199 }
1200 
1201 /// \brief Diagnose the presence of a default template argument on a
1202 /// template parameter, which is ill-formed in certain contexts.
1203 ///
1204 /// \returns true if the default template argument should be dropped.
1207  SourceLocation ParamLoc,
1208  SourceRange DefArgRange) {
1209  switch (TPC) {
1211  case Sema::TPC_VarTemplate:
1213  return false;
1214 
1217  // C++ [temp.param]p9:
1218  // A default template-argument shall not be specified in a
1219  // function template declaration or a function template
1220  // definition [...]
1221  // If a friend function template declaration specifies a default
1222  // template-argument, that declaration shall be a definition and shall be
1223  // the only declaration of the function template in the translation unit.
1224  // (C++98/03 doesn't have this wording; see DR226).
1225  S.Diag(ParamLoc, S.getLangOpts().CPlusPlus11 ?
1226  diag::warn_cxx98_compat_template_parameter_default_in_function_template
1227  : diag::ext_template_parameter_default_in_function_template)
1228  << DefArgRange;
1229  return false;
1230 
1232  // C++0x [temp.param]p9:
1233  // A default template-argument shall not be specified in the
1234  // template-parameter-lists of the definition of a member of a
1235  // class template that appears outside of the member's class.
1236  S.Diag(ParamLoc, diag::err_template_parameter_default_template_member)
1237  << DefArgRange;
1238  return true;
1239 
1242  // C++ [temp.param]p9:
1243  // A default template-argument shall not be specified in a
1244  // friend template declaration.
1245  S.Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
1246  << DefArgRange;
1247  return true;
1248 
1249  // FIXME: C++0x [temp.param]p9 allows default template-arguments
1250  // for friend function templates if there is only a single
1251  // declaration (and it is a definition). Strange!
1252  }
1253 
1254  llvm_unreachable("Invalid TemplateParamListContext!");
1255 }
1256 
1257 /// \brief Check for unexpanded parameter packs within the template parameters
1258 /// of a template template parameter, recursively.
1260  TemplateTemplateParmDecl *TTP) {
1261  // A template template parameter which is a parameter pack is also a pack
1262  // expansion.
1263  if (TTP->isParameterPack())
1264  return false;
1265 
1267  for (unsigned I = 0, N = Params->size(); I != N; ++I) {
1268  NamedDecl *P = Params->getParam(I);
1269  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
1270  if (!NTTP->isParameterPack() &&
1271  S.DiagnoseUnexpandedParameterPack(NTTP->getLocation(),
1272  NTTP->getTypeSourceInfo(),
1274  return true;
1275 
1276  continue;
1277  }
1278 
1279  if (TemplateTemplateParmDecl *InnerTTP
1280  = dyn_cast<TemplateTemplateParmDecl>(P))
1281  if (DiagnoseUnexpandedParameterPacks(S, InnerTTP))
1282  return true;
1283  }
1284 
1285  return false;
1286 }
1287 
1288 /// \brief Checks the validity of a template parameter list, possibly
1289 /// considering the template parameter list from a previous
1290 /// declaration.
1291 ///
1292 /// If an "old" template parameter list is provided, it must be
1293 /// equivalent (per TemplateParameterListsAreEqual) to the "new"
1294 /// template parameter list.
1295 ///
1296 /// \param NewParams Template parameter list for a new template
1297 /// declaration. This template parameter list will be updated with any
1298 /// default arguments that are carried through from the previous
1299 /// template parameter list.
1300 ///
1301 /// \param OldParams If provided, template parameter list from a
1302 /// previous declaration of the same template. Default template
1303 /// arguments will be merged from the old template parameter list to
1304 /// the new template parameter list.
1305 ///
1306 /// \param TPC Describes the context in which we are checking the given
1307 /// template parameter list.
1308 ///
1309 /// \returns true if an error occurred, false otherwise.
1311  TemplateParameterList *OldParams,
1313  bool Invalid = false;
1314 
1315  // C++ [temp.param]p10:
1316  // The set of default template-arguments available for use with a
1317  // template declaration or definition is obtained by merging the
1318  // default arguments from the definition (if in scope) and all
1319  // declarations in scope in the same way default function
1320  // arguments are (8.3.6).
1321  bool SawDefaultArgument = false;
1322  SourceLocation PreviousDefaultArgLoc;
1323 
1324  // Dummy initialization to avoid warnings.
1325  TemplateParameterList::iterator OldParam = NewParams->end();
1326  if (OldParams)
1327  OldParam = OldParams->begin();
1328 
1329  bool RemoveDefaultArguments = false;
1330  for (TemplateParameterList::iterator NewParam = NewParams->begin(),
1331  NewParamEnd = NewParams->end();
1332  NewParam != NewParamEnd; ++NewParam) {
1333  // Variables used to diagnose redundant default arguments
1334  bool RedundantDefaultArg = false;
1335  SourceLocation OldDefaultLoc;
1336  SourceLocation NewDefaultLoc;
1337 
1338  // Variable used to diagnose missing default arguments
1339  bool MissingDefaultArg = false;
1340 
1341  // Variable used to diagnose non-final parameter packs
1342  bool SawParameterPack = false;
1343 
1344  if (TemplateTypeParmDecl *NewTypeParm
1345  = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
1346  // Check the presence of a default argument here.
1347  if (NewTypeParm->hasDefaultArgument() &&
1349  NewTypeParm->getLocation(),
1350  NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
1351  .getSourceRange()))
1352  NewTypeParm->removeDefaultArgument();
1353 
1354  // Merge default arguments for template type parameters.
1355  TemplateTypeParmDecl *OldTypeParm
1356  = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : nullptr;
1357  if (NewTypeParm->isParameterPack()) {
1358  assert(!NewTypeParm->hasDefaultArgument() &&
1359  "Parameter packs can't have a default argument!");
1360  SawParameterPack = true;
1361  } else if (OldTypeParm && hasVisibleDefaultArgument(OldTypeParm) &&
1362  NewTypeParm->hasDefaultArgument()) {
1363  OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc();
1364  NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
1365  SawDefaultArgument = true;
1366  RedundantDefaultArg = true;
1367  PreviousDefaultArgLoc = NewDefaultLoc;
1368  } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) {
1369  // Merge the default argument from the old declaration to the
1370  // new declaration.
1371  NewTypeParm->setInheritedDefaultArgument(Context, OldTypeParm);
1372  PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc();
1373  } else if (NewTypeParm->hasDefaultArgument()) {
1374  SawDefaultArgument = true;
1375  PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
1376  } else if (SawDefaultArgument)
1377  MissingDefaultArg = true;
1378  } else if (NonTypeTemplateParmDecl *NewNonTypeParm
1379  = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
1380  // Check for unexpanded parameter packs.
1381  if (!NewNonTypeParm->isParameterPack() &&
1382  DiagnoseUnexpandedParameterPack(NewNonTypeParm->getLocation(),
1383  NewNonTypeParm->getTypeSourceInfo(),
1384  UPPC_NonTypeTemplateParameterType)) {
1385  Invalid = true;
1386  continue;
1387  }
1388 
1389  // Check the presence of a default argument here.
1390  if (NewNonTypeParm->hasDefaultArgument() &&
1392  NewNonTypeParm->getLocation(),
1393  NewNonTypeParm->getDefaultArgument()->getSourceRange())) {
1394  NewNonTypeParm->removeDefaultArgument();
1395  }
1396 
1397  // Merge default arguments for non-type template parameters
1398  NonTypeTemplateParmDecl *OldNonTypeParm
1399  = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : nullptr;
1400  if (NewNonTypeParm->isParameterPack()) {
1401  assert(!NewNonTypeParm->hasDefaultArgument() &&
1402  "Parameter packs can't have a default argument!");
1403  if (!NewNonTypeParm->isPackExpansion())
1404  SawParameterPack = true;
1405  } else if (OldNonTypeParm && hasVisibleDefaultArgument(OldNonTypeParm) &&
1406  NewNonTypeParm->hasDefaultArgument()) {
1407  OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc();
1408  NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
1409  SawDefaultArgument = true;
1410  RedundantDefaultArg = true;
1411  PreviousDefaultArgLoc = NewDefaultLoc;
1412  } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) {
1413  // Merge the default argument from the old declaration to the
1414  // new declaration.
1415  NewNonTypeParm->setInheritedDefaultArgument(Context, OldNonTypeParm);
1416  PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc();
1417  } else if (NewNonTypeParm->hasDefaultArgument()) {
1418  SawDefaultArgument = true;
1419  PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
1420  } else if (SawDefaultArgument)
1421  MissingDefaultArg = true;
1422  } else {
1423  TemplateTemplateParmDecl *NewTemplateParm
1424  = cast<TemplateTemplateParmDecl>(*NewParam);
1425 
1426  // Check for unexpanded parameter packs, recursively.
1427  if (::DiagnoseUnexpandedParameterPacks(*this, NewTemplateParm)) {
1428  Invalid = true;
1429  continue;
1430  }
1431 
1432  // Check the presence of a default argument here.
1433  if (NewTemplateParm->hasDefaultArgument() &&
1435  NewTemplateParm->getLocation(),
1436  NewTemplateParm->getDefaultArgument().getSourceRange()))
1437  NewTemplateParm->removeDefaultArgument();
1438 
1439  // Merge default arguments for template template parameters
1440  TemplateTemplateParmDecl *OldTemplateParm
1441  = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : nullptr;
1442  if (NewTemplateParm->isParameterPack()) {
1443  assert(!NewTemplateParm->hasDefaultArgument() &&
1444  "Parameter packs can't have a default argument!");
1445  if (!NewTemplateParm->isPackExpansion())
1446  SawParameterPack = true;
1447  } else if (OldTemplateParm &&
1448  hasVisibleDefaultArgument(OldTemplateParm) &&
1449  NewTemplateParm->hasDefaultArgument()) {
1450  OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation();
1451  NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation();
1452  SawDefaultArgument = true;
1453  RedundantDefaultArg = true;
1454  PreviousDefaultArgLoc = NewDefaultLoc;
1455  } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) {
1456  // Merge the default argument from the old declaration to the
1457  // new declaration.
1458  NewTemplateParm->setInheritedDefaultArgument(Context, OldTemplateParm);
1459  PreviousDefaultArgLoc
1460  = OldTemplateParm->getDefaultArgument().getLocation();
1461  } else if (NewTemplateParm->hasDefaultArgument()) {
1462  SawDefaultArgument = true;
1463  PreviousDefaultArgLoc
1464  = NewTemplateParm->getDefaultArgument().getLocation();
1465  } else if (SawDefaultArgument)
1466  MissingDefaultArg = true;
1467  }
1468 
1469  // C++11 [temp.param]p11:
1470  // If a template parameter of a primary class template or alias template
1471  // is a template parameter pack, it shall be the last template parameter.
1472  if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
1473  (TPC == TPC_ClassTemplate || TPC == TPC_VarTemplate ||
1474  TPC == TPC_TypeAliasTemplate)) {
1475  Diag((*NewParam)->getLocation(),
1476  diag::err_template_param_pack_must_be_last_template_parameter);
1477  Invalid = true;
1478  }
1479 
1480  if (RedundantDefaultArg) {
1481  // C++ [temp.param]p12:
1482  // A template-parameter shall not be given default arguments
1483  // by two different declarations in the same scope.
1484  Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
1485  Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
1486  Invalid = true;
1487  } else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) {
1488  // C++ [temp.param]p11:
1489  // If a template-parameter of a class template has a default
1490  // template-argument, each subsequent template-parameter shall either
1491  // have a default template-argument supplied or be a template parameter
1492  // pack.
1493  Diag((*NewParam)->getLocation(),
1494  diag::err_template_param_default_arg_missing);
1495  Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
1496  Invalid = true;
1497  RemoveDefaultArguments = true;
1498  }
1499 
1500  // If we have an old template parameter list that we're merging
1501  // in, move on to the next parameter.
1502  if (OldParams)
1503  ++OldParam;
1504  }
1505 
1506  // We were missing some default arguments at the end of the list, so remove
1507  // all of the default arguments.
1508  if (RemoveDefaultArguments) {
1509  for (TemplateParameterList::iterator NewParam = NewParams->begin(),
1510  NewParamEnd = NewParams->end();
1511  NewParam != NewParamEnd; ++NewParam) {
1512  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*NewParam))
1513  TTP->removeDefaultArgument();
1514  else if (NonTypeTemplateParmDecl *NTTP
1515  = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
1516  NTTP->removeDefaultArgument();
1517  else
1518  cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
1519  }
1520  }
1521 
1522  return Invalid;
1523 }
1524 
1525 namespace {
1526 
1527 /// A class which looks for a use of a certain level of template
1528 /// parameter.
1529 struct DependencyChecker : RecursiveASTVisitor<DependencyChecker> {
1531 
1532  unsigned Depth;
1533  bool Match;
1534  SourceLocation MatchLoc;
1535 
1536  DependencyChecker(unsigned Depth) : Depth(Depth), Match(false) {}
1537 
1538  DependencyChecker(TemplateParameterList *Params) : Match(false) {
1539  NamedDecl *ND = Params->getParam(0);
1540  if (TemplateTypeParmDecl *PD = dyn_cast<TemplateTypeParmDecl>(ND)) {
1541  Depth = PD->getDepth();
1542  } else if (NonTypeTemplateParmDecl *PD =
1543  dyn_cast<NonTypeTemplateParmDecl>(ND)) {
1544  Depth = PD->getDepth();
1545  } else {
1546  Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
1547  }
1548  }
1549 
1550  bool Matches(unsigned ParmDepth, SourceLocation Loc = SourceLocation()) {
1551  if (ParmDepth >= Depth) {
1552  Match = true;
1553  MatchLoc = Loc;
1554  return true;
1555  }
1556  return false;
1557  }
1558 
1559  bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
1560  return !Matches(TL.getTypePtr()->getDepth(), TL.getNameLoc());
1561  }
1562 
1563  bool VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
1564  return !Matches(T->getDepth());
1565  }
1566 
1567  bool TraverseTemplateName(TemplateName N) {
1568  if (TemplateTemplateParmDecl *PD =
1569  dyn_cast_or_null<TemplateTemplateParmDecl>(N.getAsTemplateDecl()))
1570  if (Matches(PD->getDepth()))
1571  return false;
1572  return super::TraverseTemplateName(N);
1573  }
1574 
1575  bool VisitDeclRefExpr(DeclRefExpr *E) {
1576  if (NonTypeTemplateParmDecl *PD =
1577  dyn_cast<NonTypeTemplateParmDecl>(E->getDecl()))
1578  if (Matches(PD->getDepth(), E->getExprLoc()))
1579  return false;
1580  return super::VisitDeclRefExpr(E);
1581  }
1582 
1583  bool VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
1584  return TraverseType(T->getReplacementType());
1585  }
1586 
1587  bool
1588  VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
1589  return TraverseTemplateArgument(T->getArgumentPack());
1590  }
1591 
1592  bool TraverseInjectedClassNameType(const InjectedClassNameType *T) {
1593  return TraverseType(T->getInjectedSpecializationType());
1594  }
1595 };
1596 } // end anonymous namespace
1597 
1598 /// Determines whether a given type depends on the given parameter
1599 /// list.
1600 static bool
1602  DependencyChecker Checker(Params);
1603  Checker.TraverseType(T);
1604  return Checker.Match;
1605 }
1606 
1607 // Find the source range corresponding to the named type in the given
1608 // nested-name-specifier, if any.
1610  QualType T,
1611  const CXXScopeSpec &SS) {
1613  while (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier()) {
1614  if (const Type *CurType = NNS->getAsType()) {
1615  if (Context.hasSameUnqualifiedType(T, QualType(CurType, 0)))
1616  return NNSLoc.getTypeLoc().getSourceRange();
1617  } else
1618  break;
1619 
1620  NNSLoc = NNSLoc.getPrefix();
1621  }
1622 
1623  return SourceRange();
1624 }
1625 
1626 /// \brief Match the given template parameter lists to the given scope
1627 /// specifier, returning the template parameter list that applies to the
1628 /// name.
1629 ///
1630 /// \param DeclStartLoc the start of the declaration that has a scope
1631 /// specifier or a template parameter list.
1632 ///
1633 /// \param DeclLoc The location of the declaration itself.
1634 ///
1635 /// \param SS the scope specifier that will be matched to the given template
1636 /// parameter lists. This scope specifier precedes a qualified name that is
1637 /// being declared.
1638 ///
1639 /// \param TemplateId The template-id following the scope specifier, if there
1640 /// is one. Used to check for a missing 'template<>'.
1641 ///
1642 /// \param ParamLists the template parameter lists, from the outermost to the
1643 /// innermost template parameter lists.
1644 ///
1645 /// \param IsFriend Whether to apply the slightly different rules for
1646 /// matching template parameters to scope specifiers in friend
1647 /// declarations.
1648 ///
1649 /// \param IsExplicitSpecialization will be set true if the entity being
1650 /// declared is an explicit specialization, false otherwise.
1651 ///
1652 /// \returns the template parameter list, if any, that corresponds to the
1653 /// name that is preceded by the scope specifier @p SS. This template
1654 /// parameter list may have template parameters (if we're declaring a
1655 /// template) or may have no template parameters (if we're declaring a
1656 /// template specialization), or may be NULL (if what we're declaring isn't
1657 /// itself a template).
1659  SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS,
1660  TemplateIdAnnotation *TemplateId,
1661  ArrayRef<TemplateParameterList *> ParamLists, bool IsFriend,
1662  bool &IsExplicitSpecialization, bool &Invalid) {
1663  IsExplicitSpecialization = false;
1664  Invalid = false;
1665 
1666  // The sequence of nested types to which we will match up the template
1667  // parameter lists. We first build this list by starting with the type named
1668  // by the nested-name-specifier and walking out until we run out of types.
1669  SmallVector<QualType, 4> NestedTypes;
1670  QualType T;
1671  if (SS.getScopeRep()) {
1672  if (CXXRecordDecl *Record
1673  = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, true)))
1674  T = Context.getTypeDeclType(Record);
1675  else
1676  T = QualType(SS.getScopeRep()->getAsType(), 0);
1677  }
1678 
1679  // If we found an explicit specialization that prevents us from needing
1680  // 'template<>' headers, this will be set to the location of that
1681  // explicit specialization.
1682  SourceLocation ExplicitSpecLoc;
1683 
1684  while (!T.isNull()) {
1685  NestedTypes.push_back(T);
1686 
1687  // Retrieve the parent of a record type.
1688  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
1689  // If this type is an explicit specialization, we're done.
1691  = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
1692  if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
1693  Spec->getSpecializationKind() == TSK_ExplicitSpecialization) {
1694  ExplicitSpecLoc = Spec->getLocation();
1695  break;
1696  }
1697  } else if (Record->getTemplateSpecializationKind()
1699  ExplicitSpecLoc = Record->getLocation();
1700  break;
1701  }
1702 
1703  if (TypeDecl *Parent = dyn_cast<TypeDecl>(Record->getParent()))
1704  T = Context.getTypeDeclType(Parent);
1705  else
1706  T = QualType();
1707  continue;
1708  }
1709 
1710  if (const TemplateSpecializationType *TST
1712  if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
1713  if (TypeDecl *Parent = dyn_cast<TypeDecl>(Template->getDeclContext()))
1714  T = Context.getTypeDeclType(Parent);
1715  else
1716  T = QualType();
1717  continue;
1718  }
1719  }
1720 
1721  // Look one step prior in a dependent template specialization type.
1722  if (const DependentTemplateSpecializationType *DependentTST
1724  if (NestedNameSpecifier *NNS = DependentTST->getQualifier())
1725  T = QualType(NNS->getAsType(), 0);
1726  else
1727  T = QualType();
1728  continue;
1729  }
1730 
1731  // Look one step prior in a dependent name type.
1732  if (const DependentNameType *DependentName = T->getAs<DependentNameType>()){
1733  if (NestedNameSpecifier *NNS = DependentName->getQualifier())
1734  T = QualType(NNS->getAsType(), 0);
1735  else
1736  T = QualType();
1737  continue;
1738  }
1739 
1740  // Retrieve the parent of an enumeration type.
1741  if (const EnumType *EnumT = T->getAs<EnumType>()) {
1742  // FIXME: Forward-declared enums require a TSK_ExplicitSpecialization
1743  // check here.
1744  EnumDecl *Enum = EnumT->getDecl();
1745 
1746  // Get to the parent type.
1747  if (TypeDecl *Parent = dyn_cast<TypeDecl>(Enum->getParent()))
1748  T = Context.getTypeDeclType(Parent);
1749  else
1750  T = QualType();
1751  continue;
1752  }
1753 
1754  T = QualType();
1755  }
1756  // Reverse the nested types list, since we want to traverse from the outermost
1757  // to the innermost while checking template-parameter-lists.
1758  std::reverse(NestedTypes.begin(), NestedTypes.end());
1759 
1760  // C++0x [temp.expl.spec]p17:
1761  // A member or a member template may be nested within many
1762  // enclosing class templates. In an explicit specialization for
1763  // such a member, the member declaration shall be preceded by a
1764  // template<> for each enclosing class template that is
1765  // explicitly specialized.
1766  bool SawNonEmptyTemplateParameterList = false;
1767 
1768  auto CheckExplicitSpecialization = [&](SourceRange Range, bool Recovery) {
1769  if (SawNonEmptyTemplateParameterList) {
1770  Diag(DeclLoc, diag::err_specialize_member_of_template)
1771  << !Recovery << Range;
1772  Invalid = true;
1773  IsExplicitSpecialization = false;
1774  return true;
1775  }
1776 
1777  return false;
1778  };
1779 
1780  auto DiagnoseMissingExplicitSpecialization = [&] (SourceRange Range) {
1781  // Check that we can have an explicit specialization here.
1782  if (CheckExplicitSpecialization(Range, true))
1783  return true;
1784 
1785  // We don't have a template header, but we should.
1786  SourceLocation ExpectedTemplateLoc;
1787  if (!ParamLists.empty())
1788  ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
1789  else
1790  ExpectedTemplateLoc = DeclStartLoc;
1791 
1792  Diag(DeclLoc, diag::err_template_spec_needs_header)
1793  << Range
1794  << FixItHint::CreateInsertion(ExpectedTemplateLoc, "template<> ");
1795  return false;
1796  };
1797 
1798  unsigned ParamIdx = 0;
1799  for (unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
1800  ++TypeIdx) {
1801  T = NestedTypes[TypeIdx];
1802 
1803  // Whether we expect a 'template<>' header.
1804  bool NeedEmptyTemplateHeader = false;
1805 
1806  // Whether we expect a template header with parameters.
1807  bool NeedNonemptyTemplateHeader = false;
1808 
1809  // For a dependent type, the set of template parameters that we
1810  // expect to see.
1811  TemplateParameterList *ExpectedTemplateParams = nullptr;
1812 
1813  // C++0x [temp.expl.spec]p15:
1814  // A member or a member template may be nested within many enclosing
1815  // class templates. In an explicit specialization for such a member, the
1816  // member declaration shall be preceded by a template<> for each
1817  // enclosing class template that is explicitly specialized.
1818  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
1820  = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) {
1821  ExpectedTemplateParams = Partial->getTemplateParameters();
1822  NeedNonemptyTemplateHeader = true;
1823  } else if (Record->isDependentType()) {
1824  if (Record->getDescribedClassTemplate()) {
1825  ExpectedTemplateParams = Record->getDescribedClassTemplate()
1826  ->getTemplateParameters();
1827  NeedNonemptyTemplateHeader = true;
1828  }
1829  } else if (ClassTemplateSpecializationDecl *Spec
1830  = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
1831  // C++0x [temp.expl.spec]p4:
1832  // Members of an explicitly specialized class template are defined
1833  // in the same manner as members of normal classes, and not using
1834  // the template<> syntax.
1835  if (Spec->getSpecializationKind() != TSK_ExplicitSpecialization)
1836  NeedEmptyTemplateHeader = true;
1837  else
1838  continue;
1839  } else if (Record->getTemplateSpecializationKind()) {
1840  if (Record->getTemplateSpecializationKind()
1842  TypeIdx == NumTypes - 1)
1843  IsExplicitSpecialization = true;
1844 
1845  continue;
1846  }
1847  } else if (const TemplateSpecializationType *TST
1849  if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
1850  ExpectedTemplateParams = Template->getTemplateParameters();
1851  NeedNonemptyTemplateHeader = true;
1852  }
1853  } else if (T->getAs<DependentTemplateSpecializationType>()) {
1854  // FIXME: We actually could/should check the template arguments here
1855  // against the corresponding template parameter list.
1856  NeedNonemptyTemplateHeader = false;
1857  }
1858 
1859  // C++ [temp.expl.spec]p16:
1860  // In an explicit specialization declaration for a member of a class
1861  // template or a member template that ap- pears in namespace scope, the
1862  // member template and some of its enclosing class templates may remain
1863  // unspecialized, except that the declaration shall not explicitly
1864  // specialize a class member template if its en- closing class templates
1865  // are not explicitly specialized as well.
1866  if (ParamIdx < ParamLists.size()) {
1867  if (ParamLists[ParamIdx]->size() == 0) {
1868  if (CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
1869  false))
1870  return nullptr;
1871  } else
1872  SawNonEmptyTemplateParameterList = true;
1873  }
1874 
1875  if (NeedEmptyTemplateHeader) {
1876  // If we're on the last of the types, and we need a 'template<>' header
1877  // here, then it's an explicit specialization.
1878  if (TypeIdx == NumTypes - 1)
1879  IsExplicitSpecialization = true;
1880 
1881  if (ParamIdx < ParamLists.size()) {
1882  if (ParamLists[ParamIdx]->size() > 0) {
1883  // The header has template parameters when it shouldn't. Complain.
1884  Diag(ParamLists[ParamIdx]->getTemplateLoc(),
1885  diag::err_template_param_list_matches_nontemplate)
1886  << T
1887  << SourceRange(ParamLists[ParamIdx]->getLAngleLoc(),
1888  ParamLists[ParamIdx]->getRAngleLoc())
1890  Invalid = true;
1891  return nullptr;
1892  }
1893 
1894  // Consume this template header.
1895  ++ParamIdx;
1896  continue;
1897  }
1898 
1899  if (!IsFriend)
1900  if (DiagnoseMissingExplicitSpecialization(
1902  return nullptr;
1903 
1904  continue;
1905  }
1906 
1907  if (NeedNonemptyTemplateHeader) {
1908  // In friend declarations we can have template-ids which don't
1909  // depend on the corresponding template parameter lists. But
1910  // assume that empty parameter lists are supposed to match this
1911  // template-id.
1912  if (IsFriend && T->isDependentType()) {
1913  if (ParamIdx < ParamLists.size() &&
1914  DependsOnTemplateParameters(T, ParamLists[ParamIdx]))
1915  ExpectedTemplateParams = nullptr;
1916  else
1917  continue;
1918  }
1919 
1920  if (ParamIdx < ParamLists.size()) {
1921  // Check the template parameter list, if we can.
1922  if (ExpectedTemplateParams &&
1923  !TemplateParameterListsAreEqual(ParamLists[ParamIdx],
1924  ExpectedTemplateParams,
1925  true, TPL_TemplateMatch))
1926  Invalid = true;
1927 
1928  if (!Invalid &&
1929  CheckTemplateParameterList(ParamLists[ParamIdx], nullptr,
1930  TPC_ClassTemplateMember))
1931  Invalid = true;
1932 
1933  ++ParamIdx;
1934  continue;
1935  }
1936 
1937  Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
1938  << T
1940  Invalid = true;
1941  continue;
1942  }
1943  }
1944 
1945  // If there were at least as many template-ids as there were template
1946  // parameter lists, then there are no template parameter lists remaining for
1947  // the declaration itself.
1948  if (ParamIdx >= ParamLists.size()) {
1949  if (TemplateId && !IsFriend) {
1950  // We don't have a template header for the declaration itself, but we
1951  // should.
1952  IsExplicitSpecialization = true;
1953  DiagnoseMissingExplicitSpecialization(SourceRange(TemplateId->LAngleLoc,
1954  TemplateId->RAngleLoc));
1955 
1956  // Fabricate an empty template parameter list for the invented header.
1958  SourceLocation(), None,
1959  SourceLocation());
1960  }
1961 
1962  return nullptr;
1963  }
1964 
1965  // If there were too many template parameter lists, complain about that now.
1966  if (ParamIdx < ParamLists.size() - 1) {
1967  bool HasAnyExplicitSpecHeader = false;
1968  bool AllExplicitSpecHeaders = true;
1969  for (unsigned I = ParamIdx, E = ParamLists.size() - 1; I != E; ++I) {
1970  if (ParamLists[I]->size() == 0)
1971  HasAnyExplicitSpecHeader = true;
1972  else
1973  AllExplicitSpecHeaders = false;
1974  }
1975 
1976  Diag(ParamLists[ParamIdx]->getTemplateLoc(),
1977  AllExplicitSpecHeaders ? diag::warn_template_spec_extra_headers
1978  : diag::err_template_spec_extra_headers)
1979  << SourceRange(ParamLists[ParamIdx]->getTemplateLoc(),
1980  ParamLists[ParamLists.size() - 2]->getRAngleLoc());
1981 
1982  // If there was a specialization somewhere, such that 'template<>' is
1983  // not required, and there were any 'template<>' headers, note where the
1984  // specialization occurred.
1985  if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader)
1986  Diag(ExplicitSpecLoc,
1987  diag::note_explicit_template_spec_does_not_need_header)
1988  << NestedTypes.back();
1989 
1990  // We have a template parameter list with no corresponding scope, which
1991  // means that the resulting template declaration can't be instantiated
1992  // properly (we'll end up with dependent nodes when we shouldn't).
1993  if (!AllExplicitSpecHeaders)
1994  Invalid = true;
1995  }
1996 
1997  // C++ [temp.expl.spec]p16:
1998  // In an explicit specialization declaration for a member of a class
1999  // template or a member template that ap- pears in namespace scope, the
2000  // member template and some of its enclosing class templates may remain
2001  // unspecialized, except that the declaration shall not explicitly
2002  // specialize a class member template if its en- closing class templates
2003  // are not explicitly specialized as well.
2004  if (ParamLists.back()->size() == 0 &&
2005  CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
2006  false))
2007  return nullptr;
2008 
2009  // Return the last template parameter list, which corresponds to the
2010  // entity being declared.
2011  return ParamLists.back();
2012 }
2013 
2015  if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
2016  Diag(Template->getLocation(), diag::note_template_declared_here)
2017  << (isa<FunctionTemplateDecl>(Template)
2018  ? 0
2019  : isa<ClassTemplateDecl>(Template)
2020  ? 1
2021  : isa<VarTemplateDecl>(Template)
2022  ? 2
2023  : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
2024  << Template->getDeclName();
2025  return;
2026  }
2027 
2029  for (OverloadedTemplateStorage::iterator I = OST->begin(),
2030  IEnd = OST->end();
2031  I != IEnd; ++I)
2032  Diag((*I)->getLocation(), diag::note_template_declared_here)
2033  << 0 << (*I)->getDeclName();
2034 
2035  return;
2036  }
2037 }
2038 
2039 static QualType
2041  const SmallVectorImpl<TemplateArgument> &Converted,
2042  SourceLocation TemplateLoc,
2043  TemplateArgumentListInfo &TemplateArgs) {
2044  ASTContext &Context = SemaRef.getASTContext();
2045  switch (BTD->getBuiltinTemplateKind()) {
2046  case BTK__make_integer_seq: {
2047  // Specializations of __make_integer_seq<S, T, N> are treated like
2048  // S<T, 0, ..., N-1>.
2049 
2050  // C++14 [inteseq.intseq]p1:
2051  // T shall be an integer type.
2052  if (!Converted[1].getAsType()->isIntegralType(Context)) {
2053  SemaRef.Diag(TemplateArgs[1].getLocation(),
2054  diag::err_integer_sequence_integral_element_type);
2055  return QualType();
2056  }
2057 
2058  // C++14 [inteseq.make]p1:
2059  // If N is negative the program is ill-formed.
2060  TemplateArgument NumArgsArg = Converted[2];
2061  llvm::APSInt NumArgs = NumArgsArg.getAsIntegral();
2062  if (NumArgs < 0) {
2063  SemaRef.Diag(TemplateArgs[2].getLocation(),
2064  diag::err_integer_sequence_negative_length);
2065  return QualType();
2066  }
2067 
2068  QualType ArgTy = NumArgsArg.getIntegralType();
2069  TemplateArgumentListInfo SyntheticTemplateArgs;
2070  // The type argument gets reused as the first template argument in the
2071  // synthetic template argument list.
2072  SyntheticTemplateArgs.addArgument(TemplateArgs[1]);
2073  // Expand N into 0 ... N-1.
2074  for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
2075  I < NumArgs; ++I) {
2076  TemplateArgument TA(Context, I, ArgTy);
2078  TA, TemplateArgs[2].getLocation())
2079  .getAs<Expr>();
2080  SyntheticTemplateArgs.addArgument(
2082  }
2083  // The first template argument will be reused as the template decl that
2084  // our synthetic template arguments will be applied to.
2085  return SemaRef.CheckTemplateIdType(Converted[0].getAsTemplate(),
2086  TemplateLoc, SyntheticTemplateArgs);
2087  }
2088 
2090  // Specializations of
2091  // __type_pack_element<Index, T_1, ..., T_N>
2092  // are treated like T_Index.
2093  assert(Converted.size() == 2 &&
2094  "__type_pack_element should be given an index and a parameter pack");
2095 
2096  // If the Index is out of bounds, the program is ill-formed.
2097  TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
2098  llvm::APSInt Index = IndexArg.getAsIntegral();
2099  assert(Index >= 0 && "the index used with __type_pack_element should be of "
2100  "type std::size_t, and hence be non-negative");
2101  if (Index >= Ts.pack_size()) {
2102  SemaRef.Diag(TemplateArgs[0].getLocation(),
2103  diag::err_type_pack_element_out_of_bounds);
2104  return QualType();
2105  }
2106 
2107  // We simply return the type at index `Index`.
2108  auto Nth = std::next(Ts.pack_begin(), Index.getExtValue());
2109  return Nth->getAsType();
2110  }
2111  llvm_unreachable("unexpected BuiltinTemplateDecl!");
2112 }
2113 
2115  SourceLocation TemplateLoc,
2116  TemplateArgumentListInfo &TemplateArgs) {
2119  if (DTN && DTN->isIdentifier())
2120  // When building a template-id where the template-name is dependent,
2121  // assume the template is a type template. Either our assumption is
2122  // correct, or the code is ill-formed and will be diagnosed when the
2123  // dependent name is substituted.
2125  DTN->getQualifier(),
2126  DTN->getIdentifier(),
2127  TemplateArgs);
2128 
2129  TemplateDecl *Template = Name.getAsTemplateDecl();
2130  if (!Template || isa<FunctionTemplateDecl>(Template) ||
2131  isa<VarTemplateDecl>(Template)) {
2132  // We might have a substituted template template parameter pack. If so,
2133  // build a template specialization type for it.
2135  return Context.getTemplateSpecializationType(Name, TemplateArgs);
2136 
2137  Diag(TemplateLoc, diag::err_template_id_not_a_type)
2138  << Name;
2139  NoteAllFoundTemplates(Name);
2140  return QualType();
2141  }
2142 
2143  // Check that the template argument list is well-formed for this
2144  // template.
2146  if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
2147  false, Converted))
2148  return QualType();
2149 
2150  QualType CanonType;
2151 
2152  bool InstantiationDependent = false;
2153  if (TypeAliasTemplateDecl *AliasTemplate =
2154  dyn_cast<TypeAliasTemplateDecl>(Template)) {
2155  // Find the canonical type for this type alias template specialization.
2156  TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
2157  if (Pattern->isInvalidDecl())
2158  return QualType();
2159 
2161  Converted);
2162 
2163  // Only substitute for the innermost template argument list.
2164  MultiLevelTemplateArgumentList TemplateArgLists;
2165  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
2166  unsigned Depth = AliasTemplate->getTemplateParameters()->getDepth();
2167  for (unsigned I = 0; I < Depth; ++I)
2168  TemplateArgLists.addOuterTemplateArguments(None);
2169 
2171  InstantiatingTemplate Inst(*this, TemplateLoc, Template);
2172  if (Inst.isInvalid())
2173  return QualType();
2174 
2175  CanonType = SubstType(Pattern->getUnderlyingType(),
2176  TemplateArgLists, AliasTemplate->getLocation(),
2177  AliasTemplate->getDeclName());
2178  if (CanonType.isNull())
2179  return QualType();
2180  } else if (Name.isDependent() ||
2182  TemplateArgs, InstantiationDependent)) {
2183  // This class template specialization is a dependent
2184  // type. Therefore, its canonical type is another class template
2185  // specialization type that contains all of the converted
2186  // arguments in canonical form. This ensures that, e.g., A<T> and
2187  // A<T, T> have identical types when A is declared as:
2188  //
2189  // template<typename T, typename U = T> struct A;
2190  TemplateName CanonName = Context.getCanonicalTemplateName(Name);
2191  CanonType = Context.getTemplateSpecializationType(CanonName,
2192  Converted);
2193 
2194  // FIXME: CanonType is not actually the canonical type, and unfortunately
2195  // it is a TemplateSpecializationType that we will never use again.
2196  // In the future, we need to teach getTemplateSpecializationType to only
2197  // build the canonical type and return that to us.
2198  CanonType = Context.getCanonicalType(CanonType);
2199 
2200  // This might work out to be a current instantiation, in which
2201  // case the canonical type needs to be the InjectedClassNameType.
2202  //
2203  // TODO: in theory this could be a simple hashtable lookup; most
2204  // changes to CurContext don't change the set of current
2205  // instantiations.
2206  if (isa<ClassTemplateDecl>(Template)) {
2207  for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getLookupParent()) {
2208  // If we get out to a namespace, we're done.
2209  if (Ctx->isFileContext()) break;
2210 
2211  // If this isn't a record, keep looking.
2212  CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx);
2213  if (!Record) continue;
2214 
2215  // Look for one of the two cases with InjectedClassNameTypes
2216  // and check whether it's the same template.
2217  if (!isa<ClassTemplatePartialSpecializationDecl>(Record) &&
2218  !Record->getDescribedClassTemplate())
2219  continue;
2220 
2221  // Fetch the injected class name type and check whether its
2222  // injected type is equal to the type we just built.
2223  QualType ICNT = Context.getTypeDeclType(Record);
2224  QualType Injected = cast<InjectedClassNameType>(ICNT)
2225  ->getInjectedSpecializationType();
2226 
2227  if (CanonType != Injected->getCanonicalTypeInternal())
2228  continue;
2229 
2230  // If so, the canonical type of this TST is the injected
2231  // class name type of the record we just found.
2232  assert(ICNT.isCanonical());
2233  CanonType = ICNT;
2234  break;
2235  }
2236  }
2237  } else if (ClassTemplateDecl *ClassTemplate
2238  = dyn_cast<ClassTemplateDecl>(Template)) {
2239  // Find the class template specialization declaration that
2240  // corresponds to these arguments.
2241  void *InsertPos = nullptr;
2243  = ClassTemplate->findSpecialization(Converted, InsertPos);
2244  if (!Decl) {
2245  // This is the first time we have referenced this class template
2246  // specialization. Create the canonical declaration and add it to
2247  // the set of specializations.
2249  ClassTemplate->getTemplatedDecl()->getTagKind(),
2250  ClassTemplate->getDeclContext(),
2251  ClassTemplate->getTemplatedDecl()->getLocStart(),
2252  ClassTemplate->getLocation(),
2253  ClassTemplate,
2254  Converted, nullptr);
2255  ClassTemplate->AddSpecialization(Decl, InsertPos);
2256  if (ClassTemplate->isOutOfLine())
2257  Decl->setLexicalDeclContext(ClassTemplate->getLexicalDeclContext());
2258  }
2259 
2260  // Diagnose uses of this specialization.
2261  (void)DiagnoseUseOfDecl(Decl, TemplateLoc);
2262 
2263  CanonType = Context.getTypeDeclType(Decl);
2264  assert(isa<RecordType>(CanonType) &&
2265  "type of non-dependent specialization is not a RecordType");
2266  } else if (auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
2267  CanonType = checkBuiltinTemplateIdType(*this, BTD, Converted, TemplateLoc,
2268  TemplateArgs);
2269  }
2270 
2271  // Build the fully-sugared type for this class template
2272  // specialization, which refers back to the class template
2273  // specialization we created or found.
2274  return Context.getTemplateSpecializationType(Name, TemplateArgs, CanonType);
2275 }
2276 
2277 TypeResult
2279  TemplateTy TemplateD, SourceLocation TemplateLoc,
2280  SourceLocation LAngleLoc,
2281  ASTTemplateArgsPtr TemplateArgsIn,
2282  SourceLocation RAngleLoc,
2283  bool IsCtorOrDtorName) {
2284  if (SS.isInvalid())
2285  return true;
2286 
2287  TemplateName Template = TemplateD.get();
2288 
2289  // Translate the parser's template argument list in our AST format.
2290  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
2291  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
2292 
2293  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
2294  QualType T
2296  DTN->getQualifier(),
2297  DTN->getIdentifier(),
2298  TemplateArgs);
2299  // Build type-source information.
2300  TypeLocBuilder TLB;
2305  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
2306  SpecTL.setTemplateNameLoc(TemplateLoc);
2307  SpecTL.setLAngleLoc(LAngleLoc);
2308  SpecTL.setRAngleLoc(RAngleLoc);
2309  for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
2310  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
2311  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
2312  }
2313 
2314  QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
2315 
2316  if (Result.isNull())
2317  return true;
2318 
2319  // Build type-source information.
2320  TypeLocBuilder TLB;
2322  = TLB.push<TemplateSpecializationTypeLoc>(Result);
2323  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
2324  SpecTL.setTemplateNameLoc(TemplateLoc);
2325  SpecTL.setLAngleLoc(LAngleLoc);
2326  SpecTL.setRAngleLoc(RAngleLoc);
2327  for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
2328  SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
2329 
2330  // NOTE: avoid constructing an ElaboratedTypeLoc if this is a
2331  // constructor or destructor name (in such a case, the scope specifier
2332  // will be attached to the enclosing Decl or Expr node).
2333  if (SS.isNotEmpty() && !IsCtorOrDtorName) {
2334  // Create an elaborated-type-specifier containing the nested-name-specifier.
2335  Result = Context.getElaboratedType(ETK_None, SS.getScopeRep(), Result);
2336  ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
2339  }
2340 
2341  return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
2342 }
2343 
2345  TypeSpecifierType TagSpec,
2346  SourceLocation TagLoc,
2347  CXXScopeSpec &SS,
2348  SourceLocation TemplateKWLoc,
2349  TemplateTy TemplateD,
2350  SourceLocation TemplateLoc,
2351  SourceLocation LAngleLoc,
2352  ASTTemplateArgsPtr TemplateArgsIn,
2353  SourceLocation RAngleLoc) {
2354  TemplateName Template = TemplateD.get();
2355 
2356  // Translate the parser's template argument list in our AST format.
2357  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
2358  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
2359 
2360  // Determine the tag kind
2362  ElaboratedTypeKeyword Keyword
2364 
2365  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
2367  DTN->getQualifier(),
2368  DTN->getIdentifier(),
2369  TemplateArgs);
2370 
2371  // Build type-source information.
2372  TypeLocBuilder TLB;
2375  SpecTL.setElaboratedKeywordLoc(TagLoc);
2377  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
2378  SpecTL.setTemplateNameLoc(TemplateLoc);
2379  SpecTL.setLAngleLoc(LAngleLoc);
2380  SpecTL.setRAngleLoc(RAngleLoc);
2381  for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
2382  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
2383  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
2384  }
2385 
2386  if (TypeAliasTemplateDecl *TAT =
2387  dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) {
2388  // C++0x [dcl.type.elab]p2:
2389  // If the identifier resolves to a typedef-name or the simple-template-id
2390  // resolves to an alias template specialization, the
2391  // elaborated-type-specifier is ill-formed.
2392  Diag(TemplateLoc, diag::err_tag_reference_non_tag) << 4;
2393  Diag(TAT->getLocation(), diag::note_declared_at);
2394  }
2395 
2396  QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
2397  if (Result.isNull())
2398  return TypeResult(true);
2399 
2400  // Check the tag kind
2401  if (const RecordType *RT = Result->getAs<RecordType>()) {
2402  RecordDecl *D = RT->getDecl();
2403 
2404  IdentifierInfo *Id = D->getIdentifier();
2405  assert(Id && "templated class must have an identifier");
2406 
2407  if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition,
2408  TagLoc, Id)) {
2409  Diag(TagLoc, diag::err_use_with_wrong_tag)
2410  << Result
2412  Diag(D->getLocation(), diag::note_previous_use);
2413  }
2414  }
2415 
2416  // Provide source-location information for the template specialization.
2417  TypeLocBuilder TLB;
2419  = TLB.push<TemplateSpecializationTypeLoc>(Result);
2420  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
2421  SpecTL.setTemplateNameLoc(TemplateLoc);
2422  SpecTL.setLAngleLoc(LAngleLoc);
2423  SpecTL.setRAngleLoc(RAngleLoc);
2424  for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
2425  SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
2426 
2427  // Construct an elaborated type containing the nested-name-specifier (if any)
2428  // and tag keyword.
2429  Result = Context.getElaboratedType(Keyword, SS.getScopeRep(), Result);
2430  ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
2431  ElabTL.setElaboratedKeywordLoc(TagLoc);
2433  return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
2434 }
2435 
2437  Sema &S, SourceLocation NameLoc, TemplateParameterList *TemplateParams,
2438  unsigned ExplicitArgs, SmallVectorImpl<TemplateArgument> &TemplateArgs);
2439 
2440 static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized,
2441  NamedDecl *PrevDecl,
2442  SourceLocation Loc,
2443  bool IsPartialSpecialization);
2444 
2446 
2448  const TemplateArgument &Arg, unsigned Depth, unsigned Index) {
2449  switch (Arg.getKind()) {
2456  return false;
2457 
2458  case TemplateArgument::Type: {
2459  QualType Type = Arg.getAsType();
2460  const TemplateTypeParmType *TPT =
2462  return TPT && !Type.hasQualifiers() &&
2463  TPT->getDepth() == Depth && TPT->getIndex() == Index;
2464  }
2465 
2467  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg.getAsExpr());
2468  if (!DRE || !DRE->getDecl())
2469  return false;
2470  const NonTypeTemplateParmDecl *NTTP =
2471  dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
2472  return NTTP && NTTP->getDepth() == Depth && NTTP->getIndex() == Index;
2473  }
2474 
2476  const TemplateTemplateParmDecl *TTP =
2477  dyn_cast_or_null<TemplateTemplateParmDecl>(
2479  return TTP && TTP->getDepth() == Depth && TTP->getIndex() == Index;
2480  }
2481  llvm_unreachable("unexpected kind of template argument");
2482 }
2483 
2486  if (Params->size() != Args.size())
2487  return false;
2488 
2489  unsigned Depth = Params->getDepth();
2490 
2491  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
2492  TemplateArgument Arg = Args[I];
2493 
2494  // If the parameter is a pack expansion, the argument must be a pack
2495  // whose only element is a pack expansion.
2496  if (Params->getParam(I)->isParameterPack()) {
2497  if (Arg.getKind() != TemplateArgument::Pack || Arg.pack_size() != 1 ||
2498  !Arg.pack_begin()->isPackExpansion())
2499  return false;
2500  Arg = Arg.pack_begin()->getPackExpansionPattern();
2501  }
2502 
2503  if (!isTemplateArgumentTemplateParameter(Arg, Depth, I))
2504  return false;
2505  }
2506 
2507  return true;
2508 }
2509 
2510 /// Convert the parser's template argument list representation into our form.
2513  TemplateArgumentListInfo TemplateArgs(TemplateId.LAngleLoc,
2514  TemplateId.RAngleLoc);
2515  ASTTemplateArgsPtr TemplateArgsPtr(TemplateId.getTemplateArgs(),
2516  TemplateId.NumArgs);
2517  S.translateTemplateArguments(TemplateArgsPtr, TemplateArgs);
2518  return TemplateArgs;
2519 }
2520 
2522  Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc,
2523  TemplateParameterList *TemplateParams, StorageClass SC,
2524  bool IsPartialSpecialization) {
2525  // D must be variable template id.
2526  assert(D.getName().getKind() == UnqualifiedId::IK_TemplateId &&
2527  "Variable template specialization is declared with a template it.");
2528 
2529  TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
2530  TemplateArgumentListInfo TemplateArgs =
2531  makeTemplateArgumentListInfo(*this, *TemplateId);
2532  SourceLocation TemplateNameLoc = D.getIdentifierLoc();
2533  SourceLocation LAngleLoc = TemplateId->LAngleLoc;
2534  SourceLocation RAngleLoc = TemplateId->RAngleLoc;
2535 
2536  TemplateName Name = TemplateId->Template.get();
2537 
2538  // The template-id must name a variable template.
2539  VarTemplateDecl *VarTemplate =
2540  dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());
2541  if (!VarTemplate) {
2542  NamedDecl *FnTemplate;
2543  if (auto *OTS = Name.getAsOverloadedTemplate())
2544  FnTemplate = *OTS->begin();
2545  else
2546  FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());
2547  if (FnTemplate)
2548  return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template_but_method)
2549  << FnTemplate->getDeclName();
2550  return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template)
2551  << IsPartialSpecialization;
2552  }
2553 
2554  // Check for unexpanded parameter packs in any of the template arguments.
2555  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
2556  if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
2557  UPPC_PartialSpecialization))
2558  return true;
2559 
2560  // Check that the template argument list is well-formed for this
2561  // template.
2563  if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
2564  false, Converted))
2565  return true;
2566 
2567  // Find the variable template (partial) specialization declaration that
2568  // corresponds to these arguments.
2569  if (IsPartialSpecialization) {
2571  *this, TemplateNameLoc, VarTemplate->getTemplateParameters(),
2572  TemplateArgs.size(), Converted))
2573  return true;
2574 
2575  bool InstantiationDependent;
2576  if (!Name.isDependent() &&
2578  TemplateArgs.arguments(),
2579  InstantiationDependent)) {
2580  Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
2581  << VarTemplate->getDeclName();
2582  IsPartialSpecialization = false;
2583  }
2584 
2586  Converted)) {
2587  // C++ [temp.class.spec]p9b3:
2588  //
2589  // -- The argument list of the specialization shall not be identical
2590  // to the implicit argument list of the primary template.
2591  Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
2592  << /*variable template*/ 1
2593  << /*is definition*/(SC != SC_Extern && !CurContext->isRecord())
2594  << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
2595  // FIXME: Recover from this by treating the declaration as a redeclaration
2596  // of the primary template.
2597  return true;
2598  }
2599  }
2600 
2601  void *InsertPos = nullptr;
2602  VarTemplateSpecializationDecl *PrevDecl = nullptr;
2603 
2604  if (IsPartialSpecialization)
2605  // FIXME: Template parameter list matters too
2606  PrevDecl = VarTemplate->findPartialSpecialization(Converted, InsertPos);
2607  else
2608  PrevDecl = VarTemplate->findSpecialization(Converted, InsertPos);
2609 
2610  VarTemplateSpecializationDecl *Specialization = nullptr;
2611 
2612  // Check whether we can declare a variable template specialization in
2613  // the current scope.
2614  if (CheckTemplateSpecializationScope(*this, VarTemplate, PrevDecl,
2615  TemplateNameLoc,
2616  IsPartialSpecialization))
2617  return true;
2618 
2619  if (PrevDecl && PrevDecl->getSpecializationKind() == TSK_Undeclared) {
2620  // Since the only prior variable template specialization with these
2621  // arguments was referenced but not declared, reuse that
2622  // declaration node as our own, updating its source location and
2623  // the list of outer template parameters to reflect our new declaration.
2624  Specialization = PrevDecl;
2625  Specialization->setLocation(TemplateNameLoc);
2626  PrevDecl = nullptr;
2627  } else if (IsPartialSpecialization) {
2628  // Create a new class template partial specialization declaration node.
2630  cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
2633  Context, VarTemplate->getDeclContext(), TemplateKWLoc,
2634  TemplateNameLoc, TemplateParams, VarTemplate, DI->getType(), DI, SC,
2635  Converted, TemplateArgs);
2636 
2637  if (!PrevPartial)
2638  VarTemplate->AddPartialSpecialization(Partial, InsertPos);
2639  Specialization = Partial;
2640 
2641  // If we are providing an explicit specialization of a member variable
2642  // template specialization, make a note of that.
2643  if (PrevPartial && PrevPartial->getInstantiatedFromMember())
2644  PrevPartial->setMemberSpecialization();
2645 
2646  // Check that all of the template parameters of the variable template
2647  // partial specialization are deducible from the template
2648  // arguments. If not, this variable template partial specialization
2649  // will never be used.
2650  llvm::SmallBitVector DeducibleParams(TemplateParams->size());
2651  MarkUsedTemplateParameters(Partial->getTemplateArgs(), true,
2652  TemplateParams->getDepth(), DeducibleParams);
2653 
2654  if (!DeducibleParams.all()) {
2655  unsigned NumNonDeducible =
2656  DeducibleParams.size() - DeducibleParams.count();
2657  Diag(TemplateNameLoc, diag::warn_partial_specs_not_deducible)
2658  << /*variable template*/ 1 << (NumNonDeducible > 1)
2659  << SourceRange(TemplateNameLoc, RAngleLoc);
2660  for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
2661  if (!DeducibleParams[I]) {
2662  NamedDecl *Param = cast<NamedDecl>(TemplateParams->getParam(I));
2663  if (Param->getDeclName())
2664  Diag(Param->getLocation(), diag::note_partial_spec_unused_parameter)
2665  << Param->getDeclName();
2666  else
2667  Diag(Param->getLocation(), diag::note_partial_spec_unused_parameter)
2668  << "(anonymous)";
2669  }
2670  }
2671  }
2672  } else {
2673  // Create a new class template specialization declaration node for
2674  // this explicit specialization or friend declaration.
2675  Specialization = VarTemplateSpecializationDecl::Create(
2676  Context, VarTemplate->getDeclContext(), TemplateKWLoc, TemplateNameLoc,
2677  VarTemplate, DI->getType(), DI, SC, Converted);
2678  Specialization->setTemplateArgsInfo(TemplateArgs);
2679 
2680  if (!PrevDecl)
2681  VarTemplate->AddSpecialization(Specialization, InsertPos);
2682  }
2683 
2684  // C++ [temp.expl.spec]p6:
2685  // If a template, a member template or the member of a class template is
2686  // explicitly specialized then that specialization shall be declared
2687  // before the first use of that specialization that would cause an implicit
2688  // instantiation to take place, in every translation unit in which such a
2689  // use occurs; no diagnostic is required.
2690  if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
2691  bool Okay = false;
2692  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
2693  // Is there any previous explicit specialization declaration?
2695  Okay = true;
2696  break;
2697  }
2698  }
2699 
2700  if (!Okay) {
2701  SourceRange Range(TemplateNameLoc, RAngleLoc);
2702  Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
2703  << Name << Range;
2704 
2705  Diag(PrevDecl->getPointOfInstantiation(),
2706  diag::note_instantiation_required_here)
2707  << (PrevDecl->getTemplateSpecializationKind() !=
2709  return true;
2710  }
2711  }
2712 
2713  Specialization->setTemplateKeywordLoc(TemplateKWLoc);
2714  Specialization->setLexicalDeclContext(CurContext);
2715 
2716  // Add the specialization into its lexical context, so that it can
2717  // be seen when iterating through the list of declarations in that
2718  // context. However, specializations are not found by name lookup.
2719  CurContext->addDecl(Specialization);
2720 
2721  // Note that this is an explicit specialization.
2723 
2724  if (PrevDecl) {
2725  // Check that this isn't a redefinition of this specialization,
2726  // merging with previous declarations.
2727  LookupResult PrevSpec(*this, GetNameForDeclarator(D), LookupOrdinaryName,
2728  ForRedeclaration);
2729  PrevSpec.addDecl(PrevDecl);
2730  D.setRedeclaration(CheckVariableDeclaration(Specialization, PrevSpec));
2731  } else if (Specialization->isStaticDataMember() &&
2732  Specialization->isOutOfLine()) {
2733  Specialization->setAccess(VarTemplate->getAccess());
2734  }
2735 
2736  // Link instantiations of static data members back to the template from
2737  // which they were instantiated.
2738  if (Specialization->isStaticDataMember())
2739  Specialization->setInstantiationOfStaticDataMember(
2740  VarTemplate->getTemplatedDecl(),
2741  Specialization->getSpecializationKind());
2742 
2743  return Specialization;
2744 }
2745 
2746 namespace {
2747 /// \brief A partial specialization whose template arguments have matched
2748 /// a given template-id.
2749 struct PartialSpecMatchResult {
2751  TemplateArgumentList *Args;
2752 };
2753 } // end anonymous namespace
2754 
2755 DeclResult
2757  SourceLocation TemplateNameLoc,
2758  const TemplateArgumentListInfo &TemplateArgs) {
2759  assert(Template && "A variable template id without template?");
2760 
2761  // Check that the template argument list is well-formed for this template.
2763  if (CheckTemplateArgumentList(
2764  Template, TemplateNameLoc,
2765  const_cast<TemplateArgumentListInfo &>(TemplateArgs), false,
2766  Converted))
2767  return true;
2768 
2769  // Find the variable template specialization declaration that
2770  // corresponds to these arguments.
2771  void *InsertPos = nullptr;
2772  if (VarTemplateSpecializationDecl *Spec = Template->findSpecialization(
2773  Converted, InsertPos)) {
2774  checkSpecializationVisibility(TemplateNameLoc, Spec);
2775  // If we already have a variable template specialization, return it.
2776  return Spec;
2777  }
2778 
2779  // This is the first time we have referenced this variable template
2780  // specialization. Create the canonical declaration and add it to
2781  // the set of specializations, based on the closest partial specialization
2782  // that it represents. That is,
2783  VarDecl *InstantiationPattern = Template->getTemplatedDecl();
2785  Converted);
2786  TemplateArgumentList *InstantiationArgs = &TemplateArgList;
2787  bool AmbiguousPartialSpec = false;
2788  typedef PartialSpecMatchResult MatchResult;
2790  SourceLocation PointOfInstantiation = TemplateNameLoc;
2791  TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation,
2792  /*ForTakingAddress=*/false);
2793 
2794  // 1. Attempt to find the closest partial specialization that this
2795  // specializes, if any.
2796  // If any of the template arguments is dependent, then this is probably
2797  // a placeholder for an incomplete declarative context; which must be
2798  // complete by instantiation time. Thus, do not search through the partial
2799  // specializations yet.
2800  // TODO: Unify with InstantiateClassTemplateSpecialization()?
2801  // Perhaps better after unification of DeduceTemplateArguments() and
2802  // getMoreSpecializedPartialSpecialization().
2803  bool InstantiationDependent = false;
2805  TemplateArgs, InstantiationDependent)) {
2806 
2808  Template->getPartialSpecializations(PartialSpecs);
2809 
2810  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2811  VarTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
2812  TemplateDeductionInfo Info(FailedCandidates.getLocation());
2813 
2815  DeduceTemplateArguments(Partial, TemplateArgList, Info)) {
2816  // Store the failed-deduction information for use in diagnostics, later.
2817  // TODO: Actually use the failed-deduction info?
2818  FailedCandidates.addCandidate().set(
2819  DeclAccessPair::make(Template, AS_public), Partial,
2821  (void)Result;
2822  } else {
2823  Matched.push_back(PartialSpecMatchResult());
2824  Matched.back().Partial = Partial;
2825  Matched.back().Args = Info.take();
2826  }
2827  }
2828 
2829  if (Matched.size() >= 1) {
2830  SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
2831  if (Matched.size() == 1) {
2832  // -- If exactly one matching specialization is found, the
2833  // instantiation is generated from that specialization.
2834  // We don't need to do anything for this.
2835  } else {
2836  // -- If more than one matching specialization is found, the
2837  // partial order rules (14.5.4.2) are used to determine
2838  // whether one of the specializations is more specialized
2839  // than the others. If none of the specializations is more
2840  // specialized than all of the other matching
2841  // specializations, then the use of the variable template is
2842  // ambiguous and the program is ill-formed.
2843  for (SmallVector<MatchResult, 4>::iterator P = Best + 1,
2844  PEnd = Matched.end();
2845  P != PEnd; ++P) {
2846  if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
2847  PointOfInstantiation) ==
2848  P->Partial)
2849  Best = P;
2850  }
2851 
2852  // Determine if the best partial specialization is more specialized than
2853  // the others.
2854  for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
2855  PEnd = Matched.end();
2856  P != PEnd; ++P) {
2857  if (P != Best && getMoreSpecializedPartialSpecialization(
2858  P->Partial, Best->Partial,
2859  PointOfInstantiation) != Best->Partial) {
2860  AmbiguousPartialSpec = true;
2861  break;
2862  }
2863  }
2864  }
2865 
2866  // Instantiate using the best variable template partial specialization.
2867  InstantiationPattern = Best->Partial;
2868  InstantiationArgs = Best->Args;
2869  } else {
2870  // -- If no match is found, the instantiation is generated
2871  // from the primary template.
2872  // InstantiationPattern = Template->getTemplatedDecl();
2873  }
2874  }
2875 
2876  // 2. Create the canonical declaration.
2877  // Note that we do not instantiate a definition until we see an odr-use
2878  // in DoMarkVarDeclReferenced().
2879  // FIXME: LateAttrs et al.?
2880  VarTemplateSpecializationDecl *Decl = BuildVarTemplateInstantiation(
2881  Template, InstantiationPattern, *InstantiationArgs, TemplateArgs,
2882  Converted, TemplateNameLoc, InsertPos /*, LateAttrs, StartingScope*/);
2883  if (!Decl)
2884  return true;
2885 
2886  if (AmbiguousPartialSpec) {
2887  // Partial ordering did not produce a clear winner. Complain.
2888  Decl->setInvalidDecl();
2889  Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
2890  << Decl;
2891 
2892  // Print the matching partial specializations.
2893  for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
2894  PEnd = Matched.end();
2895  P != PEnd; ++P)
2896  Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
2897  << getTemplateArgumentBindingsText(
2898  P->Partial->getTemplateParameters(), *P->Args);
2899  return true;
2900  }
2901 
2903  dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
2904  Decl->setInstantiationOf(D, InstantiationArgs);
2905 
2906  checkSpecializationVisibility(TemplateNameLoc, Decl);
2907 
2908  assert(Decl && "No variable template specialization?");
2909  return Decl;
2910 }
2911 
2912 ExprResult
2914  const DeclarationNameInfo &NameInfo,
2915  VarTemplateDecl *Template, SourceLocation TemplateLoc,
2916  const TemplateArgumentListInfo *TemplateArgs) {
2917 
2918  DeclResult Decl = CheckVarTemplateId(Template, TemplateLoc, NameInfo.getLoc(),
2919  *TemplateArgs);
2920  if (Decl.isInvalid())
2921  return ExprError();
2922 
2923  VarDecl *Var = cast<VarDecl>(Decl.get());
2924  if (!Var->getTemplateSpecializationKind())
2926  NameInfo.getLoc());
2927 
2928  // Build an ordinary singleton decl ref.
2929  return BuildDeclarationNameExpr(SS, NameInfo, Var,
2930  /*FoundD=*/nullptr, TemplateArgs);
2931 }
2932 
2934  SourceLocation TemplateKWLoc,
2935  LookupResult &R,
2936  bool RequiresADL,
2937  const TemplateArgumentListInfo *TemplateArgs) {
2938  // FIXME: Can we do any checking at this point? I guess we could check the
2939  // template arguments that we have against the template name, if the template
2940  // name refers to a single template. That's not a terribly common case,
2941  // though.
2942  // foo<int> could identify a single function unambiguously
2943  // This approach does NOT work, since f<int>(1);
2944  // gets resolved prior to resorting to overload resolution
2945  // i.e., template<class T> void f(double);
2946  // vs template<class T, class U> void f(U);
2947 
2948  // These should be filtered out by our callers.
2949  assert(!R.empty() && "empty lookup results when building templateid");
2950  assert(!R.isAmbiguous() && "ambiguous lookup when building templateid");
2951 
2952  // In C++1y, check variable template ids.
2953  bool InstantiationDependent;
2954  if (R.getAsSingle<VarTemplateDecl>() &&
2956  *TemplateArgs, InstantiationDependent)) {
2957  return CheckVarTemplateId(SS, R.getLookupNameInfo(),
2959  TemplateKWLoc, TemplateArgs);
2960  }
2961 
2962  // We don't want lookup warnings at this point.
2963  R.suppressDiagnostics();
2964 
2968  TemplateKWLoc,
2969  R.getLookupNameInfo(),
2970  RequiresADL, TemplateArgs,
2971  R.begin(), R.end());
2972 
2973  return ULE;
2974 }
2975 
2976 // We actually only call this from template instantiation.
2977 ExprResult
2979  SourceLocation TemplateKWLoc,
2980  const DeclarationNameInfo &NameInfo,
2981  const TemplateArgumentListInfo *TemplateArgs) {
2982 
2983  assert(TemplateArgs || TemplateKWLoc.isValid());
2984  DeclContext *DC;
2985  if (!(DC = computeDeclContext(SS, false)) ||
2986  DC->isDependentContext() ||
2987  RequireCompleteDeclContext(SS, DC))
2988  return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
2989 
2990  bool MemberOfUnknownSpecialization;
2991  LookupResult R(*this, NameInfo, LookupOrdinaryName);
2992  LookupTemplateName(R, (Scope*)nullptr, SS, QualType(), /*Entering*/ false,
2993  MemberOfUnknownSpecialization);
2994 
2995  if (R.isAmbiguous())
2996  return ExprError();
2997 
2998  if (R.empty()) {
2999  Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_non_template)
3000  << NameInfo.getName() << SS.getRange();
3001  return ExprError();
3002  }
3003 
3004  if (ClassTemplateDecl *Temp = R.getAsSingle<ClassTemplateDecl>()) {
3005  Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_class_template)
3006  << SS.getScopeRep()
3007  << NameInfo.getName().getAsString() << SS.getRange();
3008  Diag(Temp->getLocation(), diag::note_referenced_class_template);
3009  return ExprError();
3010  }
3011 
3012  return BuildTemplateIdExpr(SS, TemplateKWLoc, R, /*ADL*/ false, TemplateArgs);
3013 }
3014 
3015 /// \brief Form a dependent template name.
3016 ///
3017 /// This action forms a dependent template name given the template
3018 /// name and its (presumably dependent) scope specifier. For
3019 /// example, given "MetaFun::template apply", the scope specifier \p
3020 /// SS will be "MetaFun::", \p TemplateKWLoc contains the location
3021 /// of the "template" keyword, and "apply" is the \p Name.
3023  CXXScopeSpec &SS,
3024  SourceLocation TemplateKWLoc,
3026  ParsedType ObjectType,
3027  bool EnteringContext,
3028  TemplateTy &Result) {
3029  if (TemplateKWLoc.isValid() && S && !S->getTemplateParamParent())
3030  Diag(TemplateKWLoc,
3031  getLangOpts().CPlusPlus11 ?
3032  diag::warn_cxx98_compat_template_outside_of_template :
3033  diag::ext_template_outside_of_template)
3034  << FixItHint::CreateRemoval(TemplateKWLoc);
3035 
3036  DeclContext *LookupCtx = nullptr;
3037  if (SS.isSet())
3038  LookupCtx = computeDeclContext(SS, EnteringContext);
3039  if (!LookupCtx && ObjectType)
3040  LookupCtx = computeDeclContext(ObjectType.get());
3041  if (LookupCtx) {
3042  // C++0x [temp.names]p5:
3043  // If a name prefixed by the keyword template is not the name of
3044  // a template, the program is ill-formed. [Note: the keyword
3045  // template may not be applied to non-template members of class
3046  // templates. -end note ] [ Note: as is the case with the
3047  // typename prefix, the template prefix is allowed in cases
3048  // where it is not strictly necessary; i.e., when the
3049  // nested-name-specifier or the expression on the left of the ->
3050  // or . is not dependent on a template-parameter, or the use
3051  // does not appear in the scope of a template. -end note]
3052  //
3053  // Note: C++03 was more strict here, because it banned the use of
3054  // the "template" keyword prior to a template-name that was not a
3055  // dependent name. C++ DR468 relaxed this requirement (the
3056  // "template" keyword is now permitted). We follow the C++0x
3057  // rules, even in C++03 mode with a warning, retroactively applying the DR.
3058  bool MemberOfUnknownSpecialization;
3059  TemplateNameKind TNK = isTemplateName(S, SS, TemplateKWLoc.isValid(), Name,
3060  ObjectType, EnteringContext, Result,
3061  MemberOfUnknownSpecialization);
3062  if (TNK == TNK_Non_template && LookupCtx->isDependentContext() &&
3063  isa<CXXRecordDecl>(LookupCtx) &&
3064  (!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() ||
3065  cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases())) {
3066  // This is a dependent template. Handle it below.
3067  } else if (TNK == TNK_Non_template) {
3068  Diag(Name.getLocStart(),
3069  diag::err_template_kw_refers_to_non_template)
3070  << GetNameFromUnqualifiedId(Name).getName()
3071  << Name.getSourceRange()
3072  << TemplateKWLoc;
3073  return TNK_Non_template;
3074  } else {
3075  // We found something; return it.
3076  return TNK;
3077  }
3078  }
3079 
3080  NestedNameSpecifier *Qualifier = SS.getScopeRep();
3081 
3082  switch (Name.getKind()) {
3084  Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
3085  Name.Identifier));
3087 
3089  Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
3091  return TNK_Function_template;
3092 
3094  llvm_unreachable("literal operator id cannot have a dependent scope");
3095 
3096  default:
3097  break;
3098  }
3099 
3100  Diag(Name.getLocStart(),
3101  diag::err_template_kw_refers_to_non_template)
3102  << GetNameFromUnqualifiedId(Name).getName()
3103  << Name.getSourceRange()
3104  << TemplateKWLoc;
3105  return TNK_Non_template;
3106 }
3107 
3109  TemplateArgumentLoc &AL,
3110  SmallVectorImpl<TemplateArgument> &Converted) {
3111  const TemplateArgument &Arg = AL.getArgument();
3112  QualType ArgType;
3113  TypeSourceInfo *TSI = nullptr;
3114 
3115  // Check template type parameter.
3116  switch(Arg.getKind()) {
3118  // C++ [temp.arg.type]p1:
3119  // A template-argument for a template-parameter which is a
3120  // type shall be a type-id.
3121  ArgType = Arg.getAsType();
3122  TSI = AL.getTypeSourceInfo();
3123  break;
3125  // We have a template type parameter but the template argument
3126  // is a template without any arguments.
3127  SourceRange SR = AL.getSourceRange();
3129  Diag(SR.getBegin(), diag::err_template_missing_args)
3130  << Name << SR;
3131  if (TemplateDecl *Decl = Name.getAsTemplateDecl())
3132  Diag(Decl->getLocation(), diag::note_template_decl_here);
3133 
3134  return true;
3135  }
3137  // We have a template type parameter but the template argument is an
3138  // expression; see if maybe it is missing the "typename" keyword.
3139  CXXScopeSpec SS;
3140  DeclarationNameInfo NameInfo;
3141 
3142  if (DeclRefExpr *ArgExpr = dyn_cast<DeclRefExpr>(Arg.getAsExpr())) {
3143  SS.Adopt(ArgExpr->getQualifierLoc());
3144  NameInfo = ArgExpr->getNameInfo();
3145  } else if (DependentScopeDeclRefExpr *ArgExpr =
3146  dyn_cast<DependentScopeDeclRefExpr>(Arg.getAsExpr())) {
3147  SS.Adopt(ArgExpr->getQualifierLoc());
3148  NameInfo = ArgExpr->getNameInfo();
3149  } else if (CXXDependentScopeMemberExpr *ArgExpr =
3150  dyn_cast<CXXDependentScopeMemberExpr>(Arg.getAsExpr())) {
3151  if (ArgExpr->isImplicitAccess()) {
3152  SS.Adopt(ArgExpr->getQualifierLoc());
3153  NameInfo = ArgExpr->getMemberNameInfo();
3154  }
3155  }
3156 
3157  if (auto *II = NameInfo.getName().getAsIdentifierInfo()) {
3158  LookupResult Result(*this, NameInfo, LookupOrdinaryName);
3159  LookupParsedName(Result, CurScope, &SS);
3160 
3161  if (Result.getAsSingle<TypeDecl>() ||
3162  Result.getResultKind() ==
3164  // Suggest that the user add 'typename' before the NNS.
3165  SourceLocation Loc = AL.getSourceRange().getBegin();
3166  Diag(Loc, getLangOpts().MSVCCompat
3167  ? diag::ext_ms_template_type_arg_missing_typename
3168  : diag::err_template_arg_must_be_type_suggest)
3169  << FixItHint::CreateInsertion(Loc, "typename ");
3170  Diag(Param->getLocation(), diag::note_template_param_here);
3171 
3172  // Recover by synthesizing a type using the location information that we
3173  // already have.
3174  ArgType =
3176  TypeLocBuilder TLB;
3177  DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(ArgType);
3178  TL.setElaboratedKeywordLoc(SourceLocation(/*synthesized*/));
3180  TL.setNameLoc(NameInfo.getLoc());
3181  TSI = TLB.getTypeSourceInfo(Context, ArgType);
3182 
3183  // Overwrite our input TemplateArgumentLoc so that we can recover
3184  // properly.
3185  AL = TemplateArgumentLoc(TemplateArgument(ArgType),
3187 
3188  break;
3189  }
3190  }
3191  // fallthrough
3192  }
3193  default: {
3194  // We have a template type parameter but the template argument
3195  // is not a type.
3196  SourceRange SR = AL.getSourceRange();
3197  Diag(SR.getBegin(), diag::err_template_arg_must_be_type) << SR;
3198  Diag(Param->getLocation(), diag::note_template_param_here);
3199 
3200  return true;
3201  }
3202  }
3203 
3204  if (CheckTemplateArgument(Param, TSI))
3205  return true;
3206 
3207  // Add the converted template type argument.
3208  ArgType = Context.getCanonicalType(ArgType);
3209 
3210  // Objective-C ARC:
3211  // If an explicitly-specified template argument type is a lifetime type
3212  // with no lifetime qualifier, the __strong lifetime qualifier is inferred.
3213  if (getLangOpts().ObjCAutoRefCount &&
3214  ArgType->isObjCLifetimeType() &&
3215  !ArgType.getObjCLifetime()) {
3216  Qualifiers Qs;
3218  ArgType = Context.getQualifiedType(ArgType, Qs);
3219  }
3220 
3221  Converted.push_back(TemplateArgument(ArgType));
3222  return false;
3223 }
3224 
3225 /// \brief Substitute template arguments into the default template argument for
3226 /// the given template type parameter.
3227 ///
3228 /// \param SemaRef the semantic analysis object for which we are performing
3229 /// the substitution.
3230 ///
3231 /// \param Template the template that we are synthesizing template arguments
3232 /// for.
3233 ///
3234 /// \param TemplateLoc the location of the template name that started the
3235 /// template-id we are checking.
3236 ///
3237 /// \param RAngleLoc the location of the right angle bracket ('>') that
3238 /// terminates the template-id.
3239 ///
3240 /// \param Param the template template parameter whose default we are
3241 /// substituting into.
3242 ///
3243 /// \param Converted the list of template arguments provided for template
3244 /// parameters that precede \p Param in the template parameter list.
3245 /// \returns the substituted template argument, or NULL if an error occurred.
3246 static TypeSourceInfo *
3248  TemplateDecl *Template,
3249  SourceLocation TemplateLoc,
3250  SourceLocation RAngleLoc,
3251  TemplateTypeParmDecl *Param,
3252  SmallVectorImpl<TemplateArgument> &Converted) {
3253  TypeSourceInfo *ArgType = Param->getDefaultArgumentInfo();
3254 
3255  // If the argument type is dependent, instantiate it now based
3256  // on the previously-computed template arguments.
3257  if (ArgType->getType()->isDependentType()) {
3258  Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
3259  Template, Converted,
3260  SourceRange(TemplateLoc, RAngleLoc));
3261  if (Inst.isInvalid())
3262  return nullptr;
3263 
3264  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
3265 
3266  // Only substitute for the innermost template argument list.
3267  MultiLevelTemplateArgumentList TemplateArgLists;
3268  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
3269  for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
3270  TemplateArgLists.addOuterTemplateArguments(None);
3271 
3272  Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
3273  ArgType =
3274  SemaRef.SubstType(ArgType, TemplateArgLists,
3275  Param->getDefaultArgumentLoc(), Param->getDeclName());
3276  }
3277 
3278  return ArgType;
3279 }
3280 
3281 /// \brief Substitute template arguments into the default template argument for
3282 /// the given non-type template parameter.
3283 ///
3284 /// \param SemaRef the semantic analysis object for which we are performing
3285 /// the substitution.
3286 ///
3287 /// \param Template the template that we are synthesizing template arguments
3288 /// for.
3289 ///
3290 /// \param TemplateLoc the location of the template name that started the
3291 /// template-id we are checking.
3292 ///
3293 /// \param RAngleLoc the location of the right angle bracket ('>') that
3294 /// terminates the template-id.
3295 ///
3296 /// \param Param the non-type template parameter whose default we are
3297 /// substituting into.
3298 ///
3299 /// \param Converted the list of template arguments provided for template
3300 /// parameters that precede \p Param in the template parameter list.
3301 ///
3302 /// \returns the substituted template argument, or NULL if an error occurred.
3303 static ExprResult
3305  TemplateDecl *Template,
3306  SourceLocation TemplateLoc,
3307  SourceLocation RAngleLoc,
3308  NonTypeTemplateParmDecl *Param,
3309  SmallVectorImpl<TemplateArgument> &Converted) {
3310  Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
3311  Template, Converted,
3312  SourceRange(TemplateLoc, RAngleLoc));
3313  if (Inst.isInvalid())
3314  return ExprError();
3315 
3316  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
3317 
3318  // Only substitute for the innermost template argument list.
3319  MultiLevelTemplateArgumentList TemplateArgLists;
3320  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
3321  for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
3322  TemplateArgLists.addOuterTemplateArguments(None);
3323 
3324  EnterExpressionEvaluationContext ConstantEvaluated(SemaRef,
3326  return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists);
3327 }
3328 
3329 /// \brief Substitute template arguments into the default template argument for
3330 /// the given template template parameter.
3331 ///
3332 /// \param SemaRef the semantic analysis object for which we are performing
3333 /// the substitution.
3334 ///
3335 /// \param Template the template that we are synthesizing template arguments
3336 /// for.
3337 ///
3338 /// \param TemplateLoc the location of the template name that started the
3339 /// template-id we are checking.
3340 ///
3341 /// \param RAngleLoc the location of the right angle bracket ('>') that
3342 /// terminates the template-id.
3343 ///
3344 /// \param Param the template template parameter whose default we are
3345 /// substituting into.
3346 ///
3347 /// \param Converted the list of template arguments provided for template
3348 /// parameters that precede \p Param in the template parameter list.
3349 ///
3350 /// \param QualifierLoc Will be set to the nested-name-specifier (with
3351 /// source-location information) that precedes the template name.
3352 ///
3353 /// \returns the substituted template argument, or NULL if an error occurred.
3354 static TemplateName
3356  TemplateDecl *Template,
3357  SourceLocation TemplateLoc,
3358  SourceLocation RAngleLoc,
3359  TemplateTemplateParmDecl *Param,
3360  SmallVectorImpl<TemplateArgument> &Converted,
3361  NestedNameSpecifierLoc &QualifierLoc) {
3362  Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc, Template, Converted,
3363  SourceRange(TemplateLoc, RAngleLoc));
3364  if (Inst.isInvalid())
3365  return TemplateName();
3366 
3367  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
3368 
3369  // Only substitute for the innermost template argument list.
3370  MultiLevelTemplateArgumentList TemplateArgLists;
3371  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
3372  for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
3373  TemplateArgLists.addOuterTemplateArguments(None);
3374 
3375  Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
3376  // Substitute into the nested-name-specifier first,
3377  QualifierLoc = Param->getDefaultArgument().getTemplateQualifierLoc();
3378  if (QualifierLoc) {
3379  QualifierLoc =
3380  SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgLists);
3381  if (!QualifierLoc)
3382  return TemplateName();
3383  }
3384 
3385  return SemaRef.SubstTemplateName(
3386  QualifierLoc,
3389  TemplateArgLists);
3390 }
3391 
3392 /// \brief If the given template parameter has a default template
3393 /// argument, substitute into that default template argument and
3394 /// return the corresponding template argument.
3397  SourceLocation TemplateLoc,
3398  SourceLocation RAngleLoc,
3399  Decl *Param,
3401  &Converted,
3402  bool &HasDefaultArg) {
3403  HasDefaultArg = false;
3404 
3405  if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) {
3406  if (!hasVisibleDefaultArgument(TypeParm))
3407  return TemplateArgumentLoc();
3408 
3409  HasDefaultArg = true;
3410  TypeSourceInfo *DI = SubstDefaultTemplateArgument(*this, Template,
3411  TemplateLoc,
3412  RAngleLoc,
3413  TypeParm,
3414  Converted);
3415  if (DI)
3416  return TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
3417 
3418  return TemplateArgumentLoc();
3419  }
3420 
3421  if (NonTypeTemplateParmDecl *NonTypeParm
3422  = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
3423  if (!hasVisibleDefaultArgument(NonTypeParm))
3424  return TemplateArgumentLoc();
3425 
3426  HasDefaultArg = true;
3427  ExprResult Arg = SubstDefaultTemplateArgument(*this, Template,
3428  TemplateLoc,
3429  RAngleLoc,
3430  NonTypeParm,
3431  Converted);
3432  if (Arg.isInvalid())
3433  return TemplateArgumentLoc();
3434 
3435  Expr *ArgE = Arg.getAs<Expr>();
3436  return TemplateArgumentLoc(TemplateArgument(ArgE), ArgE);
3437  }
3438 
3439  TemplateTemplateParmDecl *TempTempParm
3440  = cast<TemplateTemplateParmDecl>(Param);
3441  if (!hasVisibleDefaultArgument(TempTempParm))
3442  return TemplateArgumentLoc();
3443 
3444  HasDefaultArg = true;
3445  NestedNameSpecifierLoc QualifierLoc;
3446  TemplateName TName = SubstDefaultTemplateArgument(*this, Template,
3447  TemplateLoc,
3448  RAngleLoc,
3449  TempTempParm,
3450  Converted,
3451  QualifierLoc);
3452  if (TName.isNull())
3453  return TemplateArgumentLoc();
3454 
3455  return TemplateArgumentLoc(TemplateArgument(TName),
3456  TempTempParm->getDefaultArgument().getTemplateQualifierLoc(),
3457  TempTempParm->getDefaultArgument().getTemplateNameLoc());
3458 }
3459 
3460 /// \brief Check that the given template argument corresponds to the given
3461 /// template parameter.
3462 ///
3463 /// \param Param The template parameter against which the argument will be
3464 /// checked.
3465 ///
3466 /// \param Arg The template argument, which may be updated due to conversions.
3467 ///
3468 /// \param Template The template in which the template argument resides.
3469 ///
3470 /// \param TemplateLoc The location of the template name for the template
3471 /// whose argument list we're matching.
3472 ///
3473 /// \param RAngleLoc The location of the right angle bracket ('>') that closes
3474 /// the template argument list.
3475 ///
3476 /// \param ArgumentPackIndex The index into the argument pack where this
3477 /// argument will be placed. Only valid if the parameter is a parameter pack.
3478 ///
3479 /// \param Converted The checked, converted argument will be added to the
3480 /// end of this small vector.
3481 ///
3482 /// \param CTAK Describes how we arrived at this particular template argument:
3483 /// explicitly written, deduced, etc.
3484 ///
3485 /// \returns true on error, false otherwise.
3487  TemplateArgumentLoc &Arg,
3488  NamedDecl *Template,
3489  SourceLocation TemplateLoc,
3490  SourceLocation RAngleLoc,
3491  unsigned ArgumentPackIndex,
3494  // Check template type parameters.
3495  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
3496  return CheckTemplateTypeArgument(TTP, Arg, Converted);
3497 
3498  // Check non-type template parameters.
3499  if (NonTypeTemplateParmDecl *NTTP =dyn_cast<NonTypeTemplateParmDecl>(Param)) {
3500  // Do substitution on the type of the non-type template parameter
3501  // with the template arguments we've seen thus far. But if the
3502  // template has a dependent context then we cannot substitute yet.
3503  QualType NTTPType = NTTP->getType();
3504  if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
3505  NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
3506 
3507  if (NTTPType->isDependentType() &&
3508  !isa<TemplateTemplateParmDecl>(Template) &&
3509  !Template->getDeclContext()->isDependentContext()) {
3510  // Do substitution on the type of the non-type template parameter.
3511  InstantiatingTemplate Inst(*this, TemplateLoc, Template,
3512  NTTP, Converted,
3513  SourceRange(TemplateLoc, RAngleLoc));
3514  if (Inst.isInvalid())
3515  return true;
3516 
3518  Converted);
3519  NTTPType = SubstType(NTTPType,
3520  MultiLevelTemplateArgumentList(TemplateArgs),
3521  NTTP->getLocation(),
3522  NTTP->getDeclName());
3523  // If that worked, check the non-type template parameter type
3524  // for validity.
3525  if (!NTTPType.isNull())
3526  NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
3527  NTTP->getLocation());
3528  if (NTTPType.isNull())
3529  return true;
3530  }
3531 
3532  switch (Arg.getArgument().getKind()) {
3534  llvm_unreachable("Should never see a NULL template argument here");
3535 
3538  ExprResult Res =
3539  CheckTemplateArgument(NTTP, NTTPType, Arg.getArgument().getAsExpr(),
3540  Result, CTAK);
3541  if (Res.isInvalid())
3542  return true;
3543 
3544  // If the resulting expression is new, then use it in place of the
3545  // old expression in the template argument.
3546  if (Res.get() != Arg.getArgument().getAsExpr()) {
3547  TemplateArgument TA(Res.get());
3548  Arg = TemplateArgumentLoc(TA, Res.get());
3549  }
3550 
3551  Converted.push_back(Result);
3552  break;
3553  }
3554 
3558  // We've already checked this template argument, so just copy
3559  // it to the list of converted arguments.
3560  Converted.push_back(Arg.getArgument());
3561  break;
3562 
3565  // We were given a template template argument. It may not be ill-formed;
3566  // see below.
3567  if (DependentTemplateName *DTN
3570  // We have a template argument such as \c T::template X, which we
3571  // parsed as a template template argument. However, since we now
3572  // know that we need a non-type template argument, convert this
3573  // template name into an expression.
3574 
3575  DeclarationNameInfo NameInfo(DTN->getIdentifier(),
3576  Arg.getTemplateNameLoc());
3577 
3578  CXXScopeSpec SS;
3579  SS.Adopt(Arg.getTemplateQualifierLoc());
3580  // FIXME: the template-template arg was a DependentTemplateName,
3581  // so it was provided with a template keyword. However, its source
3582  // location is not stored in the template argument structure.
3583  SourceLocation TemplateKWLoc;
3585  Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
3586  nullptr);
3587 
3588  // If we parsed the template argument as a pack expansion, create a
3589  // pack expansion expression.
3591  E = ActOnPackExpansion(E.get(), Arg.getTemplateEllipsisLoc());
3592  if (E.isInvalid())
3593  return true;
3594  }
3595 
3597  E = CheckTemplateArgument(NTTP, NTTPType, E.get(), Result);
3598  if (E.isInvalid())
3599  return true;
3600 
3601  Converted.push_back(Result);
3602  break;
3603  }
3604 
3605  // We have a template argument that actually does refer to a class
3606  // template, alias template, or template template parameter, and
3607  // therefore cannot be a non-type template argument.
3608  Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr)
3609  << Arg.getSourceRange();
3610 
3611  Diag(Param->getLocation(), diag::note_template_param_here);
3612  return true;
3613 
3614  case TemplateArgument::Type: {
3615  // We have a non-type template parameter but the template
3616  // argument is a type.
3617 
3618  // C++ [temp.arg]p2:
3619  // In a template-argument, an ambiguity between a type-id and
3620  // an expression is resolved to a type-id, regardless of the
3621  // form of the corresponding template-parameter.
3622  //
3623  // We warn specifically about this case, since it can be rather
3624  // confusing for users.
3625  QualType T = Arg.getArgument().getAsType();
3626  SourceRange SR = Arg.getSourceRange();
3627  if (T->isFunctionType())
3628  Diag(SR.getBegin(), diag::err_template_arg_nontype_ambig) << SR << T;
3629  else
3630  Diag(SR.getBegin(), diag::err_template_arg_must_be_expr) << SR;
3631  Diag(Param->getLocation(), diag::note_template_param_here);
3632  return true;
3633  }
3634 
3636  llvm_unreachable("Caller must expand template argument packs");
3637  }
3638 
3639  return false;
3640  }
3641 
3642 
3643  // Check template template parameters.
3644  TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(Param);
3645 
3646  // Substitute into the template parameter list of the template
3647  // template parameter, since previously-supplied template arguments
3648  // may appear within the template template parameter.
3649  {
3650  // Set up a template instantiation context.
3652  InstantiatingTemplate Inst(*this, TemplateLoc, Template,
3653  TempParm, Converted,
3654  SourceRange(TemplateLoc, RAngleLoc));
3655  if (Inst.isInvalid())
3656  return true;
3657 
3658  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
3659  TempParm = cast_or_null<TemplateTemplateParmDecl>(
3660  SubstDecl(TempParm, CurContext,
3661  MultiLevelTemplateArgumentList(TemplateArgs)));
3662  if (!TempParm)
3663  return true;
3664  }
3665 
3666  switch (Arg.getArgument().getKind()) {
3668  llvm_unreachable("Should never see a NULL template argument here");
3669 
3672  if (CheckTemplateArgument(TempParm, Arg, ArgumentPackIndex))
3673  return true;
3674 
3675  Converted.push_back(Arg.getArgument());
3676  break;
3677 
3680  // We have a template template parameter but the template
3681  // argument does not refer to a template.
3682  Diag(Arg.getLocation(), diag::err_template_arg_must_be_template)
3683  << getLangOpts().CPlusPlus11;
3684  return true;
3685 
3687  llvm_unreachable("Declaration argument with template template parameter");
3689  llvm_unreachable("Integral argument with template template parameter");
3691  llvm_unreachable("Null pointer argument with template template parameter");
3692 
3694  llvm_unreachable("Caller must expand template argument packs");
3695  }
3696 
3697  return false;
3698 }
3699 
3700 /// \brief Diagnose an arity mismatch in the
3701 static bool diagnoseArityMismatch(Sema &S, TemplateDecl *Template,
3702  SourceLocation TemplateLoc,
3703  TemplateArgumentListInfo &TemplateArgs) {
3704  TemplateParameterList *Params = Template->getTemplateParameters();
3705  unsigned NumParams = Params->size();
3706  unsigned NumArgs = TemplateArgs.size();
3707 
3708  SourceRange Range;
3709  if (NumArgs > NumParams)
3710  Range = SourceRange(TemplateArgs[NumParams].getLocation(),
3711  TemplateArgs.getRAngleLoc());
3712  S.Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
3713  << (NumArgs > NumParams)
3714  << (isa<ClassTemplateDecl>(Template)? 0 :
3715  isa<FunctionTemplateDecl>(Template)? 1 :
3716  isa<TemplateTemplateParmDecl>(Template)? 2 : 3)
3717  << Template << Range;
3718  S.Diag(Template->getLocation(), diag::note_template_decl_here)
3719  << Params->getSourceRange();
3720  return true;
3721 }
3722 
3723 /// \brief Check whether the template parameter is a pack expansion, and if so,
3724 /// determine the number of parameters produced by that expansion. For instance:
3725 ///
3726 /// \code
3727 /// template<typename ...Ts> struct A {
3728 /// template<Ts ...NTs, template<Ts> class ...TTs, typename ...Us> struct B;
3729 /// };
3730 /// \endcode
3731 ///
3732 /// In \c A<int,int>::B, \c NTs and \c TTs have expanded pack size 2, and \c Us
3733 /// is not a pack expansion, so returns an empty Optional.
3735  if (NonTypeTemplateParmDecl *NTTP
3736  = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
3737  if (NTTP->isExpandedParameterPack())
3738  return NTTP->getNumExpansionTypes();
3739  }
3740 
3741  if (TemplateTemplateParmDecl *TTP
3742  = dyn_cast<TemplateTemplateParmDecl>(Param)) {
3743  if (TTP->isExpandedParameterPack())
3744  return TTP->getNumExpansionTemplateParameters();
3745  }
3746 
3747  return None;
3748 }
3749 
3750 /// Diagnose a missing template argument.
3751 template<typename TemplateParmDecl>
3753  TemplateDecl *TD,
3754  const TemplateParmDecl *D,
3755  TemplateArgumentListInfo &Args) {
3756  // Dig out the most recent declaration of the template parameter; there may be
3757  // declarations of the template that are more recent than TD.
3758  D = cast<TemplateParmDecl>(cast<TemplateDecl>(TD->getMostRecentDecl())
3759  ->getTemplateParameters()
3760  ->getParam(D->getIndex()));
3761 
3762  // If there's a default argument that's not visible, diagnose that we're
3763  // missing a module import.
3765  if (D->hasDefaultArgument() && !S.hasVisibleDefaultArgument(D, &Modules)) {
3766  S.diagnoseMissingImport(Loc, cast<NamedDecl>(TD),
3767  D->getDefaultArgumentLoc(), Modules,
3769  /*Recover*/true);
3770  return true;
3771  }
3772 
3773  // FIXME: If there's a more recent default argument that *is* visible,
3774  // diagnose that it was declared too late.
3775 
3776  return diagnoseArityMismatch(S, TD, Loc, Args);
3777 }
3778 
3779 /// \brief Check that the given template argument list is well-formed
3780 /// for specializing the given template.
3782  SourceLocation TemplateLoc,
3783  TemplateArgumentListInfo &TemplateArgs,
3784  bool PartialTemplateArgs,
3785  SmallVectorImpl<TemplateArgument> &Converted) {
3786  // Make a copy of the template arguments for processing. Only make the
3787  // changes at the end when successful in matching the arguments to the
3788  // template.
3789  TemplateArgumentListInfo NewArgs = TemplateArgs;
3790 
3791  TemplateParameterList *Params = Template->getTemplateParameters();
3792 
3793  SourceLocation RAngleLoc = NewArgs.getRAngleLoc();
3794 
3795  // C++ [temp.arg]p1:
3796  // [...] The type and form of each template-argument specified in
3797  // a template-id shall match the type and form specified for the
3798  // corresponding parameter declared by the template in its
3799  // template-parameter-list.
3800  bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
3801  SmallVector<TemplateArgument, 2> ArgumentPack;
3802  unsigned ArgIdx = 0, NumArgs = NewArgs.size();
3803  LocalInstantiationScope InstScope(*this, true);
3804  for (TemplateParameterList::iterator Param = Params->begin(),
3805  ParamEnd = Params->end();
3806  Param != ParamEnd; /* increment in loop */) {
3807  // If we have an expanded parameter pack, make sure we don't have too
3808  // many arguments.
3809  if (Optional<unsigned> Expansions = getExpandedPackSize(*Param)) {
3810  if (*Expansions == ArgumentPack.size()) {
3811  // We're done with this parameter pack. Pack up its arguments and add
3812  // them to the list.
3813  Converted.push_back(
3814  TemplateArgument::CreatePackCopy(Context, ArgumentPack));
3815  ArgumentPack.clear();
3816 
3817  // This argument is assigned to the next parameter.
3818  ++Param;
3819  continue;
3820  } else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
3821  // Not enough arguments for this parameter pack.
3822  Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
3823  << false
3824  << (isa<ClassTemplateDecl>(Template)? 0 :
3825  isa<FunctionTemplateDecl>(Template)? 1 :
3826  isa<TemplateTemplateParmDecl>(Template)? 2 : 3)
3827  << Template;
3828  Diag(Template->getLocation(), diag::note_template_decl_here)
3829  << Params->getSourceRange();
3830  return true;
3831  }
3832  }
3833 
3834  if (ArgIdx < NumArgs) {
3835  // Check the template argument we were given.
3836  if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template,
3837  TemplateLoc, RAngleLoc,
3838  ArgumentPack.size(), Converted))
3839  return true;
3840 
3841  bool PackExpansionIntoNonPack =
3842  NewArgs[ArgIdx].getArgument().isPackExpansion() &&
3843  (!(*Param)->isTemplateParameterPack() || getExpandedPackSize(*Param));
3844  if (PackExpansionIntoNonPack && isa<TypeAliasTemplateDecl>(Template)) {
3845  // Core issue 1430: we have a pack expansion as an argument to an
3846  // alias template, and it's not part of a parameter pack. This
3847  // can't be canonicalized, so reject it now.
3848  Diag(NewArgs[ArgIdx].getLocation(),
3849  diag::err_alias_template_expansion_into_fixed_list)
3850  << NewArgs[ArgIdx].getSourceRange();
3851  Diag((*Param)->getLocation(), diag::note_template_param_here);
3852  return true;
3853  }
3854 
3855  // We're now done with this argument.
3856  ++ArgIdx;
3857 
3858  if ((*Param)->isTemplateParameterPack()) {
3859  // The template parameter was a template parameter pack, so take the
3860  // deduced argument and place it on the argument pack. Note that we
3861  // stay on the same template parameter so that we can deduce more
3862  // arguments.
3863  ArgumentPack.push_back(Converted.pop_back_val());
3864  } else {
3865  // Move to the next template parameter.
3866  ++Param;
3867  }
3868 
3869  // If we just saw a pack expansion into a non-pack, then directly convert
3870  // the remaining arguments, because we don't know what parameters they'll
3871  // match up with.
3872  if (PackExpansionIntoNonPack) {
3873  if (!ArgumentPack.empty()) {
3874  // If we were part way through filling in an expanded parameter pack,
3875  // fall back to just producing individual arguments.
3876  Converted.insert(Converted.end(),
3877  ArgumentPack.begin(), ArgumentPack.end());
3878  ArgumentPack.clear();
3879  }
3880 
3881  while (ArgIdx < NumArgs) {
3882  Converted.push_back(NewArgs[ArgIdx].getArgument());
3883  ++ArgIdx;
3884  }
3885 
3886  return false;
3887  }
3888 
3889  continue;
3890  }
3891 
3892  // If we're checking a partial template argument list, we're done.
3893  if (PartialTemplateArgs) {
3894  if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
3895  Converted.push_back(
3896  TemplateArgument::CreatePackCopy(Context, ArgumentPack));
3897 
3898  return false;
3899  }
3900 
3901  // If we have a template parameter pack with no more corresponding
3902  // arguments, just break out now and we'll fill in the argument pack below.
3903  if ((*Param)->isTemplateParameterPack()) {
3904  assert(!getExpandedPackSize(*Param) &&
3905  "Should have dealt with this already");
3906 
3907  // A non-expanded parameter pack before the end of the parameter list
3908  // only occurs for an ill-formed template parameter list, unless we've
3909  // got a partial argument list for a function template, so just bail out.
3910  if (Param + 1 != ParamEnd)
3911  return true;
3912 
3913  Converted.push_back(
3914  TemplateArgument::CreatePackCopy(Context, ArgumentPack));
3915  ArgumentPack.clear();
3916 
3917  ++Param;
3918  continue;
3919  }
3920 
3921  // Check whether we have a default argument.
3922  TemplateArgumentLoc Arg;
3923 
3924  // Retrieve the default template argument from the template
3925  // parameter. For each kind of template parameter, we substitute the
3926  // template arguments provided thus far and any "outer" template arguments
3927  // (when the template parameter was part of a nested template) into
3928  // the default argument.
3929  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
3930  if (!hasVisibleDefaultArgument(TTP))
3931  return diagnoseMissingArgument(*this, TemplateLoc, Template, TTP,
3932  NewArgs);
3933 
3935  Template,
3936  TemplateLoc,
3937  RAngleLoc,
3938  TTP,
3939  Converted);
3940  if (!ArgType)
3941  return true;
3942 
3943  Arg = TemplateArgumentLoc(TemplateArgument(ArgType->getType()),
3944  ArgType);
3945  } else if (NonTypeTemplateParmDecl *NTTP
3946  = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
3947  if (!hasVisibleDefaultArgument(NTTP))
3948  return diagnoseMissingArgument(*this, TemplateLoc, Template, NTTP,
3949  NewArgs);
3950 
3951  ExprResult E = SubstDefaultTemplateArgument(*this, Template,
3952  TemplateLoc,
3953  RAngleLoc,
3954  NTTP,
3955  Converted);
3956  if (E.isInvalid())
3957  return true;
3958 
3959  Expr *Ex = E.getAs<Expr>();
3960  Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex);
3961  } else {
3962  TemplateTemplateParmDecl *TempParm
3963  = cast<TemplateTemplateParmDecl>(*Param);
3964 
3965  if (!hasVisibleDefaultArgument(TempParm))
3966  return diagnoseMissingArgument(*this, TemplateLoc, Template, TempParm,
3967  NewArgs);
3968 
3969  NestedNameSpecifierLoc QualifierLoc;
3971  TemplateLoc,
3972  RAngleLoc,
3973  TempParm,
3974  Converted,
3975  QualifierLoc);
3976  if (Name.isNull())
3977  return true;
3978 
3979  Arg = TemplateArgumentLoc(TemplateArgument(Name), QualifierLoc,
3980  TempParm->getDefaultArgument().getTemplateNameLoc());
3981  }
3982 
3983  // Introduce an instantiation record that describes where we are using
3984  // the default template argument.
3985  InstantiatingTemplate Inst(*this, RAngleLoc, Template, *Param, Converted,
3986  SourceRange(TemplateLoc, RAngleLoc));
3987  if (Inst.isInvalid())
3988  return true;
3989 
3990  // Check the default template argument.
3991  if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc,
3992  RAngleLoc, 0, Converted))
3993  return true;
3994 
3995  // Core issue 150 (assumed resolution): if this is a template template
3996  // parameter, keep track of the default template arguments from the
3997  // template definition.
3998  if (isTemplateTemplateParameter)
3999  NewArgs.addArgument(Arg);
4000 
4001  // Move to the next template parameter and argument.
4002  ++Param;
4003  ++ArgIdx;
4004  }
4005 
4006  // If we're performing a partial argument substitution, allow any trailing
4007  // pack expansions; they might be empty. This can happen even if
4008  // PartialTemplateArgs is false (the list of arguments is complete but
4009  // still dependent).
4010  if (ArgIdx < NumArgs && CurrentInstantiationScope &&
4011  CurrentInstantiationScope->getPartiallySubstitutedPack()) {
4012  while (ArgIdx < NumArgs && NewArgs[ArgIdx].getArgument().isPackExpansion())
4013  Converted.push_back(NewArgs[ArgIdx++].getArgument());
4014  }
4015 
4016  // If we have any leftover arguments, then there were too many arguments.
4017  // Complain and fail.
4018  if (ArgIdx < NumArgs)
4019  return diagnoseArityMismatch(*this, Template, TemplateLoc, NewArgs);
4020 
4021  // No problems found with the new argument list, propagate changes back
4022  // to caller.
4023  TemplateArgs = std::move(NewArgs);
4024 
4025  return false;
4026 }
4027 
4028 namespace {
4029  class UnnamedLocalNoLinkageFinder
4030  : public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
4031  {
4032  Sema &S;
4033  SourceRange SR;
4034 
4036 
4037  public:
4038  UnnamedLocalNoLinkageFinder(Sema &S, SourceRange SR) : S(S), SR(SR) { }
4039 
4040  bool Visit(QualType T) {
4041  return inherited::Visit(T.getTypePtr());
4042  }
4043 
4044 #define TYPE(Class, Parent) \
4045  bool Visit##Class##Type(const Class##Type *);
4046 #define ABSTRACT_TYPE(Class, Parent) \
4047  bool Visit##Class##Type(const Class##Type *) { return false; }
4048 #define NON_CANONICAL_TYPE(Class, Parent) \
4049  bool Visit##Class##Type(const Class##Type *) { return false; }
4050 #include "clang/AST/TypeNodes.def"
4051 
4052  bool VisitTagDecl(const TagDecl *Tag);
4053  bool VisitNestedNameSpecifier(NestedNameSpecifier *NNS);
4054  };
4055 } // end anonymous namespace
4056 
4057 bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(const BuiltinType*) {
4058  return false;
4059 }
4060 
4061 bool UnnamedLocalNoLinkageFinder::VisitComplexType(const ComplexType* T) {
4062  return Visit(T->getElementType());
4063 }
4064 
4065 bool UnnamedLocalNoLinkageFinder::VisitPointerType(const PointerType* T) {
4066  return Visit(T->getPointeeType());
4067 }
4068 
4069 bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
4070  const BlockPointerType* T) {
4071  return Visit(T->getPointeeType());
4072 }
4073 
4074 bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
4075  const LValueReferenceType* T) {
4076  return Visit(T->getPointeeType());
4077 }
4078 
4079 bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
4080  const RValueReferenceType* T) {
4081  return Visit(T->getPointeeType());
4082 }
4083 
4084 bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
4085  const MemberPointerType* T) {
4086  return Visit(T->getPointeeType()) || Visit(QualType(T->getClass(), 0));
4087 }
4088 
4089 bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
4090  const ConstantArrayType* T) {
4091  return Visit(T->getElementType());
4092 }
4093 
4094 bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
4095  const IncompleteArrayType* T) {
4096  return Visit(T->getElementType());
4097 }
4098 
4099 bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
4100  const VariableArrayType* T) {
4101  return Visit(T->getElementType());
4102 }
4103 
4104 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
4105  const DependentSizedArrayType* T) {
4106  return Visit(T->getElementType());
4107 }
4108 
4109 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
4110  const DependentSizedExtVectorType* T) {
4111  return Visit(T->getElementType());
4112 }
4113 
4114 bool UnnamedLocalNoLinkageFinder::VisitVectorType(const VectorType* T) {
4115  return Visit(T->getElementType());
4116 }
4117 
4118 bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(const ExtVectorType* T) {
4119  return Visit(T->getElementType());
4120 }
4121 
4122 bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
4123  const FunctionProtoType* T) {
4124  for (const auto &A : T->param_types()) {
4125  if (Visit(A))
4126  return true;
4127  }
4128 
4129  return Visit(T->getReturnType());
4130 }
4131 
4132 bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
4133  const FunctionNoProtoType* T) {
4134  return Visit(T->getReturnType());
4135 }
4136 
4137 bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
4138  const UnresolvedUsingType*) {
4139  return false;
4140 }
4141 
4142 bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(const TypeOfExprType*) {
4143  return false;
4144 }
4145 
4146 bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(const TypeOfType* T) {
4147  return Visit(T->getUnderlyingType());
4148 }
4149 
4150 bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType*) {
4151  return false;
4152 }
4153 
4154 bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
4155  const UnaryTransformType*) {
4156  return false;
4157 }
4158 
4159 bool UnnamedLocalNoLinkageFinder::VisitAutoType(const AutoType *T) {
4160  return Visit(T->getDeducedType());
4161 }
4162 
4163 bool UnnamedLocalNoLinkageFinder::VisitRecordType(const RecordType* T) {
4164  return VisitTagDecl(T->getDecl());
4165 }
4166 
4167 bool UnnamedLocalNoLinkageFinder::VisitEnumType(const EnumType* T) {
4168  return VisitTagDecl(T->getDecl());
4169 }
4170 
4171 bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
4172  const TemplateTypeParmType*) {
4173  return false;
4174 }
4175 
4176 bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
4178  return false;
4179 }
4180 
4181 bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
4182  const TemplateSpecializationType*) {
4183  return false;
4184 }
4185 
4186 bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
4187  const InjectedClassNameType* T) {
4188  return VisitTagDecl(T->getDecl());
4189 }
4190 
4191 bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
4192  const DependentNameType* T) {
4193  return VisitNestedNameSpecifier(T->getQualifier());
4194 }
4195 
4196 bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
4198  return VisitNestedNameSpecifier(T->getQualifier());
4199 }
4200 
4201 bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
4202  const PackExpansionType* T) {
4203  return Visit(T->getPattern());
4204 }
4205 
4206 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType *) {
4207  return false;
4208 }
4209 
4210 bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
4211  const ObjCInterfaceType *) {
4212  return false;
4213 }
4214 
4215 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
4216  const ObjCObjectPointerType *) {
4217  return false;
4218 }
4219 
4220 bool UnnamedLocalNoLinkageFinder::VisitAtomicType(const AtomicType* T) {
4221  return Visit(T->getValueType());
4222 }
4223 
4224 bool UnnamedLocalNoLinkageFinder::VisitPipeType(const PipeType* T) {
4225  return false;
4226 }
4227 
4228 bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl *Tag) {
4229  if (Tag->getDeclContext()->isFunctionOrMethod()) {
4230  S.Diag(SR.getBegin(),
4231  S.getLangOpts().CPlusPlus11 ?
4232  diag::warn_cxx98_compat_template_arg_local_type :
4233  diag::ext_template_arg_local_type)
4234  << S.Context.getTypeDeclType(Tag) << SR;
4235  return true;
4236  }
4237 
4238  if (!Tag->hasNameForLinkage()) {
4239  S.Diag(SR.getBegin(),
4240  S.getLangOpts().CPlusPlus11 ?
4241  diag::warn_cxx98_compat_template_arg_unnamed_type :
4242  diag::ext_template_arg_unnamed_type) << SR;
4243  S.Diag(Tag->getLocation(), diag::note_template_unnamed_type_here);
4244  return true;
4245  }
4246 
4247  return false;
4248 }
4249 
4250 bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
4251  NestedNameSpecifier *NNS) {
4252  if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix()))
4253  return true;
4254 
4255  switch (NNS->getKind()) {
4261  return false;
4262 
4265  return Visit(QualType(NNS->getAsType(), 0));
4266  }
4267  llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
4268 }
4269 
4270 /// \brief Check a template argument against its corresponding
4271 /// template type parameter.
4272 ///
4273 /// This routine implements the semantics of C++ [temp.arg.type]. It
4274 /// returns true if an error occurred, and false otherwise.
4276  TypeSourceInfo *ArgInfo) {
4277  assert(ArgInfo && "invalid TypeSourceInfo");
4278  QualType Arg = ArgInfo->getType();
4279  SourceRange SR = ArgInfo->getTypeLoc().getSourceRange();
4280 
4281  if (Arg->isVariablyModifiedType()) {
4282  return Diag(SR.getBegin(), diag::err_variably_modified_template_arg) << Arg;
4283  } else if (Context.hasSameUnqualifiedType(Arg, Context.OverloadTy)) {
4284  return Diag(SR.getBegin(), diag::err_template_arg_overload_type) << SR;
4285  }
4286 
4287  // C++03 [temp.arg.type]p2:
4288  // A local type, a type with no linkage, an unnamed type or a type
4289  // compounded from any of these types shall not be used as a
4290  // template-argument for a template type-parameter.
4291  //
4292  // C++11 allows these, and even in C++03 we allow them as an extension with
4293  // a warning.
4294  bool NeedsCheck;
4295  if (LangOpts.CPlusPlus11)
4296  NeedsCheck =
4297  !Diags.isIgnored(diag::warn_cxx98_compat_template_arg_unnamed_type,
4298  SR.getBegin()) ||
4299  !Diags.isIgnored(diag::warn_cxx98_compat_template_arg_local_type,
4300  SR.getBegin());
4301  else
4302  NeedsCheck = Arg->hasUnnamedOrLocalType();
4303 
4304  if (NeedsCheck) {
4305  UnnamedLocalNoLinkageFinder Finder(*this, SR);
4306  (void)Finder.Visit(Context.getCanonicalType(Arg));
4307  }
4308 
4309  return false;
4310 }
4311 
4316 };
4317 
4318 /// \brief Determine whether the given template argument is a null pointer
4319 /// value of the appropriate type.
4320 static NullPointerValueKind
4322  QualType ParamType, Expr *Arg) {
4323  if (Arg->isValueDependent() || Arg->isTypeDependent())
4324  return NPV_NotNullPointer;
4325 
4326  if (!S.isCompleteType(Arg->getExprLoc(), ParamType))
4327  llvm_unreachable(
4328  "Incomplete parameter type in isNullPointerValueTemplateArgument!");
4329 
4330  if (!S.getLangOpts().CPlusPlus11)
4331  return NPV_NotNullPointer;
4332 
4333  // Determine whether we have a constant expression.
4335  if (ArgRV.isInvalid())
4336  return NPV_Error;
4337  Arg = ArgRV.get();
4338 
4339  Expr::EvalResult EvalResult;
4341  EvalResult.Diag = &Notes;
4342  if (!Arg->EvaluateAsRValue(EvalResult, S.Context) ||
4343  EvalResult.HasSideEffects) {
4344  SourceLocation DiagLoc = Arg->getExprLoc();
4345 
4346  // If our only note is the usual "invalid subexpression" note, just point
4347  // the caret at its location rather than producing an essentially
4348  // redundant note.
4349  if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
4350  diag::note_invalid_subexpr_in_const_expr) {
4351  DiagLoc = Notes[0].first;
4352  Notes.clear();
4353  }
4354 
4355  S.Diag(DiagLoc, diag::err_template_arg_not_address_constant)
4356  << Arg->getType() << Arg->getSourceRange();
4357  for (unsigned I = 0, N = Notes.size(); I != N; ++I)
4358  S.Diag(Notes[I].first, Notes[I].second);
4359 
4360  S.Diag(Param->getLocation(), diag::note_template_param_here);
4361  return NPV_Error;
4362  }
4363 
4364  // C++11 [temp.arg.nontype]p1:
4365  // - an address constant expression of type std::nullptr_t
4366  if (Arg->getType()->isNullPtrType())
4367  return NPV_NullPointer;
4368 
4369  // - a constant expression that evaluates to a null pointer value (4.10); or
4370  // - a constant expression that evaluates to a null member pointer value
4371  // (4.11); or
4372  if ((EvalResult.Val.isLValue() && !EvalResult.Val.getLValueBase()) ||
4373  (EvalResult.Val.isMemberPointer() &&
4374  !EvalResult.Val.getMemberPointerDecl())) {
4375  // If our expression has an appropriate type, we've succeeded.
4376  bool ObjCLifetimeConversion;
4377  if (S.Context.hasSameUnqualifiedType(Arg->getType(), ParamType) ||
4378  S.IsQualificationConversion(Arg->getType(), ParamType, false,
4379  ObjCLifetimeConversion))
4380  return NPV_NullPointer;
4381 
4382  // The types didn't match, but we know we got a null pointer; complain,
4383  // then recover as if the types were correct.
4384  S.Diag(Arg->getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
4385  << Arg->getType() << ParamType << Arg->getSourceRange();
4386  S.Diag(Param->getLocation(), diag::note_template_param_here);
4387  return NPV_NullPointer;
4388  }
4389 
4390  // If we don't have a null pointer value, but we do have a NULL pointer
4391  // constant, suggest a cast to the appropriate type.
4393  std::string Code = "static_cast<" + ParamType.getAsString() + ">(";
4394  S.Diag(Arg->getExprLoc(), diag::err_template_arg_untyped_null_constant)
4395  << ParamType << FixItHint::CreateInsertion(Arg->getLocStart(), Code)
4396  << FixItHint::CreateInsertion(S.getLocForEndOfToken(Arg->getLocEnd()),
4397  ")");
4398  S.Diag(Param->getLocation(), diag::note_template_param_here);
4399  return NPV_NullPointer;
4400  }
4401 
4402  // FIXME: If we ever want to support general, address-constant expressions
4403  // as non-type template arguments, we should return the ExprResult here to
4404  // be interpreted by the caller.
4405  return NPV_NotNullPointer;
4406 }
4407 
4408 /// \brief Checks whether the given template argument is compatible with its
4409 /// template parameter.
4411  Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
4412  Expr *Arg, QualType ArgType) {
4413  bool ObjCLifetimeConversion;
4414  if (ParamType->isPointerType() &&
4415  !ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType() &&
4416  S.IsQualificationConversion(ArgType, ParamType, false,
4417  ObjCLifetimeConversion)) {
4418  // For pointer-to-object types, qualification conversions are
4419  // permitted.
4420  } else {
4421  if (const ReferenceType *ParamRef = ParamType->getAs<ReferenceType>()) {
4422  if (!ParamRef->getPointeeType()->isFunctionType()) {
4423  // C++ [temp.arg.nontype]p5b3:
4424  // For a non-type template-parameter of type reference to
4425  // object, no conversions apply. The type referred to by the
4426  // reference may be more cv-qualified than the (otherwise
4427  // identical) type of the template- argument. The
4428  // template-parameter is bound directly to the
4429  // template-argument, which shall be an lvalue.
4430 
4431  // FIXME: Other qualifiers?
4432  unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
4433  unsigned ArgQuals = ArgType.getCVRQualifiers();
4434 
4435  if ((ParamQuals | ArgQuals) != ParamQuals) {
4436  S.Diag(Arg->getLocStart(),
4437  diag::err_template_arg_ref_bind_ignores_quals)
4438  << ParamType << Arg->getType() << Arg->getSourceRange();
4439  S.Diag(Param->getLocation(), diag::note_template_param_here);
4440  return true;
4441  }
4442  }
4443  }
4444 
4445  // At this point, the template argument refers to an object or
4446  // function with external linkage. We now need to check whether the
4447  // argument and parameter types are compatible.
4448  if (!S.Context.hasSameUnqualifiedType(ArgType,
4449  ParamType.getNonReferenceType())) {
4450  // We can't perform this conversion or binding.
4451  if (ParamType->isReferenceType())
4452  S.Diag(Arg->getLocStart(), diag::err_template_arg_no_ref_bind)
4453  << ParamType << ArgIn->getType() << Arg->getSourceRange();
4454  else
4455  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_convertible)
4456  << ArgIn->getType() << ParamType << Arg->getSourceRange();
4457  S.Diag(Param->getLocation(), diag::note_template_param_here);
4458  return true;
4459  }
4460  }
4461 
4462  return false;
4463 }
4464 
4465 /// \brief Checks whether the given template argument is the address
4466 /// of an object or function according to C++ [temp.arg.nontype]p1.
4467 static bool
4469  NonTypeTemplateParmDecl *Param,
4470  QualType ParamType,
4471  Expr *ArgIn,
4472  TemplateArgument &Converted) {
4473  bool Invalid = false;
4474  Expr *Arg = ArgIn;
4475  QualType ArgType = Arg->getType();
4476 
4477  bool AddressTaken = false;
4478  SourceLocation AddrOpLoc;
4479  if (S.getLangOpts().MicrosoftExt) {
4480  // Microsoft Visual C++ strips all casts, allows an arbitrary number of
4481  // dereference and address-of operators.
4482  Arg = Arg->IgnoreParenCasts();
4483 
4484  bool ExtWarnMSTemplateArg = false;
4485  UnaryOperatorKind FirstOpKind;
4486  SourceLocation FirstOpLoc;
4487  while (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
4488  UnaryOperatorKind UnOpKind = UnOp->getOpcode();
4489  if (UnOpKind == UO_Deref)
4490  ExtWarnMSTemplateArg = true;
4491  if (UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {
4492  Arg = UnOp->getSubExpr()->IgnoreParenCasts();
4493  if (!AddrOpLoc.isValid()) {
4494  FirstOpKind = UnOpKind;
4495  FirstOpLoc = UnOp->getOperatorLoc();
4496  }
4497  } else
4498  break;
4499  }
4500  if (FirstOpLoc.isValid()) {
4501  if (ExtWarnMSTemplateArg)
4502  S.Diag(ArgIn->getLocStart(), diag::ext_ms_deref_template_argument)
4503  << ArgIn->getSourceRange();
4504 
4505  if (FirstOpKind == UO_AddrOf)
4506  AddressTaken = true;
4507  else if (Arg->getType()->isPointerType()) {
4508  // We cannot let pointers get dereferenced here, that is obviously not a
4509  // constant expression.
4510  assert(FirstOpKind == UO_Deref);
4511  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
4512  << Arg->getSourceRange();
4513  }
4514  }
4515  } else {
4516  // See through any implicit casts we added to fix the type.
4517  Arg = Arg->IgnoreImpCasts();
4518 
4519  // C++ [temp.arg.nontype]p1:
4520  //
4521  // A template-argument for a non-type, non-template
4522  // template-parameter shall be one of: [...]
4523  //
4524  // -- the address of an object or function with external
4525  // linkage, including function templates and function
4526  // template-ids but excluding non-static class members,
4527  // expressed as & id-expression where the & is optional if
4528  // the name refers to a function or array, or if the
4529  // corresponding template-parameter is a reference; or
4530 
4531  // In C++98/03 mode, give an extension warning on any extra parentheses.
4532  // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
4533  bool ExtraParens = false;
4534  while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
4535  if (!Invalid && !ExtraParens) {
4536  S.Diag(Arg->getLocStart(),
4537  S.getLangOpts().CPlusPlus11
4538  ? diag::warn_cxx98_compat_template_arg_extra_parens
4539  : diag::ext_template_arg_extra_parens)
4540  << Arg->getSourceRange();
4541  ExtraParens = true;
4542  }
4543 
4544  Arg = Parens->getSubExpr();
4545  }
4546 
4547  while (SubstNonTypeTemplateParmExpr *subst =
4548  dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
4549  Arg = subst->getReplacement()->IgnoreImpCasts();
4550 
4551  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
4552  if (UnOp->getOpcode() == UO_AddrOf) {
4553  Arg = UnOp->getSubExpr();
4554  AddressTaken = true;
4555  AddrOpLoc = UnOp->getOperatorLoc();
4556  }
4557  }
4558 
4559  while (SubstNonTypeTemplateParmExpr *subst =
4560  dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
4561  Arg = subst->getReplacement()->IgnoreImpCasts();
4562  }
4563 
4564  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg);
4565  ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;
4566 
4567  // If our parameter has pointer type, check for a null template value.
4568  if (ParamType->isPointerType() || ParamType->isNullPtrType()) {
4570  // dllimport'd entities aren't constant but are available inside of template
4571  // arguments.
4572  if (Entity && Entity->hasAttr<DLLImportAttr>())
4573  NPV = NPV_NotNullPointer;
4574  else
4575  NPV = isNullPointerValueTemplateArgument(S, Param, ParamType, ArgIn);
4576  switch (NPV) {
4577  case NPV_NullPointer:
4578  S.Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
4579  Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
4580  /*isNullPtr=*/true);
4581  return false;
4582 
4583  case NPV_Error:
4584  return true;
4585 
4586  case NPV_NotNullPointer:
4587  break;
4588  }
4589  }
4590 
4591  // Stop checking the precise nature of the argument if it is value dependent,
4592  // it should be checked when instantiated.
4593  if (Arg->isValueDependent()) {
4594  Converted = TemplateArgument(ArgIn);
4595  return false;
4596  }
4597 
4598  if (isa<CXXUuidofExpr>(Arg)) {
4599  if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType,
4600  ArgIn, Arg, ArgType))
4601  return true;
4602 
4603  Converted = TemplateArgument(ArgIn);
4604  return false;
4605  }
4606 
4607  if (!DRE) {
4608  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
4609  << Arg->getSourceRange();
4610  S.Diag(Param->getLocation(), diag::note_template_param_here);
4611  return true;
4612  }
4613 
4614  // Cannot refer to non-static data members
4615  if (isa<FieldDecl>(Entity) || isa<IndirectFieldDecl>(Entity)) {
4616  S.Diag(Arg->getLocStart(), diag::err_template_arg_field)
4617  << Entity << Arg->getSourceRange();
4618  S.Diag(Param->getLocation(), diag::note_template_param_here);
4619  return true;
4620  }
4621 
4622  // Cannot refer to non-static member functions
4623  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) {
4624  if (!Method->isStatic()) {
4625  S.Diag(Arg->getLocStart(), diag::err_template_arg_method)
4626  << Method << Arg->getSourceRange();
4627  S.Diag(Param->getLocation(), diag::note_template_param_here);
4628  return true;
4629  }
4630  }
4631 
4632  FunctionDecl *Func = dyn_cast<FunctionDecl>(Entity);
4633  VarDecl *Var = dyn_cast<VarDecl>(Entity);
4634 
4635  // A non-type template argument must refer to an object or function.
4636  if (!Func && !Var) {
4637  // We found something, but we don't know specifically what it is.
4638  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_object_or_func)
4639  << Arg->getSourceRange();
4640  S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
4641  return true;
4642  }
4643 
4644  // Address / reference template args must have external linkage in C++98.
4645  if (Entity->getFormalLinkage() == InternalLinkage) {
4646  S.Diag(Arg->getLocStart(), S.getLangOpts().CPlusPlus11 ?
4647  diag::warn_cxx98_compat_template_arg_object_internal :
4648  diag::ext_template_arg_object_internal)
4649  << !Func << Entity << Arg->getSourceRange();
4650  S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
4651  << !Func;
4652  } else if (!Entity->hasLinkage()) {
4653  S.Diag(Arg->getLocStart(), diag::err_template_arg_object_no_linkage)
4654  << !Func << Entity << Arg->getSourceRange();
4655  S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
4656  << !Func;
4657  return true;
4658  }
4659 
4660  if (Func) {
4661  // If the template parameter has pointer type, the function decays.
4662  if (ParamType->isPointerType() && !AddressTaken)
4663  ArgType = S.Context.getPointerType(Func->getType());
4664  else if (AddressTaken && ParamType->isReferenceType()) {
4665  // If we originally had an address-of operator, but the
4666  // parameter has reference type, complain and (if things look
4667  // like they will work) drop the address-of operator.
4668  if (!S.Context.hasSameUnqualifiedType(Func->getType(),
4669  ParamType.getNonReferenceType())) {
4670  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
4671  << ParamType;
4672  S.Diag(Param->getLocation(), diag::note_template_param_here);
4673  return true;
4674  }
4675 
4676  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
4677  << ParamType
4678  << FixItHint::CreateRemoval(AddrOpLoc);
4679  S.Diag(Param->getLocation(), diag::note_template_param_here);
4680 
4681  ArgType = Func->getType();
4682  }
4683  } else {
4684  // A value of reference type is not an object.
4685  if (Var->getType()->isReferenceType()) {
4686  S.Diag(Arg->getLocStart(),
4687  diag::err_template_arg_reference_var)
4688  << Var->getType() << Arg->getSourceRange();
4689  S.Diag(Param->getLocation(), diag::note_template_param_here);
4690  return true;
4691  }
4692 
4693  // A template argument must have static storage duration.
4694  if (Var->getTLSKind()) {
4695  S.Diag(Arg->getLocStart(), diag::err_template_arg_thread_local)
4696  << Arg->getSourceRange();
4697  S.Diag(Var->getLocation(), diag::note_template_arg_refers_here);
4698  return true;
4699  }
4700 
4701  // If the template parameter has pointer type, we must have taken
4702  // the address of this object.
4703  if (ParamType->isReferenceType()) {
4704  if (AddressTaken) {
4705  // If we originally had an address-of operator, but the
4706  // parameter has reference type, complain and (if things look
4707  // like they will work) drop the address-of operator.
4708  if (!S.Context.hasSameUnqualifiedType(Var->getType(),
4709  ParamType.getNonReferenceType())) {
4710  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
4711  << ParamType;
4712  S.Diag(Param->getLocation(), diag::note_template_param_here);
4713  return true;
4714  }
4715 
4716  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
4717  << ParamType
4718  << FixItHint::CreateRemoval(AddrOpLoc);
4719  S.Diag(Param->getLocation(), diag::note_template_param_here);
4720 
4721  ArgType = Var->getType();
4722  }
4723  } else if (!AddressTaken && ParamType->isPointerType()) {
4724  if (Var->getType()->isArrayType()) {
4725  // Array-to-pointer decay.
4726  ArgType = S.Context.getArrayDecayedType(Var->getType());
4727  } else {
4728  // If the template parameter has pointer type but the address of
4729  // this object was not taken, complain and (possibly) recover by
4730  // taking the address of the entity.
4731  ArgType = S.Context.getPointerType(Var->getType());
4732  if (!S.Context.hasSameUnqualifiedType(ArgType, ParamType)) {
4733  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
4734  << ParamType;
4735  S.Diag(Param->getLocation(), diag::note_template_param_here);
4736  return true;
4737  }
4738 
4739  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
4740  << ParamType
4741  << FixItHint::CreateInsertion(Arg->getLocStart(), "&");
4742 
4743  S.Diag(Param->getLocation(), diag::note_template_param_here);
4744  }
4745  }
4746  }
4747 
4748  if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType, ArgIn,
4749  Arg, ArgType))
4750  return true;
4751 
4752  // Create the template argument.
4753  Converted =
4754  TemplateArgument(cast<ValueDecl>(Entity->getCanonicalDecl()), ParamType);
4755  S.MarkAnyDeclReferenced(Arg->getLocStart(), Entity, false);
4756  return false;
4757 }
4758 
4759 /// \brief Checks whether the given template argument is a pointer to
4760 /// member constant according to C++ [temp.arg.nontype]p1.
4762  NonTypeTemplateParmDecl *Param,
4763  QualType ParamType,
4764  Expr *&ResultArg,
4765  TemplateArgument &Converted) {
4766  bool Invalid = false;
4767 
4768  // Check for a null pointer value.
4769  Expr *Arg = ResultArg;
4770  switch (isNullPointerValueTemplateArgument(S, Param, ParamType, Arg)) {
4771  case NPV_Error:
4772  return true;
4773  case NPV_NullPointer:
4774  S.Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
4775  Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
4776  /*isNullPtr*/true);
4777  return false;
4778  case NPV_NotNullPointer:
4779  break;
4780  }
4781 
4782  bool ObjCLifetimeConversion;
4783  if (S.IsQualificationConversion(Arg->getType(),
4784  ParamType.getNonReferenceType(),
4785  false, ObjCLifetimeConversion)) {
4786  Arg = S.ImpCastExprToType(Arg, ParamType, CK_NoOp,
4787  Arg->getValueKind()).get();
4788  ResultArg = Arg;
4789  } else if (!S.Context.hasSameUnqualifiedType(Arg->getType(),
4790  ParamType.getNonReferenceType())) {
4791  // We can't perform this conversion.
4792  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_convertible)
4793  << Arg->getType() << ParamType << Arg->getSourceRange();
4794  S.Diag(Param->getLocation(), diag::note_template_param_here);
4795  return true;
4796  }
4797 
4798  // See through any implicit casts we added to fix the type.
4799  while (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(Arg))
4800  Arg = Cast->getSubExpr();
4801 
4802  // C++ [temp.arg.nontype]p1:
4803  //
4804  // A template-argument for a non-type, non-template
4805  // template-parameter shall be one of: [...]
4806  //
4807  // -- a pointer to member expressed as described in 5.3.1.
4808  DeclRefExpr *DRE = nullptr;
4809 
4810  // In C++98/03 mode, give an extension warning on any extra parentheses.
4811  // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
4812  bool ExtraParens = false;
4813  while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
4814  if (!Invalid && !ExtraParens) {
4815  S.Diag(Arg->getLocStart(),
4816  S.getLangOpts().CPlusPlus11 ?
4817  diag::warn_cxx98_compat_template_arg_extra_parens :
4818  diag::ext_template_arg_extra_parens)
4819  << Arg->getSourceRange();
4820  ExtraParens = true;
4821  }
4822 
4823  Arg = Parens->getSubExpr();
4824  }
4825 
4826  while (SubstNonTypeTemplateParmExpr *subst =
4827  dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
4828  Arg = subst->getReplacement()->IgnoreImpCasts();
4829 
4830  // A pointer-to-member constant written &Class::member.
4831  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
4832  if (UnOp->getOpcode() == UO_AddrOf) {
4833  DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
4834  if (DRE && !DRE->getQualifier())
4835  DRE = nullptr;
4836  }
4837  }
4838  // A constant of pointer-to-member type.
4839  else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
4840  if (ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl())) {
4841  if (VD->getType()->isMemberPointerType()) {
4842  if (isa<NonTypeTemplateParmDecl>(VD)) {
4843  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
4844  Converted = TemplateArgument(Arg);
4845  } else {
4846  VD = cast<ValueDecl>(VD->getCanonicalDecl());
4847  Converted = TemplateArgument(VD, ParamType);
4848  }
4849  return Invalid;
4850  }
4851  }
4852  }
4853 
4854  DRE = nullptr;
4855  }
4856 
4857  if (!DRE)
4858  return S.Diag(Arg->getLocStart(),
4859  diag::err_template_arg_not_pointer_to_member_form)
4860  << Arg->getSourceRange();
4861 
4862  if (isa<FieldDecl>(DRE->getDecl()) ||
4863  isa<IndirectFieldDecl>(DRE->getDecl()) ||
4864  isa<CXXMethodDecl>(DRE->getDecl())) {
4865  assert((isa<FieldDecl>(DRE->getDecl()) ||
4866  isa<IndirectFieldDecl>(DRE->getDecl()) ||
4867  !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&
4868  "Only non-static member pointers can make it here");
4869 
4870  // Okay: this is the address of a non-static member, and therefore
4871  // a member pointer constant.
4872  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
4873  Converted = TemplateArgument(Arg);
4874  } else {
4875  ValueDecl *D = cast<ValueDecl>(DRE->getDecl()->getCanonicalDecl());
4876  Converted = TemplateArgument(D, ParamType);
4877  }
4878  return Invalid;
4879  }
4880 
4881  // We found something else, but we don't know specifically what it is.
4882  S.Diag(Arg->getLocStart(),
4883  diag::err_template_arg_not_pointer_to_member_form)
4884  << Arg->getSourceRange();
4885  S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
4886  return true;
4887 }
4888 
4889 /// \brief Check a template argument against its corresponding
4890 /// non-type template parameter.
4891 ///
4892 /// This routine implements the semantics of C++ [temp.arg.nontype].
4893 /// If an error occurred, it returns ExprError(); otherwise, it
4894 /// returns the converted template argument. \p ParamType is the
4895 /// type of the non-type template parameter after it has been instantiated.
4897  QualType ParamType, Expr *Arg,
4898  TemplateArgument &Converted,
4900  SourceLocation StartLoc = Arg->getLocStart();
4901 
4902  // If either the parameter has a dependent type or the argument is
4903  // type-dependent, there's nothing we can check now.
4904  if (ParamType->isDependentType() || Arg->isTypeDependent()) {
4905  // FIXME: Produce a cloned, canonical expression?
4906  Converted = TemplateArgument(Arg);
4907  return Arg;
4908  }
4909 
4910  // We should have already dropped all cv-qualifiers by now.
4911  assert(!ParamType.hasQualifiers() &&
4912  "non-type template parameter type cannot be qualified");
4913 
4914  if (CTAK == CTAK_Deduced &&
4915  !Context.hasSameUnqualifiedType(ParamType, Arg->getType())) {
4916  // C++ [temp.deduct.type]p17:
4917  // If, in the declaration of a function template with a non-type
4918  // template-parameter, the non-type template-parameter is used
4919  // in an expression in the function parameter-list and, if the
4920  // corresponding template-argument is deduced, the
4921  // template-argument type shall match the type of the
4922  // template-parameter exactly, except that a template-argument
4923  // deduced from an array bound may be of any integral type.
4924  Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
4925  << Arg->getType().getUnqualifiedType()
4926  << ParamType.getUnqualifiedType();
4927  Diag(Param->getLocation(), diag::note_template_param_here);
4928  return ExprError();
4929  }
4930 
4931  if (getLangOpts().CPlusPlus1z) {
4932  // FIXME: We can do some limited checking for a value-dependent but not
4933  // type-dependent argument.
4934  if (Arg->isValueDependent()) {
4935  Converted = TemplateArgument(Arg);
4936  return Arg;
4937  }
4938 
4939  // C++1z [temp.arg.nontype]p1:
4940  // A template-argument for a non-type template parameter shall be
4941  // a converted constant expression of the type of the template-parameter.
4942  APValue Value;
4944  Arg, ParamType, Value, CCEK_TemplateArg);
4945  if (ArgResult.isInvalid())
4946  return ExprError();
4947 
4948  QualType CanonParamType = Context.getCanonicalType(ParamType);
4949 
4950  // Convert the APValue to a TemplateArgument.
4951  switch (Value.getKind()) {
4953  assert(ParamType->isNullPtrType());
4954  Converted = TemplateArgument(CanonParamType, /*isNullPtr*/true);
4955  break;
4956  case APValue::Int:
4957  assert(ParamType->isIntegralOrEnumerationType());
4958  Converted = TemplateArgument(Context, Value.getInt(), CanonParamType);
4959  break;
4960  case APValue::MemberPointer: {
4961  assert(ParamType->isMemberPointerType());
4962 
4963  // FIXME: We need TemplateArgument representation and mangling for these.
4964  if (!Value.getMemberPointerPath().empty()) {
4965  Diag(Arg->getLocStart(),
4966  diag::err_template_arg_member_ptr_base_derived_not_supported)
4967  << Value.getMemberPointerDecl() << ParamType
4968  << Arg->getSourceRange();
4969  return ExprError();
4970  }
4971 
4972  auto *VD = const_cast<ValueDecl*>(Value.getMemberPointerDecl());
4973  Converted = VD ? TemplateArgument(VD, CanonParamType)
4974  : TemplateArgument(CanonParamType, /*isNullPtr*/true);
4975  break;
4976  }
4977  case APValue::LValue: {
4978  // For a non-type template-parameter of pointer or reference type,
4979  // the value of the constant expression shall not refer to
4980  assert(ParamType->isPointerType() || ParamType->isReferenceType() ||
4981  ParamType->isNullPtrType());
4982  // -- a temporary object
4983  // -- a string literal
4984  // -- the result of a typeid expression, or
4985  // -- a predefind __func__ variable
4986  if (auto *E = Value.getLValueBase().dyn_cast<const Expr*>()) {
4987  if (isa<CXXUuidofExpr>(E)) {
4988  Converted = TemplateArgument(const_cast<Expr*>(E));
4989  break;
4990  }
4991  Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
4992  << Arg->getSourceRange();
4993  return ExprError();
4994  }
4995  auto *VD = const_cast<ValueDecl *>(
4996  Value.getLValueBase().dyn_cast<const ValueDecl *>());
4997  // -- a subobject
4998  if (Value.hasLValuePath() && Value.getLValuePath().size() == 1 &&
4999  VD && VD->getType()->isArrayType() &&
5000  Value.getLValuePath()[0].ArrayIndex == 0 &&
5001  !Value.isLValueOnePastTheEnd() && ParamType->isPointerType()) {
5002  // Per defect report (no number yet):
5003  // ... other than a pointer to the first element of a complete array
5004  // object.
5005  } else if (!Value.hasLValuePath() || Value.getLValuePath().size() ||
5006  Value.isLValueOnePastTheEnd()) {
5007  Diag(StartLoc, diag::err_non_type_template_arg_subobject)
5008  << Value.getAsString(Context, ParamType);
5009  return ExprError();
5010  }
5011  assert((VD || !ParamType->isReferenceType()) &&
5012  "null reference should not be a constant expression");
5013  assert((!VD || !ParamType->isNullPtrType()) &&
5014  "non-null value of type nullptr_t?");
5015  Converted = VD ? TemplateArgument(VD, CanonParamType)
5016  : TemplateArgument(CanonParamType, /*isNullPtr*/true);
5017  break;
5018  }
5020  return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
5021  case APValue::Float:
5022  case APValue::ComplexInt:
5023  case APValue::ComplexFloat:
5024  case APValue::Vector:
5025  case APValue::Array:
5026  case APValue::Struct:
5027  case APValue::Union:
5028  llvm_unreachable("invalid kind for template argument");
5029  }
5030 
5031  return ArgResult.get();
5032  }
5033 
5034  // C++ [temp.arg.nontype]p5:
5035  // The following conversions are performed on each expression used
5036  // as a non-type template-argument. If a non-type
5037  // template-argument cannot be converted to the type of the
5038  // corresponding template-parameter then the program is
5039  // ill-formed.
5040  if (ParamType->isIntegralOrEnumerationType()) {
5041  // C++11:
5042  // -- for a non-type template-parameter of integral or
5043  // enumeration type, conversions permitted in a converted
5044  // constant expression are applied.
5045  //
5046  // C++98:
5047  // -- for a non-type template-parameter of integral or
5048  // enumeration type, integral promotions (4.5) and integral
5049  // conversions (4.7) are applied.
5050 
5051  if (getLangOpts().CPlusPlus11) {
5052  // We can't check arbitrary value-dependent arguments.
5053  // FIXME: If there's no viable conversion to the template parameter type,
5054  // we should be able to diagnose that prior to instantiation.
5055  if (Arg->isValueDependent()) {
5056  Converted = TemplateArgument(Arg);
5057  return Arg;
5058  }
5059 
5060  // C++ [temp.arg.nontype]p1:
5061  // A template-argument for a non-type, non-template template-parameter
5062  // shall be one of:
5063  //
5064  // -- for a non-type template-parameter of integral or enumeration
5065  // type, a converted constant expression of the type of the
5066  // template-parameter; or
5067  llvm::APSInt Value;
5068  ExprResult ArgResult =
5069  CheckConvertedConstantExpression(Arg, ParamType, Value,
5070  CCEK_TemplateArg);
5071  if (ArgResult.isInvalid())
5072  return ExprError();
5073 
5074  // Widen the argument value to sizeof(parameter type). This is almost
5075  // always a no-op, except when the parameter type is bool. In
5076  // that case, this may extend the argument from 1 bit to 8 bits.
5077  QualType IntegerType = ParamType;
5078  if (const EnumType *Enum = IntegerType->getAs<EnumType>())
5079  IntegerType = Enum->getDecl()->getIntegerType();
5080  Value = Value.extOrTrunc(Context.getTypeSize(IntegerType));
5081 
5082  Converted = TemplateArgument(Context, Value,
5083  Context.getCanonicalType(ParamType));
5084  return ArgResult;
5085  }
5086 
5087  ExprResult ArgResult = DefaultLvalueConversion(Arg);
5088  if (ArgResult.isInvalid())
5089  return ExprError();
5090  Arg = ArgResult.get();
5091 
5092  QualType ArgType = Arg->getType();
5093 
5094  // C++ [temp.arg.nontype]p1:
5095  // A template-argument for a non-type, non-template
5096  // template-parameter shall be one of:
5097  //
5098  // -- an integral constant-expression of integral or enumeration
5099  // type; or
5100  // -- the name of a non-type template-parameter; or
5101  SourceLocation NonConstantLoc;
5102  llvm::APSInt Value;
5103  if (!ArgType->isIntegralOrEnumerationType()) {
5104  Diag(Arg->getLocStart(),
5105  diag::err_template_arg_not_integral_or_enumeral)
5106  << ArgType << Arg->getSourceRange();
5107  Diag(Param->getLocation(), diag::note_template_param_here);
5108  return ExprError();
5109  } else if (!Arg->isValueDependent()) {
5110  class TmplArgICEDiagnoser : public VerifyICEDiagnoser {
5111  QualType T;
5112 
5113  public:
5114  TmplArgICEDiagnoser(QualType T) : T(T) { }
5115 
5116  void diagnoseNotICE(Sema &S, SourceLocation Loc,
5117  SourceRange SR) override {
5118  S.Diag(Loc, diag::err_template_arg_not_ice) << T << SR;
5119  }
5120  } Diagnoser(ArgType);
5121 
5122  Arg = VerifyIntegerConstantExpression(Arg, &Value, Diagnoser,
5123  false).get();
5124  if (!Arg)
5125  return ExprError();
5126  }
5127 
5128  // From here on out, all we care about is the unqualified form
5129  // of the argument type.
5130  ArgType = ArgType.getUnqualifiedType();
5131 
5132  // Try to convert the argument to the parameter's type.
5133  if (Context.hasSameType(ParamType, ArgType)) {
5134  // Okay: no conversion necessary
5135  } else if (ParamType->isBooleanType()) {
5136  // This is an integral-to-boolean conversion.
5137  Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralToBoolean).get();
5138  } else if (IsIntegralPromotion(Arg, ArgType, ParamType) ||
5139  !ParamType->isEnumeralType()) {
5140  // This is an integral promotion or conversion.
5141  Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralCast).get();
5142  } else {
5143  // We can't perform this conversion.
5144  Diag(Arg->getLocStart(),
5145  diag::err_template_arg_not_convertible)
5146  << Arg->getType() << ParamType << Arg->getSourceRange();
5147  Diag(Param->getLocation(), diag::note_template_param_here);
5148  return ExprError();
5149  }
5150 
5151  // Add the value of this argument to the list of converted
5152  // arguments. We use the bitwidth and signedness of the template
5153  // parameter.
5154  if (Arg->isValueDependent()) {
5155  // The argument is value-dependent. Create a new
5156  // TemplateArgument with the converted expression.
5157  Converted = TemplateArgument(Arg);
5158  return Arg;
5159  }
5160 
5161  QualType IntegerType = Context.getCanonicalType(ParamType);
5162  if (const EnumType *Enum = IntegerType->getAs<EnumType>())
5163  IntegerType = Context.getCanonicalType(Enum->getDecl()->getIntegerType());
5164 
5165  if (ParamType->isBooleanType()) {
5166  // Value must be zero or one.
5167  Value = Value != 0;
5168  unsigned AllowedBits = Context.getTypeSize(IntegerType);
5169  if (Value.getBitWidth() != AllowedBits)
5170  Value = Value.extOrTrunc(AllowedBits);
5171  Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
5172  } else {
5173  llvm::APSInt OldValue = Value;
5174 
5175  // Coerce the template argument's value to the value it will have
5176  // based on the template parameter's type.
5177  unsigned AllowedBits = Context.getTypeSize(IntegerType);
5178  if (Value.getBitWidth() != AllowedBits)
5179  Value = Value.extOrTrunc(AllowedBits);
5180  Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
5181 
5182  // Complain if an unsigned parameter received a negative value.
5183  if (IntegerType->isUnsignedIntegerOrEnumerationType()
5184  && (OldValue.isSigned() && OldValue.isNegative())) {
5185  Diag(Arg->getLocStart(), diag::warn_template_arg_negative)
5186  << OldValue.toString(10) << Value.toString(10) << Param->getType()
5187  << Arg->getSourceRange();
5188  Diag(Param->getLocation(), diag::note_template_param_here);
5189  }
5190 
5191  // Complain if we overflowed the template parameter's type.
5192  unsigned RequiredBits;
5193  if (IntegerType->isUnsignedIntegerOrEnumerationType())
5194  RequiredBits = OldValue.getActiveBits();
5195  else if (OldValue.isUnsigned())
5196  RequiredBits = OldValue.getActiveBits() + 1;
5197  else
5198  RequiredBits = OldValue.getMinSignedBits();
5199  if (RequiredBits > AllowedBits) {
5200  Diag(Arg->getLocStart(),
5201  diag::warn_template_arg_too_large)
5202  << OldValue.toString(10) << Value.toString(10) << Param->getType()
5203  << Arg->getSourceRange();
5204  Diag(Param->getLocation(), diag::note_template_param_here);
5205  }
5206  }
5207 
5208  Converted = TemplateArgument(Context, Value,
5209  ParamType->isEnumeralType()
5210  ? Context.getCanonicalType(ParamType)
5211  : IntegerType);
5212  return Arg;
5213  }
5214 
5215  QualType ArgType = Arg->getType();
5216  DeclAccessPair FoundResult; // temporary for ResolveOverloadedFunction
5217 
5218  // Handle pointer-to-function, reference-to-function, and
5219  // pointer-to-member-function all in (roughly) the same way.
5220  if (// -- For a non-type template-parameter of type pointer to
5221  // function, only the function-to-pointer conversion (4.3) is
5222  // applied. If the template-argument represents a set of
5223  // overloaded functions (or a pointer to such), the matching
5224  // function is selected from the set (13.4).
5225  (ParamType->isPointerType() &&
5226  ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType()) ||
5227  // -- For a non-type template-parameter of type reference to
5228  // function, no conversions apply. If the template-argument
5229  // represents a set of overloaded functions, the matching
5230  // function is selected from the set (13.4).
5231  (ParamType->isReferenceType() &&
5232  ParamType->getAs<ReferenceType>()->getPointeeType()->isFunctionType()) ||
5233  // -- For a non-type template-parameter of type pointer to
5234  // member function, no conversions apply. If the
5235  // template-argument represents a set of overloaded member
5236  // functions, the matching member function is selected from
5237  // the set (13.4).
5238  (ParamType->isMemberPointerType() &&
5239  ParamType->getAs<MemberPointerType>()->getPointeeType()
5240  ->isFunctionType())) {
5241 
5242  if (Arg->getType() == Context.OverloadTy) {
5243  if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType,
5244  true,
5245  FoundResult)) {
5246  if (DiagnoseUseOfDecl(Fn, Arg->getLocStart()))
5247  return ExprError();
5248 
5249  Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
5250  ArgType = Arg->getType();
5251  } else
5252  return ExprError();
5253  }
5254 
5255  if (!ParamType->isMemberPointerType()) {
5257  ParamType,
5258  Arg, Converted))
5259  return ExprError();
5260  return Arg;
5261  }
5262 
5263  if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
5264  Converted))
5265  return ExprError();
5266  return Arg;
5267  }
5268 
5269  if (ParamType->isPointerType()) {
5270  // -- for a non-type template-parameter of type pointer to
5271  // object, qualification conversions (4.4) and the
5272  // array-to-pointer conversion (4.2) are applied.
5273  // C++0x also allows a value of std::nullptr_t.
5274  assert(ParamType->getPointeeType()->isIncompleteOrObjectType() &&
5275  "Only object pointers allowed here");
5276 
5278  ParamType,
5279  Arg, Converted))
5280  return ExprError();
5281  return Arg;
5282  }
5283 
5284  if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
5285  // -- For a non-type template-parameter of type reference to
5286  // object, no conversions apply. The type referred to by the
5287  // reference may be more cv-qualified than the (otherwise
5288  // identical) type of the template-argument. The
5289  // template-parameter is bound directly to the
5290  // template-argument, which must be an lvalue.
5291  assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&
5292  "Only object references allowed here");
5293 
5294  if (Arg->getType() == Context.OverloadTy) {
5295  if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg,
5296  ParamRefType->getPointeeType(),
5297  true,
5298  FoundResult)) {
5299  if (DiagnoseUseOfDecl(Fn, Arg->getLocStart()))
5300  return ExprError();
5301 
5302  Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
5303  ArgType = Arg->getType();
5304  } else
5305  return ExprError();
5306  }
5307 
5309  ParamType,
5310  Arg, Converted))
5311  return ExprError();
5312  return Arg;
5313  }
5314 
5315  // Deal with parameters of type std::nullptr_t.
5316  if (ParamType->isNullPtrType()) {
5317  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
5318  Converted = TemplateArgument(Arg);
5319  return Arg;
5320  }
5321 
5322  switch (isNullPointerValueTemplateArgument(*this, Param, ParamType, Arg)) {
5323  case NPV_NotNullPointer:
5324  Diag(Arg->getExprLoc(), diag::err_template_arg_not_convertible)
5325  << Arg->getType() << ParamType;
5326  Diag(Param->getLocation(), diag::note_template_param_here);
5327  return ExprError();
5328 
5329  case NPV_Error:
5330  return ExprError();
5331 
5332  case NPV_NullPointer:
5333  Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
5334  Converted = TemplateArgument(Context.getCanonicalType(ParamType),
5335  /*isNullPtr*/true);
5336  return Arg;
5337  }
5338  }
5339 
5340  // -- For a non-type template-parameter of type pointer to data
5341  // member, qualification conversions (4.4) are applied.
5342  assert(ParamType->isMemberPointerType() && "Only pointers to members remain");
5343 
5344  if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
5345  Converted))
5346  return ExprError();
5347  return Arg;
5348 }
5349 
5350 /// \brief Check a template argument against its corresponding
5351 /// template template parameter.
5352 ///
5353 /// This routine implements the semantics of C++ [temp.arg.template].
5354 /// It returns true if an error occurred, and false otherwise.
5356  TemplateArgumentLoc &Arg,
5357  unsigned ArgumentPackIndex) {
5359  TemplateDecl *Template = Name.getAsTemplateDecl();
5360  if (!Template) {
5361  // Any dependent template name is fine.
5362  assert(Name.isDependent() && "Non-dependent template isn't a declaration?");
5363  return false;
5364  }
5365 
5366  // C++0x [temp.arg.template]p1:
5367  // A template-argument for a template template-parameter shall be
5368  // the name of a class template or an alias template, expressed as an
5369  // id-expression. When the template-argument names a class template, only
5370  // primary class templates are considered when matching the
5371  // template template argument with the corresponding parameter;
5372  // partial specializations are not considered even if their
5373  // parameter lists match that of the template template parameter.
5374  //
5375  // Note that we also allow template template parameters here, which
5376  // will happen when we are dealing with, e.g., class template
5377  // partial specializations.
5378  if (!isa<ClassTemplateDecl>(Template) &&
5379  !isa<TemplateTemplateParmDecl>(Template) &&
5380  !isa<TypeAliasTemplateDecl>(Template) &&
5381  !isa<BuiltinTemplateDecl>(Template)) {
5382  assert(isa<FunctionTemplateDecl>(Template) &&
5383  "Only function templates are possible here");
5384  Diag(Arg.getLocation(), diag::err_template_arg_not_valid_template);
5385  Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
5386  << Template;
5387  }
5388 
5389  TemplateParameterList *Params = Param->getTemplateParameters();
5390  if (Param->isExpandedParameterPack())
5391  Params = Param->getExpansionTemplateParameters(ArgumentPackIndex);
5392 
5393  return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),
5394  Params,
5395  true,
5396  TPL_TemplateTemplateArgumentMatch,
5397  Arg.getLocation());
5398 }
5399 
5400 /// \brief Given a non-type template argument that refers to a
5401 /// declaration and the type of its corresponding non-type template
5402 /// parameter, produce an expression that properly refers to that
5403 /// declaration.
5404 ExprResult
5406  QualType ParamType,
5407  SourceLocation Loc) {
5408  // C++ [temp.param]p8:
5409  //
5410  // A non-type template-parameter of type "array of T" or
5411  // "function returning T" is adjusted to be of type "pointer to
5412  // T" or "pointer to function returning T", respectively.
5413  if (ParamType->isArrayType())
5414  ParamType = Context.getArrayDecayedType(ParamType);
5415  else if (ParamType->isFunctionType())
5416  ParamType = Context.getPointerType(ParamType);
5417 
5418  // For a NULL non-type template argument, return nullptr casted to the
5419  // parameter's type.
5420  if (Arg.getKind() == TemplateArgument::NullPtr) {
5421  return ImpCastExprToType(
5423  ParamType,
5424  ParamType->getAs<MemberPointerType>()
5425  ? CK_NullToMemberPointer
5426  : CK_NullToPointer);
5427  }
5428  assert(Arg.getKind() == TemplateArgument::Declaration &&
5429  "Only declaration template arguments permitted here");
5430 
5431  ValueDecl *VD = cast<ValueDecl>(Arg.getAsDecl());
5432 
5433  if (VD->getDeclContext()->isRecord() &&
5434  (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||
5435  isa<IndirectFieldDecl>(VD))) {
5436  // If the value is a class member, we might have a pointer-to-member.
5437  // Determine whether the non-type template template parameter is of
5438  // pointer-to-member type. If so, we need to build an appropriate
5439  // expression for a pointer-to-member, since a "normal" DeclRefExpr
5440  // would refer to the member itself.
5441  if (ParamType->isMemberPointerType()) {
5442  QualType ClassType
5443  = Context.getTypeDeclType(cast<RecordDecl>(VD->getDeclContext()));
5444  NestedNameSpecifier *Qualifier
5445  = NestedNameSpecifier::Create(Context, nullptr, false,
5446  ClassType.getTypePtr());
5447  CXXScopeSpec SS;
5448  SS.MakeTrivial(Context, Qualifier, Loc);
5449 
5450  // The actual value-ness of this is unimportant, but for
5451  // internal consistency's sake, references to instance methods
5452  // are r-values.
5453  ExprValueKind VK = VK_LValue;
5454  if (isa<CXXMethodDecl>(VD) && cast<CXXMethodDecl>(VD)->isInstance())
5455  VK = VK_RValue;
5456 
5457  ExprResult RefExpr = BuildDeclRefExpr(VD,
5458  VD->getType().getNonReferenceType(),
5459  VK,
5460  Loc,
5461  &SS);
5462  if (RefExpr.isInvalid())
5463  return ExprError();
5464 
5465  RefExpr = CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
5466 
5467  // We might need to perform a trailing qualification conversion, since
5468  // the element type on the parameter could be more qualified than the
5469  // element type in the expression we constructed.
5470  bool ObjCLifetimeConversion;
5471  if (IsQualificationConversion(((Expr*) RefExpr.get())->getType(),
5472  ParamType.getUnqualifiedType(), false,
5473  ObjCLifetimeConversion))
5474  RefExpr = ImpCastExprToType(RefExpr.get(), ParamType.getUnqualifiedType(), CK_NoOp);
5475 
5476  assert(!RefExpr.isInvalid() &&
5477  Context.hasSameType(((Expr*) RefExpr.get())->getType(),
5478  ParamType.getUnqualifiedType()));
5479  return RefExpr;
5480  }
5481  }
5482 
5483  QualType T = VD->getType().getNonReferenceType();
5484 
5485  if (ParamType->isPointerType()) {
5486  // When the non-type template parameter is a pointer, take the
5487  // address of the declaration.
5488  ExprResult RefExpr = BuildDeclRefExpr(VD, T, VK_LValue, Loc);
5489  if (RefExpr.isInvalid())
5490  return ExprError();
5491 
5492  if (T->isFunctionType() || T->isArrayType()) {
5493  // Decay functions and arrays.
5494  RefExpr = DefaultFunctionArrayConversion(RefExpr.get());
5495  if (RefExpr.isInvalid())
5496  return ExprError();
5497 
5498  return RefExpr;
5499  }
5500 
5501  // Take the address of everything else
5502  return CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
5503  }
5504 
5505  ExprValueKind VK = VK_RValue;
5506 
5507  // If the non-type template parameter has reference type, qualify the
5508  // resulting declaration reference with the extra qualifiers on the
5509  // type that the reference refers to.
5510  if (const ReferenceType *TargetRef = ParamType->getAs<ReferenceType>()) {
5511  VK = VK_LValue;
5512  T = Context.getQualifiedType(T,
5513  TargetRef->getPointeeType().getQualifiers());
5514  } else if (isa<FunctionDecl>(VD)) {
5515  // References to functions are always lvalues.
5516  VK = VK_LValue;
5517  }
5518 
5519  return BuildDeclRefExpr(VD, T, VK, Loc);
5520 }
5521 
5522 /// \brief Construct a new expression that refers to the given
5523 /// integral template argument with the given source-location
5524 /// information.
5525 ///
5526 /// This routine takes care of the mapping from an integral template
5527 /// argument (which may have any integral type) to the appropriate
5528 /// literal value.
5529 ExprResult
5531  SourceLocation Loc) {
5532  assert(Arg.getKind() == TemplateArgument::Integral &&
5533  "Operation is only valid for integral template arguments");
5534  QualType OrigT = Arg.getIntegralType();
5535 
5536  // If this is an enum type that we're instantiating, we need to use an integer
5537  // type the same size as the enumerator. We don't want to build an
5538  // IntegerLiteral with enum type. The integer type of an enum type can be of
5539  // any integral type with C++11 enum classes, make sure we create the right
5540  // type of literal for it.
5541  QualType T = OrigT;
5542  if (const EnumType *ET = OrigT->getAs<EnumType>())
5543  T = ET->getDecl()->getIntegerType();
5544 
5545  Expr *E;
5546  if (T->isAnyCharacterType()) {
5547  // This does not need to handle u8 character literals because those are
5548  // of type char, and so can also be covered by an ASCII character literal.
5550  if (T->isWideCharType())
5551  Kind = CharacterLiteral::Wide;
5552  else if (T->isChar16Type())
5553  Kind = CharacterLiteral::UTF16;
5554  else if (T->isChar32Type())
5555  Kind = CharacterLiteral::UTF32;
5556  else
5557  Kind = CharacterLiteral::Ascii;
5558 
5559  E = new (Context) CharacterLiteral(Arg.getAsIntegral().getZExtValue(),
5560  Kind, T, Loc);
5561  } else if (T->isBooleanType()) {
5562  E = new (Context) CXXBoolLiteralExpr(Arg.getAsIntegral().getBoolValue(),
5563  T, Loc);
5564  } else if (T->isNullPtrType()) {
5566  } else {
5567  E = IntegerLiteral::Create(Context, Arg.getAsIntegral(), T, Loc);
5568  }
5569 
5570  if (OrigT->isEnumeralType()) {
5571  // FIXME: This is a hack. We need a better way to handle substituted
5572  // non-type template parameters.
5573  E = CStyleCastExpr::Create(Context, OrigT, VK_RValue, CK_IntegralCast, E,
5574  nullptr,
5575  Context.getTrivialTypeSourceInfo(OrigT, Loc),
5576  Loc, Loc);
5577  }
5578 
5579  return E;
5580 }
5581 
5582 /// \brief Match two template parameters within template parameter lists.
5584  bool Complain,
5586  SourceLocation TemplateArgLoc) {
5587  // Check the actual kind (type, non-type, template).
5588  if (Old->getKind() != New->getKind()) {
5589  if (Complain) {
5590  unsigned NextDiag = diag::err_template_param_different_kind;
5591  if (TemplateArgLoc.isValid()) {
5592  S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
5593  NextDiag = diag::note_template_param_different_kind;
5594  }
5595  S.Diag(New->getLocation(), NextDiag)
5596  << (Kind != Sema::TPL_TemplateMatch);
5597  S.Diag(Old->getLocation(), diag::note_template_prev_declaration)
5598  << (Kind != Sema::TPL_TemplateMatch);
5599  }
5600 
5601  return false;
5602  }
5603 
5604  // Check that both are parameter packs are neither are parameter packs.
5605  // However, if we are matching a template template argument to a
5606  // template template parameter, the template template parameter can have
5607  // a parameter pack where the template template argument does not.
5608  if (Old->isTemplateParameterPack() != New->isTemplateParameterPack() &&
5610  Old->isTemplateParameterPack())) {
5611  if (Complain) {
5612  unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
5613  if (TemplateArgLoc.isValid()) {
5614  S.Diag(TemplateArgLoc,
5615  diag::err_template_arg_template_params_mismatch);
5616  NextDiag = diag::note_template_parameter_pack_non_pack;
5617  }
5618 
5619  unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
5620  : isa<NonTypeTemplateParmDecl>(New)? 1
5621  : 2;
5622  S.Diag(New->getLocation(), NextDiag)
5623  << ParamKind << New->isParameterPack();
5624  S.Diag(Old->getLocation(), diag::note_template_parameter_pack_here)
5625  << ParamKind << Old->isParameterPack();
5626  }
5627 
5628  return false;
5629  }
5630 
5631  // For non-type template parameters, check the type of the parameter.
5632  if (NonTypeTemplateParmDecl *OldNTTP
5633  = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
5634  NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);
5635 
5636  // If we are matching a template template argument to a template
5637  // template parameter and one of the non-type template parameter types
5638  // is dependent, then we must wait until template instantiation time
5639  // to actually compare the arguments.
5641  (OldNTTP->getType()->isDependentType() ||
5642  NewNTTP->getType()->isDependentType()))
5643  return true;
5644 
5645  if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
5646  if (Complain) {
5647  unsigned NextDiag = diag::err_template_nontype_parm_different_type;
5648  if (TemplateArgLoc.isValid()) {
5649  S.Diag(TemplateArgLoc,
5650  diag::err_template_arg_template_params_mismatch);
5651  NextDiag = diag::note_template_nontype_parm_different_type;
5652  }
5653  S.Diag(NewNTTP->getLocation(), NextDiag)
5654  << NewNTTP->getType()
5655  << (Kind != Sema::TPL_TemplateMatch);
5656  S.Diag(OldNTTP->getLocation(),
5657  diag::note_template_nontype_parm_prev_declaration)
5658  << OldNTTP->getType();
5659  }
5660 
5661  return false;
5662  }
5663 
5664  return true;
5665  }
5666 
5667  // For template template parameters, check the template parameter types.
5668  // The template parameter lists of template template
5669  // parameters must agree.
5670  if (TemplateTemplateParmDecl *OldTTP
5671  = dyn_cast<TemplateTemplateParmDecl>(Old)) {
5672  TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
5674  OldTTP->getTemplateParameters(),
5675  Complain,
5676  (Kind == Sema::TPL_TemplateMatch
5678  : Kind),
5679  TemplateArgLoc);
5680  }
5681 
5682  return true;
5683 }
5684 
5685 /// \brief Diagnose a known arity mismatch when comparing template argument
5686 /// lists.
5687 static
5689  TemplateParameterList *New,
5690  TemplateParameterList *Old,
5692  SourceLocation TemplateArgLoc) {
5693  unsigned NextDiag = diag::err_template_param_list_different_arity;
5694  if (TemplateArgLoc.isValid()) {
5695  S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
5696  NextDiag = diag::note_template_param_list_different_arity;
5697  }
5698  S.Diag(New->getTemplateLoc(), NextDiag)
5699  << (New->size() > Old->size())
5700  << (Kind != Sema::TPL_TemplateMatch)
5701  << SourceRange(New->getTemplateLoc(), New->getRAngleLoc());
5702  S.Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration)
5703  << (Kind != Sema::TPL_TemplateMatch)
5704  << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc());
5705 }
5706 
5707 /// \brief Determine whether the given template parameter lists are
5708 /// equivalent.
5709 ///
5710 /// \param New The new template parameter list, typically written in the
5711 /// source code as part of a new template declaration.
5712 ///
5713 /// \param Old The old template parameter list, typically found via
5714 /// name lookup of the template declared with this template parameter
5715 /// list.
5716 ///
5717 /// \param Complain If true, this routine will produce a diagnostic if
5718 /// the template parameter lists are not equivalent.
5719 ///
5720 /// \param Kind describes how we are to match the template parameter lists.
5721 ///
5722 /// \param TemplateArgLoc If this source location is valid, then we
5723 /// are actually checking the template parameter list of a template
5724 /// argument (New) against the template parameter list of its
5725 /// corresponding template template parameter (Old). We produce
5726 /// slightly different diagnostics in this scenario.
5727 ///
5728 /// \returns True if the template parameter lists are equal, false
5729 /// otherwise.
5730 bool
5732  TemplateParameterList *Old,
5733  bool Complain,
5735  SourceLocation TemplateArgLoc) {
5736  if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) {
5737  if (Complain)
5738  DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
5739  TemplateArgLoc);
5740 
5741  return false;
5742  }
5743 
5744  // C++0x [temp.arg.template]p3:
5745  // A template-argument matches a template template-parameter (call it P)
5746  // when each of the template parameters in the template-parameter-list of
5747  // the template-argument's corresponding class template or alias template
5748  // (call it A) matches the corresponding template parameter in the
5749  // template-parameter-list of P. [...]
5750  TemplateParameterList::iterator NewParm = New->begin();
5751  TemplateParameterList::iterator NewParmEnd = New->end();
5752  for (TemplateParameterList::iterator OldParm = Old->begin(),
5753  OldParmEnd = Old->end();
5754  OldParm != OldParmEnd; ++OldParm) {
5755  if (Kind != TPL_TemplateTemplateArgumentMatch ||
5756  !(*OldParm)->isTemplateParameterPack()) {
5757  if (NewParm == NewParmEnd) {
5758  if (Complain)
5759  DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
5760  TemplateArgLoc);
5761 
5762  return false;
5763  }
5764 
5765  if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
5766  Kind, TemplateArgLoc))
5767  return false;
5768 
5769  ++NewParm;
5770  continue;
5771  }
5772 
5773  // C++0x [temp.arg.template]p3:
5774  // [...] When P's template- parameter-list contains a template parameter
5775  // pack (14.5.3), the template parameter pack will match zero or more
5776  // template parameters or template parameter packs in the
5777  // template-parameter-list of A with the same type and form as the
5778  // template parameter pack in P (ignoring whether those template
5779  // parameters are template parameter packs).
5780  for (; NewParm != NewParmEnd; ++NewParm) {
5781  if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
5782  Kind, TemplateArgLoc))
5783  return false;
5784  }
5785  }
5786 
5787  // Make sure we exhausted all of the arguments.
5788  if (NewParm != NewParmEnd) {
5789  if (Complain)
5790  DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
5791  TemplateArgLoc);
5792 
5793  return false;
5794  }
5795 
5796  return true;
5797 }
5798 
5799 /// \brief Check whether a template can be declared within this scope.
5800 ///
5801 /// If the template declaration is valid in this scope, returns
5802 /// false. Otherwise, issues a diagnostic and returns true.
5803 bool
5805  if (!S)
5806  return false;
5807 
5808  // Find the nearest enclosing declaration scope.
5809  while ((S->getFlags() & Scope::DeclScope) == 0 ||
5810  (S->getFlags() & Scope::TemplateParamScope) != 0)
5811  S = S->getParent();
5812 
5813  // C++ [temp]p4:
5814  // A template [...] shall not have C linkage.
5815  DeclContext *Ctx = S->getEntity();
5816  if (Ctx && Ctx->isExternCContext())
5817  return Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
5818  << TemplateParams->getSourceRange();
5819 
5820  while (Ctx && isa<LinkageSpecDecl>(Ctx))
5821  Ctx = Ctx->getParent();
5822 
5823  // C++ [temp]p2:
5824  // A template-declaration can appear only as a namespace scope or
5825  // class scope declaration.
5826  if (Ctx) {
5827  if (Ctx->isFileContext())
5828  return false;
5829  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Ctx)) {
5830  // C++ [temp.mem]p2:
5831  // A local class shall not have member templates.
5832  if (RD->isLocalClass())
5833  return Diag(TemplateParams->getTemplateLoc(),
5834  diag::err_template_inside_local_class)
5835  << TemplateParams->getSourceRange();
5836  else
5837  return false;
5838  }
5839  }
5840 
5841  return Diag(TemplateParams->getTemplateLoc(),
5842  diag::err_template_outside_namespace_or_class_scope)
5843  << TemplateParams->getSourceRange();
5844 }
5845 
5846 /// \brief Determine what kind of template specialization the given declaration
5847 /// is.
5849  if (!D)
5850  return TSK_Undeclared;
5851 
5852  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D))
5853  return Record->getTemplateSpecializationKind();
5854  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D))
5855  return Function->getTemplateSpecializationKind();
5856  if (VarDecl *Var = dyn_cast<VarDecl>(D))
5857  return Var->getTemplateSpecializationKind();
5858 
5859  return TSK_Undeclared;
5860 }
5861 
5862 /// \brief Check whether a specialization is well-formed in the current
5863 /// context.
5864 ///
5865 /// This routine determines whether a template specialization can be declared
5866 /// in the current context (C++ [temp.expl.spec]p2).
5867 ///
5868 /// \param S the semantic analysis object for which this check is being
5869 /// performed.
5870 ///
5871 /// \param Specialized the entity being specialized or instantiated, which
5872 /// may be a kind of template (class template, function template, etc.) or
5873 /// a member of a class template (member function, static data member,
5874 /// member class).
5875 ///
5876 /// \param PrevDecl the previous declaration of this entity, if any.
5877 ///
5878 /// \param Loc the location of the explicit specialization or instantiation of
5879 /// this entity.
5880 ///
5881 /// \param IsPartialSpecialization whether this is a partial specialization of
5882 /// a class template.
5883 ///
5884 /// \returns true if there was an error that we cannot recover from, false
5885 /// otherwise.
5887  NamedDecl *Specialized,
5888  NamedDecl *PrevDecl,
5889  SourceLocation Loc,
5890  bool IsPartialSpecialization) {
5891  // Keep these "kind" numbers in sync with the %select statements in the
5892  // various diagnostics emitted by this routine.
5893  int EntityKind = 0;
5894  if (isa<ClassTemplateDecl>(Specialized))
5895  EntityKind = IsPartialSpecialization? 1 : 0;
5896  else if (isa<VarTemplateDecl>(Specialized))
5897  EntityKind = IsPartialSpecialization ? 3 : 2;
5898  else if (isa<FunctionTemplateDecl>(Specialized))
5899  EntityKind = 4;
5900  else if (isa<CXXMethodDecl>(Specialized))
5901  EntityKind = 5;
5902  else if (isa<VarDecl>(Specialized))
5903  EntityKind = 6;
5904  else if (isa<RecordDecl>(Specialized))
5905  EntityKind = 7;
5906  else if (isa<EnumDecl>(Specialized) && S.getLangOpts().CPlusPlus11)
5907  EntityKind = 8;
5908  else {
5909  S.Diag(Loc, diag::err_template_spec_unknown_kind)
5910  << S.getLangOpts().CPlusPlus11;
5911  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
5912  return true;
5913  }
5914 
5915  // C++ [temp.expl.spec]p2:
5916  // An explicit specialization shall be declared in the namespace
5917  // of which the template is a member, or, for member templates, in
5918  // the namespace of which the enclosing class or enclosing class
5919  // template is a member. An explicit specialization of a member
5920  // function, member class or static data member of a class
5921  // template shall be declared in the namespace of which the class
5922  // template is a member. Such a declaration may also be a
5923  // definition. If the declaration is not a definition, the
5924  // specialization may be defined later in the name- space in which
5925  // the explicit specialization was declared, or in a namespace
5926  // that encloses the one in which the explicit specialization was
5927  // declared.
5929  S.Diag(Loc, diag::err_template_spec_decl_function_scope)
5930  << Specialized;
5931  return true;
5932  }
5933 
5934  if (S.CurContext->isRecord() && !IsPartialSpecialization) {
5935  if (S.getLangOpts().MicrosoftExt) {
5936  // Do not warn for class scope explicit specialization during
5937  // instantiation, warning was already emitted during pattern
5938  // semantic analysis.
5939  if (!S.ActiveTemplateInstantiations.size())
5940  S.Diag(Loc, diag::ext_function_specialization_in_class)
5941  << Specialized;
5942  } else {
5943  S.Diag(Loc, diag::err_template_spec_decl_class_scope)
5944  << Specialized;
5945  return true;
5946  }
5947  }
5948 
5949  if (S.CurContext->isRecord() &&
5950  !S.CurContext->Equals(Specialized->getDeclContext())) {
5951  // Make sure that we're specializing in the right record context.
5952  // Otherwise, things can go horribly wrong.
5953  S.Diag(Loc, diag::err_template_spec_decl_class_scope)
5954  << Specialized;
5955  return true;
5956  }
5957 
5958  // C++ [temp.class.spec]p6:
5959  // A class template partial specialization may be declared or redeclared
5960  // in any namespace scope in which its definition may be defined (14.5.1
5961  // and 14.5.2).
5962  DeclContext *SpecializedContext
5963  = Specialized->getDeclContext()->getEnclosingNamespaceContext();
5965 
5966  // Make sure that this redeclaration (or definition) occurs in an enclosing
5967  // namespace.
5968  // Note that HandleDeclarator() performs this check for explicit
5969  // specializations of function templates, static data members, and member
5970  // functions, so we skip the check here for those kinds of entities.
5971  // FIXME: HandleDeclarator's diagnostics aren't quite as good, though.
5972  // Should we refactor that check, so that it occurs later?
5973  if (!DC->Encloses(SpecializedContext) &&
5974  !(isa<FunctionTemplateDecl>(Specialized) ||
5975  isa<FunctionDecl>(Specialized) ||
5976  isa<VarTemplateDecl>(Specialized) ||
5977  isa<VarDecl>(Specialized))) {
5978  if (isa<TranslationUnitDecl>(SpecializedContext))
5979  S.Diag(Loc, diag::err_template_spec_redecl_global_scope)
5980  << EntityKind << Specialized;
5981  else if (isa<NamespaceDecl>(SpecializedContext)) {
5982  int Diag = diag::err_template_spec_redecl_out_of_scope;
5983  if (S.getLangOpts().MicrosoftExt)
5984  Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
5985  S.Diag(Loc, Diag) << EntityKind << Specialized
5986  << cast<NamedDecl>(SpecializedContext);
5987  } else
5988  llvm_unreachable("unexpected namespace context for specialization");
5989 
5990  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
5991  } else if ((!PrevDecl ||
5993  getTemplateSpecializationKind(PrevDecl) ==
5995  // C++ [temp.exp.spec]p2:
5996  // An explicit specialization shall be declared in the namespace of which
5997  // the template is a member, or, for member templates, in the namespace
5998  // of which the enclosing class or enclosing class template is a member.
5999  // An explicit specialization of a member function, member class or
6000  // static data member of a class template shall be declared in the
6001  // namespace of which the class template is a member.
6002  //
6003  // C++11 [temp.expl.spec]p2:
6004  // An explicit specialization shall be declared in a namespace enclosing
6005  // the specialized template.
6006  // C++11 [temp.explicit]p3:
6007  // An explicit instantiation shall appear in an enclosing namespace of its
6008  // template.
6009  if (!DC->InEnclosingNamespaceSetOf(SpecializedContext)) {
6010  bool IsCPlusPlus11Extension = DC->Encloses(SpecializedContext);
6011  if (isa<TranslationUnitDecl>(SpecializedContext)) {
6012  assert(!IsCPlusPlus11Extension &&
6013  "DC encloses TU but isn't in enclosing namespace set");
6014  S.Diag(Loc, diag::err_template_spec_decl_out_of_scope_global)
6015  << EntityKind << Specialized;
6016  } else if (isa<NamespaceDecl>(SpecializedContext)) {
6017  int Diag;
6018  if (!IsCPlusPlus11Extension)
6019  Diag = diag::err_template_spec_decl_out_of_scope;
6020  else if (!S.getLangOpts().CPlusPlus11)
6021  Diag = diag::ext_template_spec_decl_out_of_scope;
6022  else
6023  Diag = diag::warn_cxx98_compat_template_spec_decl_out_of_scope;
6024  S.Diag(Loc, Diag)
6025  << EntityKind << Specialized << cast<NamedDecl>(SpecializedContext);
6026  }
6027 
6028  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
6029  }
6030  }
6031 
6032  return false;
6033 }
6034 
6036  if (!E->isInstantiationDependent())
6037  return SourceLocation();
6038  DependencyChecker Checker(Depth);
6039  Checker.TraverseStmt(E);
6040  if (Checker.Match && Checker.MatchLoc.isInvalid())
6041  return E->getSourceRange();
6042  return Checker.MatchLoc;
6043 }
6044 
6046  if (!TL.getType()->isDependentType())
6047  return SourceLocation();
6048  DependencyChecker Checker(Depth);
6049  Checker.TraverseTypeLoc(TL);
6050  if (Checker.Match && Checker.MatchLoc.isInvalid())
6051  return TL.getSourceRange();
6052  return Checker.MatchLoc;
6053 }
6054 
6055 /// \brief Subroutine of Sema::CheckTemplatePartialSpecializationArgs
6056 /// that checks non-type template partial specialization arguments.
6058  Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param,
6059  const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument) {
6060  for (unsigned I = 0; I != NumArgs; ++I) {
6061  if (Args[I].getKind() == TemplateArgument::Pack) {
6063  S, TemplateNameLoc, Param, Args[I].pack_begin(),
6064  Args[I].pack_size(), IsDefaultArgument))
6065  return true;
6066 
6067  continue;
6068  }
6069 
6070  if (Args[I].getKind() != TemplateArgument::Expression)
6071  continue;
6072 
6073  Expr *ArgExpr = Args[I].getAsExpr();
6074 
6075  // We can have a pack expansion of any of the bullets below.
6076  if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(ArgExpr))
6077  ArgExpr = Expansion->getPattern();
6078 
6079  // Strip off any implicit casts we added as part of type checking.
6080  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
6081  ArgExpr = ICE->getSubExpr();
6082 
6083  // C++ [temp.class.spec]p8:
6084  // A non-type argument is non-specialized if it is the name of a
6085  // non-type parameter. All other non-type arguments are
6086  // specialized.
6087  //
6088  // Below, we check the two conditions that only apply to
6089  // specialized non-type arguments, so skip any non-specialized
6090  // arguments.
6091  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
6092  if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
6093  continue;
6094 
6095  // C++ [temp.class.spec]p9:
6096  // Within the argument list of a class template partial
6097  // specialization, the following restrictions apply:
6098  // -- A partially specialized non-type argument expression
6099  // shall not involve a template parameter of the partial
6100  // specialization except when the argument expression is a
6101  // simple identifier.
6102  SourceRange ParamUseRange =
6103  findTemplateParameter(Param->getDepth(), ArgExpr);
6104  if (ParamUseRange.isValid()) {
6105  if (IsDefaultArgument) {
6106  S.Diag(TemplateNameLoc,
6107  diag::err_dependent_non_type_arg_in_partial_spec);
6108  S.Diag(ParamUseRange.getBegin(),
6109  diag::note_dependent_non_type_default_arg_in_partial_spec)
6110  << ParamUseRange;
6111  } else {
6112  S.Diag(ParamUseRange.getBegin(),
6113  diag::err_dependent_non_type_arg_in_partial_spec)
6114  << ParamUseRange;
6115  }
6116  return true;
6117  }
6118 
6119  // -- The type of a template parameter corresponding to a
6120  // specialized non-type argument shall not be dependent on a
6121  // parameter of the specialization.
6122  //
6123  // FIXME: We need to delay this check until instantiation in some cases:
6124  //
6125  // template<template<typename> class X> struct A {
6126  // template<typename T, X<T> N> struct B;
6127  // template<typename T> struct B<T, 0>;
6128  // };
6129  // template<typename> using X = int;
6130  // A<X>::B<int, 0> b;
6131  ParamUseRange = findTemplateParameter(
6132  Param->getDepth(), Param->getTypeSourceInfo()->getTypeLoc());
6133  if (ParamUseRange.isValid()) {
6134  S.Diag(IsDefaultArgument ? TemplateNameLoc : ArgExpr->getLocStart(),
6135  diag::err_dependent_typed_non_type_arg_in_partial_spec)
6136  << Param->getType() << ParamUseRange;
6137  S.Diag(Param->getLocation(), diag::note_template_param_here)
6138  << (IsDefaultArgument ? ParamUseRange : SourceRange());
6139  return true;
6140  }
6141  }
6142 
6143  return false;
6144 }
6145 
6146 /// \brief Check the non-type template arguments of a class template
6147 /// partial specialization according to C++ [temp.class.spec]p9.
6148 ///
6149 /// \param TemplateNameLoc the location of the template name.
6150 /// \param TemplateParams the template parameters of the primary class
6151 /// template.
6152 /// \param NumExplicit the number of explicitly-specified template arguments.
6153 /// \param TemplateArgs the template arguments of the class template
6154 /// partial specialization.
6155 ///
6156 /// \returns \c true if there was an error, \c false otherwise.
6158  Sema &S, SourceLocation TemplateNameLoc,
6159  TemplateParameterList *TemplateParams, unsigned NumExplicit,
6160  SmallVectorImpl<TemplateArgument> &TemplateArgs) {
6161  const TemplateArgument *ArgList = TemplateArgs.data();
6162 
6163  for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
6165  = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I));
6166  if (!Param)
6167  continue;
6168 
6170  S, TemplateNameLoc, Param, &ArgList[I], 1, I >= NumExplicit))
6171  return true;
6172  }
6173 
6174  return false;
6175 }
6176 
6177 DeclResult
6179  TagUseKind TUK,
6180  SourceLocation KWLoc,
6181  SourceLocation ModulePrivateLoc,
6182  TemplateIdAnnotation &TemplateId,
6185  TemplateParameterLists,
6186  SkipBodyInfo *SkipBody) {
6187  assert(TUK != TUK_Reference && "References are not specializations");
6188 
6189  CXXScopeSpec &SS = TemplateId.SS;
6190 
6191  // NOTE: KWLoc is the location of the tag keyword. This will instead
6192  // store the location of the outermost template keyword in the declaration.
6193  SourceLocation TemplateKWLoc = TemplateParameterLists.size() > 0
6194  ? TemplateParameterLists[0]->getTemplateLoc() : KWLoc;
6195  SourceLocation TemplateNameLoc = TemplateId.TemplateNameLoc;
6196  SourceLocation LAngleLoc = TemplateId.LAngleLoc;
6197  SourceLocation RAngleLoc = TemplateId.RAngleLoc;
6198 
6199  // Find the class template we're specializing
6200  TemplateName Name = TemplateId.Template.get();
6201  ClassTemplateDecl *ClassTemplate
6202  = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());
6203 
6204  if (!ClassTemplate) {
6205  Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
6206  << (Name.getAsTemplateDecl() &&
6207  isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
6208  return true;
6209  }
6210 
6211  bool isExplicitSpecialization = false;
6212  bool isPartialSpecialization = false;
6213 
6214  // Check the validity of the template headers that introduce this
6215  // template.
6216  // FIXME: We probably shouldn't complain about these headers for
6217  // friend declarations.
6218  bool Invalid = false;
6219  TemplateParameterList *TemplateParams =
6220  MatchTemplateParametersToScopeSpecifier(
6221  KWLoc, TemplateNameLoc, SS, &TemplateId,
6222  TemplateParameterLists, TUK == TUK_Friend, isExplicitSpecialization,
6223  Invalid);
6224  if (Invalid)
6225  return true;
6226 
6227  if (TemplateParams && TemplateParams->size() > 0) {
6228  isPartialSpecialization = true;
6229 
6230  if (TUK == TUK_Friend) {
6231  Diag(KWLoc, diag::err_partial_specialization_friend)
6232  << SourceRange(LAngleLoc, RAngleLoc);
6233  return true;
6234  }
6235 
6236  // C++ [temp.class.spec]p10:
6237  // The template parameter list of a specialization shall not
6238  // contain default template argument values.
6239  for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
6240  Decl *Param = TemplateParams->getParam(I);
6241  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
6242  if (TTP->hasDefaultArgument()) {
6243  Diag(TTP->getDefaultArgumentLoc(),
6244  diag::err_default_arg_in_partial_spec);
6245  TTP->removeDefaultArgument();
6246  }
6247  } else if (NonTypeTemplateParmDecl *NTTP
6248  = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
6249  if (Expr *DefArg = NTTP->getDefaultArgument()) {
6250  Diag(NTTP->getDefaultArgumentLoc(),
6251  diag::err_default_arg_in_partial_spec)
6252  << DefArg->getSourceRange();
6253  NTTP->removeDefaultArgument();
6254  }
6255  } else {
6256  TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param);
6257  if (TTP->hasDefaultArgument()) {
6259  diag::err_default_arg_in_partial_spec)
6260  << TTP->getDefaultArgument().getSourceRange();
6261  TTP->removeDefaultArgument();
6262  }
6263  }
6264  }
6265  } else if (TemplateParams) {
6266  if (TUK == TUK_Friend)
6267  Diag(KWLoc, diag::err_template_spec_friend)
6269  SourceRange(TemplateParams->getTemplateLoc(),
6270  TemplateParams->getRAngleLoc()))
6271  << SourceRange(LAngleLoc, RAngleLoc);
6272  else
6273  isExplicitSpecialization = true;
6274  } else {
6275  assert(TUK == TUK_Friend && "should have a 'template<>' for this decl");
6276  }
6277 
6278  // Check that the specialization uses the same tag kind as the
6279  // original template.
6281  assert(Kind != TTK_Enum && "Invalid enum tag in class template spec!");
6282  if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
6283  Kind, TUK == TUK_Definition, KWLoc,
6284  ClassTemplate->getIdentifier())) {
6285  Diag(KWLoc, diag::err_use_with_wrong_tag)
6286  << ClassTemplate
6288  ClassTemplate->getTemplatedDecl()->getKindName());
6289  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
6290  diag::note_previous_use);
6291  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
6292  }
6293 
6294  // Translate the parser's template argument list in our AST format.
6295  TemplateArgumentListInfo TemplateArgs =
6296  makeTemplateArgumentListInfo(*this, TemplateId);
6297 
6298  // Check for unexpanded parameter packs in any of the template arguments.
6299  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
6300  if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
6301  UPPC_PartialSpecialization))
6302  return true;
6303 
6304  // Check that the template argument list is well-formed for this
6305  // template.
6307  if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
6308  TemplateArgs, false, Converted))
6309  return true;
6310 
6311  // Find the class template (partial) specialization declaration that
6312  // corresponds to these arguments.
6313  if (isPartialSpecialization) {
6315  *this, TemplateNameLoc, ClassTemplate->getTemplateParameters(),
6316  TemplateArgs.size(), Converted))
6317  return true;
6318 
6319  bool InstantiationDependent;
6320  if (!Name.isDependent() &&
6322  TemplateArgs.arguments(), InstantiationDependent)) {
6323  Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
6324  << ClassTemplate->getDeclName();
6325  isPartialSpecialization = false;
6326  }
6327  }
6328 
6329  void *InsertPos = nullptr;
6330  ClassTemplateSpecializationDecl *PrevDecl = nullptr;
6331 
6332  if (isPartialSpecialization)
6333  // FIXME: Template parameter list matters, too
6334  PrevDecl = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
6335  else
6336  PrevDecl = ClassTemplate->findSpecialization(Converted, InsertPos);
6337 
6338  ClassTemplateSpecializationDecl *Specialization = nullptr;
6339 
6340  // Check whether we can declare a class template specialization in
6341  // the current scope.
6342  if (TUK != TUK_Friend &&
6343  CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl,
6344  TemplateNameLoc,
6345  isPartialSpecialization))
6346  return true;
6347 
6348  // The canonical type
6349  QualType CanonType;
6350  if (isPartialSpecialization) {
6351  // Build the canonical type that describes the converted template
6352  // arguments of the class template partial specialization.
6353  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
6354  CanonType = Context.getTemplateSpecializationType(CanonTemplate,
6355  Converted);
6356 
6357  if (Context.hasSameType(CanonType,
6358  ClassTemplate->getInjectedClassNameSpecialization())) {
6359  // C++ [temp.class.spec]p9b3:
6360  //
6361  // -- The argument list of the specialization shall not be identical
6362  // to the implicit argument list of the primary template.
6363  Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
6364  << /*class template*/0 << (TUK == TUK_Definition)
6365  << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
6366  return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
6367  ClassTemplate->getIdentifier(),
6368  TemplateNameLoc,
6369  Attr,
6370  TemplateParams,
6371  AS_none, /*ModulePrivateLoc=*/SourceLocation(),
6372  /*FriendLoc*/SourceLocation(),
6373  TemplateParameterLists.size() - 1,
6374  TemplateParameterLists.data());
6375  }
6376 
6377  // Create a new class template partial specialization declaration node.
6379  = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
6382  ClassTemplate->getDeclContext(),
6383  KWLoc, TemplateNameLoc,
6384  TemplateParams,
6385  ClassTemplate,
6386  Converted,
6387  TemplateArgs,
6388  CanonType,
6389  PrevPartial);
6390  SetNestedNameSpecifier(Partial, SS);
6391  if (TemplateParameterLists.size() > 1 && SS.isSet()) {
6392  Partial->setTemplateParameterListsInfo(
6393  Context, TemplateParameterLists.drop_back(1));
6394  }
6395 
6396  if (!PrevPartial)
6397  ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
6398  Specialization = Partial;
6399 
6400  // If we are providing an explicit specialization of a member class
6401  // template specialization, make a note of that.
6402  if (PrevPartial && PrevPartial->getInstantiatedFromMember())
6403  PrevPartial->setMemberSpecialization();
6404 
6405  // Check that all of the template parameters of the class template
6406  // partial specialization are deducible from the template
6407  // arguments. If not, this class template partial specialization
6408  // will never be used.
6409  llvm::SmallBitVector DeducibleParams(TemplateParams->size());
6410  MarkUsedTemplateParameters(Partial->getTemplateArgs(), true,
6411  TemplateParams->getDepth(),
6412  DeducibleParams);
6413 
6414  if (!DeducibleParams.all()) {
6415  unsigned NumNonDeducible = DeducibleParams.size()-DeducibleParams.count();
6416  Diag(TemplateNameLoc, diag::warn_partial_specs_not_deducible)
6417  << /*class template*/0 << (NumNonDeducible > 1)
6418  << SourceRange(TemplateNameLoc, RAngleLoc);
6419  for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
6420  if (!DeducibleParams[I]) {
6421  NamedDecl *Param = cast<NamedDecl>(TemplateParams->getParam(I));
6422  if (Param->getDeclName())
6423  Diag(Param->getLocation(),
6424  diag::note_partial_spec_unused_parameter)
6425  << Param->getDeclName();
6426  else
6427  Diag(Param->getLocation(),
6428  diag::note_partial_spec_unused_parameter)
6429  << "(anonymous)";
6430  }
6431  }
6432  }
6433  } else {
6434  // Create a new class template specialization declaration node for
6435  // this explicit specialization or friend declaration.
6436  Specialization
6438  ClassTemplate->getDeclContext(),
6439  KWLoc, TemplateNameLoc,
6440  ClassTemplate,
6441  Converted,
6442  PrevDecl);
6443  SetNestedNameSpecifier(Specialization, SS);
6444  if (TemplateParameterLists.size() > 0) {
6445  Specialization->setTemplateParameterListsInfo(Context,
6446  TemplateParameterLists);
6447  }
6448 
6449  if (!PrevDecl)
6450  ClassTemplate->AddSpecialization(Specialization, InsertPos);
6451 
6452  if (CurContext->isDependentContext()) {
6453  // -fms-extensions permits specialization of nested classes without
6454  // fully specializing the outer class(es).
6455  assert(getLangOpts().MicrosoftExt &&
6456  "Only possible with -fms-extensions!");
6457  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
6459  CanonTemplate, Converted);
6460  } else {
6461  CanonType = Context.getTypeDeclType(Specialization);
6462  }
6463  }
6464 
6465  // C++ [temp.expl.spec]p6:
6466  // If a template, a member template or the member of a class template is
6467  // explicitly specialized then that specialization shall be declared
6468  // before the first use of that specialization that would cause an implicit
6469  // instantiation to take place, in every translation unit in which such a
6470  // use occurs; no diagnostic is required.
6471  if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
6472  bool Okay = false;
6473  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
6474  // Is there any previous explicit specialization declaration?
6476  Okay = true;
6477  break;
6478  }
6479  }
6480 
6481  if (!Okay) {
6482  SourceRange Range(TemplateNameLoc, RAngleLoc);
6483  Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
6484  << Context.getTypeDeclType(Specialization) << Range;
6485 
6486  Diag(PrevDecl->getPointOfInstantiation(),
6487  diag::note_instantiation_required_here)
6488  << (PrevDecl->getTemplateSpecializationKind()
6490  return true;
6491  }
6492  }
6493 
6494  // If this is not a friend, note that this is an explicit specialization.
6495  if (TUK != TUK_Friend)
6497 
6498  // Check that this isn't a redefinition of this specialization.
6499  if (TUK == TUK_Definition) {
6500  RecordDecl *Def = Specialization->getDefinition();
6501  NamedDecl *Hidden = nullptr;
6502  if (Def && SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
6503  SkipBody->ShouldSkip = true;
6504  makeMergedDefinitionVisible(Hidden, KWLoc);
6505  // From here on out, treat this as just a redeclaration.
6506  TUK = TUK_Declaration;
6507  } else if (Def) {
6508  SourceRange Range(TemplateNameLoc, RAngleLoc);
6509  Diag(TemplateNameLoc, diag::err_redefinition)
6510  << Context.getTypeDeclType(Specialization) << Range;
6511  Diag(Def->getLocation(), diag::note_previous_definition);
6512  Specialization->setInvalidDecl();
6513  return true;
6514  }
6515  }
6516 
6517  if (Attr)
6518  ProcessDeclAttributeList(S, Specialization, Attr);
6519 
6520  // Add alignment attributes if necessary; these attributes are checked when
6521  // the ASTContext lays out the structure.
6522  if (TUK == TUK_Definition) {
6523  AddAlignmentAttributesForRecord(Specialization);
6524  AddMsStructLayoutForRecord(Specialization);
6525  }
6526 
6527  if (ModulePrivateLoc.isValid())
6528  Diag(Specialization->getLocation(), diag::err_module_private_specialization)
6529  << (isPartialSpecialization? 1 : 0)
6530  << FixItHint::CreateRemoval(ModulePrivateLoc);
6531 
6532  // Build the fully-sugared type for this class template
6533  // specialization as the user wrote in the specialization
6534  // itself. This means that we'll pretty-print the type retrieved
6535  // from the specialization's declaration the way that the user
6536  // actually wrote the specialization, rather than formatting the
6537  // name based on the "canonical" representation used to store the
6538  // template arguments in the specialization.
6539  TypeSourceInfo *WrittenTy
6540  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
6541  TemplateArgs, CanonType);
6542  if (TUK != TUK_Friend) {
6543  Specialization->setTypeAsWritten(WrittenTy);
6544  Specialization->setTemplateKeywordLoc(TemplateKWLoc);
6545  }
6546 
6547  // C++ [temp.expl.spec]p9:
6548  // A template explicit specialization is in the scope of the
6549  // namespace in which the template was defined.
6550  //
6551  // We actually implement this paragraph where we set the semantic
6552  // context (in the creation of the ClassTemplateSpecializationDecl),
6553  // but we also maintain the lexical context where the actual
6554  // definition occurs.
6555  Specialization->setLexicalDeclContext(CurContext);
6556 
6557  // We may be starting the definition of this specialization.
6558  if (TUK == TUK_Definition)
6559  Specialization->startDefinition();
6560 
6561  if (TUK == TUK_Friend) {
6562  FriendDecl *Friend = FriendDecl::Create(Context, CurContext,
6563  TemplateNameLoc,
6564  WrittenTy,
6565  /*FIXME:*/KWLoc);
6566  Friend->setAccess(AS_public);
6567  CurContext->addDecl(Friend);
6568  } else {
6569  // Add the specialization into its lexical context, so that it can
6570  // be seen when iterating through the list of declarations in that
6571  // context. However, specializations are not found by name lookup.
6572  CurContext->addDecl(Specialization);
6573  }
6574  return Specialization;
6575 }
6576 
6578  MultiTemplateParamsArg TemplateParameterLists,
6579  Declarator &D) {
6580  Decl *NewDecl = HandleDeclarator(S, D, TemplateParameterLists);
6581  ActOnDocumentableDecl(NewDecl);
6582  return NewDecl;
6583 }
6584 
6585 /// \brief Strips various properties off an implicit instantiation
6586 /// that has just been explicitly specialized.
6588  D->dropAttr<DLLImportAttr>();
6589  D->dropAttr<DLLExportAttr>();
6590 
6591  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
6592  FD->setInlineSpecified(false);
6593 }
6594 
6595 /// \brief Compute the diagnostic location for an explicit instantiation
6596 // declaration or definition.
6598  NamedDecl* D, SourceLocation PointOfInstantiation) {
6599  // Explicit instantiations following a specialization have no effect and
6600  // hence no PointOfInstantiation. In that case, walk decl backwards
6601  // until a valid name loc is found.
6602  SourceLocation PrevDiagLoc = PointOfInstantiation;
6603  for (Decl *Prev = D; Prev && !PrevDiagLoc.isValid();
6604  Prev = Prev->getPreviousDecl()) {
6605  PrevDiagLoc = Prev->getLocation();
6606  }
6607  assert(PrevDiagLoc.isValid() &&
6608  "Explicit instantiation without point of instantiation?");
6609  return PrevDiagLoc;
6610 }
6611 
6612 /// \brief Diagnose cases where we have an explicit template specialization
6613 /// before/after an explicit template instantiation, producing diagnostics
6614 /// for those cases where they are required and determining whether the
6615 /// new specialization/instantiation will have any effect.
6616 ///
6617 /// \param NewLoc the location of the new explicit specialization or
6618 /// instantiation.
6619 ///
6620 /// \param NewTSK the kind of the new explicit specialization or instantiation.
6621 ///
6622 /// \param PrevDecl the previous declaration of the entity.
6623 ///
6624 /// \param PrevTSK the kind of the old explicit specialization or instantiatin.
6625 ///
6626 /// \param PrevPointOfInstantiation if valid, indicates where the previus
6627 /// declaration was instantiated (either implicitly or explicitly).
6628 ///
6629 /// \param HasNoEffect will be set to true to indicate that the new
6630 /// specialization or instantiation has no effect and should be ignored.
6631 ///
6632 /// \returns true if there was an error that should prevent the introduction of
6633 /// the new declaration into the AST, false otherwise.
6634 bool
6637  NamedDecl *PrevDecl,
6639  SourceLocation PrevPointOfInstantiation,
6640  bool &HasNoEffect) {
6641  HasNoEffect = false;
6642 
6643  switch (NewTSK) {
6644  case TSK_Undeclared:
6646  assert(
6647  (PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) &&
6648  "previous declaration must be implicit!");
6649  return false;
6650 
6652  switch (PrevTSK) {
6653  case TSK_Undeclared:
6655  // Okay, we're just specializing something that is either already
6656  // explicitly specialized or has merely been mentioned without any
6657  // instantiation.
6658  return false;
6659 
6661  if (PrevPointOfInstantiation.isInvalid()) {
6662  // The declaration itself has not actually been instantiated, so it is
6663  // still okay to specialize it.
6664  StripImplicitInstantiation(PrevDecl);
6665  return false;
6666  }
6667  // Fall through
6668 
6671  assert((PrevTSK == TSK_ImplicitInstantiation ||
6672  PrevPointOfInstantiation.isValid()) &&
6673  "Explicit instantiation without point of instantiation?");
6674 
6675  // C++ [temp.expl.spec]p6:
6676  // If a template, a member template or the member of a class template
6677  // is explicitly specialized then that specialization shall be declared
6678  // before the first use of that specialization that would cause an
6679  // implicit instantiation to take place, in every translation unit in
6680  // which such a use occurs; no diagnostic is required.
6681  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
6682  // Is there any previous explicit specialization declaration?
6684  return false;
6685  }
6686 
6687  Diag(NewLoc, diag::err_specialization_after_instantiation)
6688  << PrevDecl;
6689  Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
6690  << (PrevTSK != TSK_ImplicitInstantiation);
6691 
6692  return true;
6693  }
6694 
6696  switch (PrevTSK) {
6698  // This explicit instantiation declaration is redundant (that's okay).
6699  HasNoEffect = true;
6700  return false;
6701 
6702  case TSK_Undeclared:
6704  // We're explicitly instantiating something that may have already been
6705  // implicitly instantiated; that's fine.
6706  return false;
6707 
6709  // C++0x [temp.explicit]p4:
6710  // For a given set of template parameters, if an explicit instantiation
6711  // of a template appears after a declaration of an explicit
6712  // specialization for that template, the explicit instantiation has no
6713  // effect.
6714  HasNoEffect = true;
6715  return false;
6716 
6718  // C++0x [temp.explicit]p10:
6719  // If an entity is the subject of both an explicit instantiation
6720  // declaration and an explicit instantiation definition in the same
6721  // translation unit, the definition shall follow the declaration.
6722  Diag(NewLoc,
6723  diag::err_explicit_instantiation_declaration_after_definition);
6724 
6725  // Explicit instantiations following a specialization have no effect and
6726  // hence no PrevPointOfInstantiation. In that case, walk decl backwards
6727  // until a valid name loc is found.
6728  Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
6729  diag::note_explicit_instantiation_definition_here);
6730  HasNoEffect = true;
6731  return false;
6732  }
6733 
6735  switch (PrevTSK) {
6736  case TSK_Undeclared:
6738  // We're explicitly instantiating something that may have already been
6739  // implicitly instantiated; that's fine.
6740  return false;
6741 
6743  // C++ DR 259, C++0x [temp.explicit]p4:
6744  // For a given set of template parameters, if an explicit
6745  // instantiation of a template appears after a declaration of
6746  // an explicit specialization for that template, the explicit
6747  // instantiation has no effect.
6748  //
6749  // In C++98/03 mode, we only give an extension warning here, because it
6750  // is not harmful to try to explicitly instantiate something that
6751  // has been explicitly specialized.
6752  Diag(NewLoc, getLangOpts().CPlusPlus11 ?
6753  diag::warn_cxx98_compat_explicit_instantiation_after_specialization :
6754  diag::ext_explicit_instantiation_after_specialization)
6755  << PrevDecl;
6756  Diag(PrevDecl->getLocation(),
6757  diag::note_previous_template_specialization);
6758  HasNoEffect = true;
6759  return false;
6760 
6762  // We're explicity instantiating a definition for something for which we
6763  // were previously asked to suppress instantiations. That's fine.
6764 
6765  // C++0x [temp.explicit]p4:
6766  // For a given set of template parameters, if an explicit instantiation
6767  // of a template appears after a declaration of an explicit
6768  // specialization for that template, the explicit instantiation has no
6769  // effect.
6770  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
6771  // Is there any previous explicit specialization declaration?
6773  HasNoEffect = true;
6774  break;
6775  }
6776  }
6777 
6778  return false;
6779 
6781  // C++0x [temp.spec]p5:
6782  // For a given template and a given set of template-arguments,
6783  // - an explicit instantiation definition shall appear at most once
6784  // in a program,
6785 
6786  // MSVCCompat: MSVC silently ignores duplicate explicit instantiations.
6787  Diag(NewLoc, (getLangOpts().MSVCCompat)
6788  ? diag::ext_explicit_instantiation_duplicate
6789  : diag::err_explicit_instantiation_duplicate)
6790  << PrevDecl;
6791  Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
6792  diag::note_previous_explicit_instantiation);
6793  HasNoEffect = true;
6794  return false;
6795  }
6796  }
6797 
6798  llvm_unreachable("Missing specialization/instantiation case?");
6799 }
6800 
6801 /// \brief Perform semantic analysis for the given dependent function
6802 /// template specialization.
6803 ///
6804 /// The only possible way to get a dependent function template specialization
6805 /// is with a friend declaration, like so:
6806 ///
6807 /// \code
6808 /// template <class T> void foo(T);
6809 /// template <class T> class A {
6810 /// friend void foo<>(T);
6811 /// };
6812 /// \endcode
6813 ///
6814 /// There really isn't any useful analysis we can do here, so we
6815 /// just store the information.
6816 bool
6818  const TemplateArgumentListInfo &ExplicitTemplateArgs,
6820  // Remove anything from Previous that isn't a function template in
6821  // the correct context.
6822  DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
6823  LookupResult::Filter F = Previous.makeFilter();
6824  while (F.hasNext()) {
6825  NamedDecl *D = F.next()->getUnderlyingDecl();
6826  if (!isa<FunctionTemplateDecl>(D) ||
6827  !FDLookupContext->InEnclosingNamespaceSetOf(
6828  D->getDeclContext()->getRedeclContext()))
6829  F.erase();
6830  }
6831  F.done();
6832 
6833  // Should this be diagnosed here?
6834  if (Previous.empty()) return true;
6835 
6837  ExplicitTemplateArgs);
6838  return false;
6839 }
6840 
6841 /// \brief Perform semantic analysis for the given function template
6842 /// specialization.
6843 ///
6844 /// This routine performs all of the semantic analysis required for an
6845 /// explicit function template specialization. On successful completion,
6846 /// the function declaration \p FD will become a function template
6847 /// specialization.
6848 ///
6849 /// \param FD the function declaration, which will be updated to become a
6850 /// function template specialization.
6851 ///
6852 /// \param ExplicitTemplateArgs the explicitly-provided template arguments,
6853 /// if any. Note that this may be valid info even when 0 arguments are
6854 /// explicitly provided as in, e.g., \c void sort<>(char*, char*);
6855 /// as it anyway contains info on the angle brackets locations.
6856 ///
6857 /// \param Previous the set of declarations that may be specialized by
6858 /// this function specialization.
6860  FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
6862  // The set of function template specializations that could match this
6863  // explicit function template specialization.
6864  UnresolvedSet<8> Candidates;
6865  TemplateSpecCandidateSet FailedCandidates(FD->getLocation(),
6866  /*ForTakingAddress=*/false);
6867 
6868  llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
6869  ConvertedTemplateArgs;
6870 
6871  DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
6872  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6873  I != E; ++I) {
6874  NamedDecl *Ovl = (*I)->getUnderlyingDecl();
6875  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) {
6876  // Only consider templates found within the same semantic lookup scope as
6877  // FD.
6878  if (!FDLookupContext->InEnclosingNamespaceSetOf(
6879  Ovl->getDeclContext()->getRedeclContext()))
6880  continue;
6881 
6882  // When matching a constexpr member function template specialization
6883  // against the primary template, we don't yet know whether the
6884  // specialization has an implicit 'const' (because we don't know whether
6885  // it will be a static member function until we know which template it
6886  // specializes), so adjust it now assuming it specializes this template.
6887  QualType FT = FD->getType();
6888  if (FD->isConstexpr()) {
6889  CXXMethodDecl *OldMD =
6890  dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
6891  if (OldMD && OldMD->isConst()) {
6892  const FunctionProtoType *FPT = FT->castAs<FunctionProtoType>();
6896  FPT->getParamTypes(), EPI);
6897  }
6898  }
6899 
6901  if (ExplicitTemplateArgs)
6902  Args = *ExplicitTemplateArgs;
6903 
6904  // C++ [temp.expl.spec]p11:
6905  // A trailing template-argument can be left unspecified in the
6906  // template-id naming an explicit function template specialization
6907  // provided it can be deduced from the function argument type.
6908  // Perform template argument deduction to determine whether we may be
6909  // specializing this template.
6910  // FIXME: It is somewhat wasteful to build
6911  TemplateDeductionInfo Info(FailedCandidates.getLocation());
6912  FunctionDecl *Specialization = nullptr;
6914  cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
6915  ExplicitTemplateArgs ? &Args : nullptr, FT, Specialization,
6916  Info)) {
6917  // Template argument deduction failed; record why it failed, so
6918  // that we can provide nifty diagnostics.
6919  FailedCandidates.addCandidate().set(
6920  I.getPair(), FunTmpl->getTemplatedDecl(),
6921  MakeDeductionFailureInfo(Context, TDK, Info));
6922  (void)TDK;
6923  continue;
6924  }
6925 
6926  // Record this candidate.
6927  if (ExplicitTemplateArgs)
6928  ConvertedTemplateArgs[Specialization] = std::move(Args);
6929  Candidates.addDecl(Specialization, I.getAccess());
6930  }
6931  }
6932 
6933  // Find the most specialized function template.
6934  UnresolvedSetIterator Result = getMostSpecialized(
6935  Candidates.begin(), Candidates.end(), FailedCandidates,
6936  FD->getLocation(),
6937  PDiag(diag::err_function_template_spec_no_match) << FD->getDeclName(),
6938  PDiag(diag::err_function_template_spec_ambiguous)
6939  << FD->getDeclName() << (ExplicitTemplateArgs != nullptr),
6940  PDiag(diag::note_function_template_spec_matched));
6941 
6942  if (Result == Candidates.end())
6943  return true;
6944 
6945  // Ignore access information; it doesn't figure into redeclaration checking.
6946  FunctionDecl *Specialization = cast<FunctionDecl>(*Result);
6947 
6948  // C++ Concepts TS [dcl.spec.concept]p7: A program shall not declare [...]
6949  // an explicit specialization (14.8.3) [...] of a concept definition.
6950  if (Specialization->getPrimaryTemplate()->isConcept()) {
6951  Diag(FD->getLocation(), diag::err_concept_specialized)
6952  << 0 /*function*/ << 1 /*explicitly specialized*/;
6953  Diag(Specialization->getLocation(), diag::note_previous_declaration);
6954  return true;
6955  }
6956 
6958  = Specialization->getTemplateSpecializationInfo();
6959  assert(SpecInfo && "Function template specialization info missing?");
6960 
6961  // Note: do not overwrite location info if previous template
6962  // specialization kind was explicit.
6964  if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation) {
6965  Specialization->setLocation(FD->getLocation());
6966  // C++11 [dcl.constexpr]p1: An explicit specialization of a constexpr
6967  // function can differ from the template declaration with respect to
6968  // the constexpr specifier.
6969  Specialization->setConstexpr(FD->isConstexpr());
6970  }
6971 
6972  // FIXME: Check if the prior specialization has a point of instantiation.
6973  // If so, we have run afoul of .
6974 
6975  // If this is a friend declaration, then we're not really declaring
6976  // an explicit specialization.
6977  bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None);
6978 
6979  // Check the scope of this explicit specialization.
6980  if (!isFriend &&
6982  Specialization->getPrimaryTemplate(),
6983  Specialization, FD->getLocation(),
6984  false))
6985  return true;
6986 
6987  // C++ [temp.expl.spec]p6:
6988  // If a template, a member template or the member of a class template is
6989  // explicitly specialized then that specialization shall be declared
6990  // before the first use of that specialization that would cause an implicit
6991  // instantiation to take place, in every translation unit in which such a
6992  // use occurs; no diagnostic is required.
6993  bool HasNoEffect = false;
6994  if (!isFriend &&
6995  CheckSpecializationInstantiationRedecl(FD->getLocation(),
6997  Specialization,
6998  SpecInfo->getTemplateSpecializationKind(),
6999  SpecInfo->getPointOfInstantiation(),
7000  HasNoEffect))
7001  return true;
7002 
7003  // Mark the prior declaration as an explicit specialization, so that later
7004  // clients know that this is an explicit specialization.
7005  if (!isFriend) {
7006  // Since explicit specializations do not inherit '=delete' from their
7007  // primary function template - check if the 'specialization' that was
7008  // implicitly generated (during template argument deduction for partial
7009  // ordering) from the most specialized of all the function templates that
7010  // 'FD' could have been specializing, has a 'deleted' definition. If so,
7011  // first check that it was implicitly generated during template argument
7012  // deduction by making sure it wasn't referenced, and then reset the deleted
7013  // flag to not-deleted, so that we can inherit that information from 'FD'.
7014  if (Specialization->isDeleted() && !SpecInfo->isExplicitSpecialization() &&
7015  !Specialization->getCanonicalDecl()->isReferenced()) {
7016  assert(
7017  Specialization->getCanonicalDecl() == Specialization &&
7018  "This must be the only existing declaration of this specialization");
7019  Specialization->setDeletedAsWritten(false);
7020  }
7022  MarkUnusedFileScopedDecl(Specialization);
7023  }
7024 
7025  // Turn the given function declaration into a function template
7026  // specialization, with the template arguments from the previous
7027  // specialization.
7028  // Take copies of (semantic and syntactic) template argument lists.
7029  const TemplateArgumentList* TemplArgs = new (Context)
7030  TemplateArgumentList(Specialization->getTemplateSpecializationArgs());
7031  FD->setFunctionTemplateSpecialization(
7032  Specialization->getPrimaryTemplate(), TemplArgs, /*InsertPos=*/nullptr,
7033  SpecInfo->getTemplateSpecializationKind(),
7034  ExplicitTemplateArgs ? &ConvertedTemplateArgs[Specialization] : nullptr);
7035 
7036  // The "previous declaration" for this function template specialization is
7037  // the prior function template specialization.
7038  Previous.clear();
7039  Previous.addDecl(Specialization);
7040  return false;
7041 }
7042 
7043 /// \brief Perform semantic analysis for the given non-template member
7044 /// specialization.
7045 ///
7046 /// This routine performs all of the semantic analysis required for an
7047 /// explicit member function specialization. On successful completion,
7048 /// the function declaration \p FD will become a member function
7049 /// specialization.
7050 ///
7051 /// \param Member the member declaration, which will be updated to become a
7052 /// specialization.
7053 ///
7054 /// \param Previous the set of declarations, one of which may be specialized
7055 /// by this function specialization; the set will be modified to contain the
7056 /// redeclared member.
7057 bool
7059  assert(!isa<TemplateDecl>(Member) && "Only for non-template members");
7060 
7061  // Try to find the member we are instantiating.
7062  NamedDecl *FoundInstantiation = nullptr;
7063  NamedDecl *Instantiation = nullptr;
7064  NamedDecl *InstantiatedFrom = nullptr;
7065  MemberSpecializationInfo *MSInfo = nullptr;
7066 
7067  if (Previous.empty()) {
7068  // Nowhere to look anyway.
7069  } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Member)) {
7070  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
7071  I != E; ++I) {
7072  NamedDecl *D = (*I)->getUnderlyingDecl();
7073  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
7074  QualType Adjusted = Function->getType();
7075  if (!hasExplicitCallingConv(Adjusted))
7076  Adjusted = adjustCCAndNoReturn(Adjusted, Method->getType());
7077  if (Context.hasSameType(Adjusted, Method->getType())) {
7078  FoundInstantiation = *I;
7079  Instantiation = Method;
7080  InstantiatedFrom = Method->getInstantiatedFromMemberFunction();
7081  MSInfo = Method->getMemberSpecializationInfo();
7082  break;
7083  }
7084  }
7085  }
7086  } else if (isa<VarDecl>(Member)) {
7087  VarDecl *PrevVar;
7088  if (Previous.isSingleResult() &&
7089  (PrevVar = dyn_cast<VarDecl>(Previous.getFoundDecl())))
7090  if (PrevVar->isStaticDataMember()) {
7091  FoundInstantiation = Previous.getRepresentativeDecl();
7092  Instantiation = PrevVar;
7093  InstantiatedFrom = PrevVar->getInstantiatedFromStaticDataMember();
7094  MSInfo = PrevVar->getMemberSpecializationInfo();
7095  }
7096  } else if (isa<RecordDecl>(Member)) {
7097  CXXRecordDecl *PrevRecord;
7098  if (Previous.isSingleResult() &&
7099  (PrevRecord = dyn_cast<CXXRecordDecl>(Previous.getFoundDecl()))) {
7100  FoundInstantiation = Previous.getRepresentativeDecl();
7101  Instantiation = PrevRecord;
7102  InstantiatedFrom = PrevRecord->getInstantiatedFromMemberClass();
7103  MSInfo = PrevRecord->getMemberSpecializationInfo();
7104  }
7105  } else if (isa<EnumDecl>(Member)) {
7106  EnumDecl *PrevEnum;
7107  if (Previous.isSingleResult() &&
7108  (PrevEnum = dyn_cast<EnumDecl>(Previous.getFoundDecl()))) {
7109  FoundInstantiation = Previous.getRepresentativeDecl();
7110  Instantiation = PrevEnum;
7111  InstantiatedFrom = PrevEnum->getInstantiatedFromMemberEnum();
7112  MSInfo = PrevEnum->getMemberSpecializationInfo();
7113  }
7114  }
7115 
7116  if (!Instantiation) {
7117  // There is no previous declaration that matches. Since member
7118  // specializations are always out-of-line, the caller will complain about
7119  // this mismatch later.
7120  return false;
7121  }
7122 
7123  // If this is a friend, just bail out here before we start turning
7124  // things into explicit specializations.
7125  if (Member->getFriendObjectKind() != Decl::FOK_None) {
7126  // Preserve instantiation information.
7127  if (InstantiatedFrom && isa<CXXMethodDecl>(Member)) {
7128  cast<CXXMethodDecl>(Member)->setInstantiationOfMemberFunction(
7129  cast<CXXMethodDecl>(InstantiatedFrom),
7130  cast<CXXMethodDecl>(Instantiation)->getTemplateSpecializationKind());
7131  } else if (InstantiatedFrom && isa<CXXRecordDecl>(Member)) {
7132  cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
7133  cast<CXXRecordDecl>(InstantiatedFrom),
7134  cast<CXXRecordDecl>(Instantiation)->getTemplateSpecializationKind());
7135  }
7136 
7137  Previous.clear();
7138  Previous.addDecl(FoundInstantiation);
7139  return false;
7140  }
7141 
7142  // Make sure that this is a specialization of a member.
7143  if (!InstantiatedFrom) {
7144  Diag(Member->getLocation(), diag::err_spec_member_not_instantiated)
7145  << Member;
7146  Diag(Instantiation->getLocation(), diag::note_specialized_decl);
7147  return true;
7148  }
7149 
7150  // C++ [temp.expl.spec]p6:
7151  // If a template, a member template or the member of a class template is
7152  // explicitly specialized then that specialization shall be declared
7153  // before the first use of that specialization that would cause an implicit
7154  // instantiation to take place, in every translation unit in which such a
7155  // use occurs; no diagnostic is required.
7156  assert(MSInfo && "Member specialization info missing?");
7157 
7158  bool HasNoEffect = false;
7159  if (CheckSpecializationInstantiationRedecl(Member->getLocation(),
7161  Instantiation,
7163  MSInfo->getPointOfInstantiation(),
7164  HasNoEffect))
7165  return true;
7166 
7167  // Check the scope of this explicit specialization.
7169  InstantiatedFrom,
7170  Instantiation, Member->getLocation(),
7171  false))
7172  return true;
7173 
7174  // Note that this is an explicit instantiation of a member.
7175  // the original declaration to note that it is an explicit specialization
7176  // (if it was previously an implicit instantiation). This latter step
7177  // makes bookkeeping easier.
7178  if (isa<FunctionDecl>(Member)) {
7179  FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
7180  if (InstantiationFunction->getTemplateSpecializationKind() ==
7182  InstantiationFunction->setTemplateSpecializationKind(
7184  InstantiationFunction->setLocation(Member->getLocation());
7185  // Explicit specializations of member functions of class templates do not
7186  // inherit '=delete' from the member function they are specializing.
7187  if (InstantiationFunction->isDeleted()) {
7188  assert(InstantiationFunction->getCanonicalDecl() ==
7189  InstantiationFunction);
7190  InstantiationFunction->setDeletedAsWritten(false);
7191  }
7192  }
7193 
7194  cast<FunctionDecl>(Member)->setInstantiationOfMemberFunction(
7195  cast<CXXMethodDecl>(InstantiatedFrom),
7197  MarkUnusedFileScopedDecl(InstantiationFunction);
7198  } else if (isa<VarDecl>(Member)) {
7199  VarDecl *InstantiationVar = cast<VarDecl>(Instantiation);
7200  if (InstantiationVar->getTemplateSpecializationKind() ==
7202  InstantiationVar->setTemplateSpecializationKind(
7204  InstantiationVar->setLocation(Member->getLocation());
7205  }
7206 
7207  cast<VarDecl>(Member)->setInstantiationOfStaticDataMember(
7208  cast<VarDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
7209  MarkUnusedFileScopedDecl(InstantiationVar);
7210  } else if (isa<CXXRecordDecl>(Member)) {
7211  CXXRecordDecl *InstantiationClass = cast<CXXRecordDecl>(Instantiation);
7212  if (InstantiationClass->getTemplateSpecializationKind() ==
7214  InstantiationClass->setTemplateSpecializationKind(
7216  InstantiationClass->setLocation(Member->getLocation());
7217  }
7218 
7219  cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
7220  cast<CXXRecordDecl>(InstantiatedFrom),
7222  } else {
7223  assert(isa<EnumDecl>(Member) && "Only member enums remain");
7224  EnumDecl *InstantiationEnum = cast<EnumDecl>(Instantiation);
7225  if (InstantiationEnum->getTemplateSpecializationKind() ==
7227  InstantiationEnum->setTemplateSpecializationKind(
7229  InstantiationEnum->setLocation(Member->getLocation());
7230  }
7231 
7232  cast<EnumDecl>(Member)->setInstantiationOfMemberEnum(
7233  cast<EnumDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
7234  }
7235 
7236  // Save the caller the trouble of having to figure out which declaration
7237  // this specialization matches.
7238  Previous.clear();
7239  Previous.addDecl(FoundInstantiation);
7240  return false;
7241 }
7242 
7243 /// \brief Check the scope of an explicit instantiation.
7244 ///
7245 /// \returns true if a serious error occurs, false otherwise.
7247  SourceLocation InstLoc,
7248  bool WasQualifiedName) {
7249  DeclContext *OrigContext= D->getDeclContext()->getEnclosingNamespaceContext();
7250  DeclContext *CurContext = S.CurContext->getRedeclContext();
7251 
7252  if (CurContext->isRecord()) {
7253  S.Diag(InstLoc, diag::err_explicit_instantiation_in_class)
7254  << D;
7255  return true;
7256  }
7257 
7258  // C++11 [temp.explicit]p3:
7259  // An explicit instantiation shall appear in an enclosing namespace of its
7260  // template. If the name declared in the explicit instantiation is an
7261  // unqualified name, the explicit instantiation shall appear in the
7262  // namespace where its template is declared or, if that namespace is inline
7263  // (7.3.1), any namespace from its enclosing namespace set.
7264  //
7265  // This is DR275, which we do not retroactively apply to C++98/03.
7266  if (WasQualifiedName) {
7267  if (CurContext->Encloses(OrigContext))
7268  return false;
7269  } else {
7270  if (CurContext->InEnclosingNamespaceSetOf(OrigContext))
7271  return false;
7272  }
7273 
7274  if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
7275  if (WasQualifiedName)
7276  S.Diag(InstLoc,
7277  S.getLangOpts().CPlusPlus11?
7278  diag::err_explicit_instantiation_out_of_scope :
7279  diag::warn_explicit_instantiation_out_of_scope_0x)
7280  << D << NS;
7281  else
7282  S.Diag(InstLoc,
7283  S.getLangOpts().CPlusPlus11?
7284  diag::err_explicit_instantiation_unqualified_wrong_namespace :
7285  diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
7286  << D << NS;
7287  } else
7288  S.Diag(InstLoc,
7289  S.getLangOpts().CPlusPlus11?
7290  diag::err_explicit_instantiation_must_be_global :
7291  diag::warn_explicit_instantiation_must_be_global_0x)
7292  << D;
7293  S.Diag(D->getLocation(), diag::note_explicit_instantiation_here);
7294  return false;
7295 }
7296 
7297 /// \brief Determine whether the given scope specifier has a template-id in it.
7299  if (!SS.isSet())
7300  return false;
7301 
7302  // C++11 [temp.explicit]p3:
7303  // If the explicit instantiation is for a member function, a member class
7304  // or a static data member of a class template specialization, the name of
7305  // the class template specialization in the qualified-id for the member
7306  // name shall be a simple-template-id.
7307  //
7308  // C++98 has the same restriction, just worded differently.
7309  for (NestedNameSpecifier *NNS = SS.getScopeRep(); NNS;
7310  NNS = NNS->getPrefix())
7311  if (const Type *T = NNS->getAsType())
7312  if (isa<TemplateSpecializationType>(T))
7313  return true;
7314 
7315  return false;
7316 }
7317 
7318 // Explicit instantiation of a class template specialization
7319 DeclResult
7321  SourceLocation ExternLoc,
7322  SourceLocation TemplateLoc,
7323  unsigned TagSpec,
7324  SourceLocation KWLoc,
7325  const CXXScopeSpec &SS,
7326  TemplateTy TemplateD,
7327  SourceLocation TemplateNameLoc,
7328  SourceLocation LAngleLoc,
7329  ASTTemplateArgsPtr TemplateArgsIn,
7330  SourceLocation RAngleLoc,
7331  AttributeList *Attr) {
7332  // Find the class template we're specializing
7333  TemplateName Name = TemplateD.get();
7334  TemplateDecl *TD = Name.getAsTemplateDecl();
7335  // Check that the specialization uses the same tag kind as the
7336  // original template.
7338  assert(Kind != TTK_Enum &&
7339  "Invalid enum tag in class template explicit instantiation!");
7340 
7341  ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(TD);
7342 
7343  if (!ClassTemplate) {
7344  unsigned ErrorKind = 0;
7345  if (isa<TypeAliasTemplateDecl>(TD)) {
7346  ErrorKind = 4;
7347  } else if (isa<TemplateTemplateParmDecl>(TD)) {
7348  ErrorKind = 5;
7349  }
7350 
7351  Diag(TemplateNameLoc, diag::err_tag_reference_non_tag) << ErrorKind;
7352  Diag(TD->getLocation(), diag::note_previous_use);
7353  return true;
7354  }
7355 
7356  if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
7357  Kind, /*isDefinition*/false, KWLoc,
7358  ClassTemplate->getIdentifier())) {
7359  Diag(KWLoc, diag::err_use_with_wrong_tag)
7360  << ClassTemplate
7362  ClassTemplate->getTemplatedDecl()->getKindName());
7363  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
7364  diag::note_previous_use);
7365  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
7366  }
7367 
7368  // C++0x [temp.explicit]p2:
7369  // There are two forms of explicit instantiation: an explicit instantiation
7370  // definition and an explicit instantiation declaration. An explicit
7371  // instantiation declaration begins with the extern keyword. [...]
7372  TemplateSpecializationKind TSK = ExternLoc.isInvalid()
7375 
7377  // Check for dllexport class template instantiation declarations.
7378  for (AttributeList *A = Attr; A; A = A->getNext()) {
7379  if (A->getKind() == AttributeList::AT_DLLExport) {
7380  Diag(ExternLoc,
7381  diag::warn_attribute_dllexport_explicit_instantiation_decl);
7382  Diag(A->getLoc(), diag::note_attribute);
7383  break;
7384  }
7385  }
7386 
7387  if (auto *A = ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
7388  Diag(ExternLoc,
7389  diag::warn_attribute_dllexport_explicit_instantiation_decl);
7390  Diag(A->getLocation(), diag::note_attribute);
7391  }
7392  }
7393 
7394  // In MSVC mode, dllimported explicit instantiation definitions are treated as
7395  // instantiation declarations for most purposes.
7396  bool DLLImportExplicitInstantiationDef = false;
7399  // Check for dllimport class template instantiation definitions.
7400  bool DLLImport =
7401  ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
7402  for (AttributeList *A = Attr; A; A = A->getNext()) {
7403  if (A->getKind() == AttributeList::AT_DLLImport)
7404  DLLImport = true;
7405  if (A->getKind() == AttributeList::AT_DLLExport) {
7406  // dllexport trumps dllimport here.
7407  DLLImport = false;
7408  break;
7409  }
7410  }
7411  if (DLLImport) {
7413  DLLImportExplicitInstantiationDef = true;
7414  }
7415  }
7416 
7417  // Translate the parser's template argument list in our AST format.
7418  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
7419  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
7420 
7421  // Check that the template argument list is well-formed for this
7422  // template.
7424  if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
7425  TemplateArgs, false, Converted))
7426  return true;
7427 
7428  // Find the class template specialization declaration that
7429  // corresponds to these arguments.
7430  void *InsertPos = nullptr;
7432  = ClassTemplate->findSpecialization(Converted, InsertPos);
7433 
7434  TemplateSpecializationKind PrevDecl_TSK
7435  = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared;
7436 
7437  // C++0x [temp.explicit]p2:
7438  // [...] An explicit instantiation shall appear in an enclosing
7439  // namespace of its template. [...]
7440  //
7441  // This is C++ DR 275.
7442  if (CheckExplicitInstantiationScope(*this, ClassTemplate, TemplateNameLoc,
7443  SS.isSet()))
7444  return true;
7445 
7446  ClassTemplateSpecializationDecl *Specialization = nullptr;
7447 
7448  bool HasNoEffect = false;
7449  if (PrevDecl) {
7450  if (CheckSpecializationInstantiationRedecl(TemplateNameLoc, TSK,
7451  PrevDecl, PrevDecl_TSK,
7452  PrevDecl->getPointOfInstantiation(),
7453  HasNoEffect))
7454  return PrevDecl;
7455 
7456  // Even though HasNoEffect == true means that this explicit instantiation
7457  // has no effect on semantics, we go on to put its syntax in the AST.
7458 
7459  if (PrevDecl_TSK == TSK_ImplicitInstantiation ||
7460  PrevDecl_TSK == TSK_Undeclared) {
7461  // Since the only prior class template specialization with these
7462  // arguments was referenced but not declared, reuse that
7463  // declaration node as our own, updating the source location
7464  // for the template name to reflect our new declaration.
7465  // (Other source locations will be updated later.)
7466  Specialization = PrevDecl;
7467  Specialization->setLocation(TemplateNameLoc);
7468  PrevDecl = nullptr;
7469  }
7470 
7471  if (PrevDecl_TSK == TSK_ExplicitInstantiationDeclaration &&
7472  DLLImportExplicitInstantiationDef) {
7473  // The new specialization might add a dllimport attribute.
7474  HasNoEffect = false;
7475  }
7476  }
7477 
7478  if (!Specialization) {
7479  // Create a new class template specialization declaration node for
7480  // this explicit specialization.
7481  Specialization
7483  ClassTemplate->getDeclContext(),
7484  KWLoc, TemplateNameLoc,
7485  ClassTemplate,
7486  Converted,
7487  PrevDecl);
7488  SetNestedNameSpecifier(Specialization, SS);
7489 
7490  if (!HasNoEffect && !PrevDecl) {
7491  // Insert the new specialization.
7492  ClassTemplate->AddSpecialization(Specialization, InsertPos);
7493  }
7494  }
7495 
7496  // Build the fully-sugared type for this explicit instantiation as
7497  // the user wrote in the explicit instantiation itself. This means
7498  // that we'll pretty-print the type retrieved from the
7499  // specialization's declaration the way that the user actually wrote
7500  // the explicit instantiation, rather than formatting the name based
7501  // on the "canonical" representation used to store the template
7502  // arguments in the specialization.
7503  TypeSourceInfo *WrittenTy
7504  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
7505  TemplateArgs,
7506  Context.getTypeDeclType(Specialization));
7507  Specialization->setTypeAsWritten(WrittenTy);
7508 
7509  // Set source locations for keywords.
7510  Specialization->setExternLoc(ExternLoc);
7511  Specialization->setTemplateKeywordLoc(TemplateLoc);
7512  Specialization->setBraceRange(SourceRange());
7513 
7514  if (Attr)
7515  ProcessDeclAttributeList(S, Specialization, Attr);
7516 
7517  // Add the explicit instantiation into its lexical context. However,
7518  // since explicit instantiations are never found by name lookup, we
7519  // just put it into the declaration context directly.
7520  Specialization->setLexicalDeclContext(CurContext);
7521  CurContext->addDecl(Specialization);
7522 
7523  // Syntax is now OK, so return if it has no other effect on semantics.
7524  if (HasNoEffect) {
7525  // Set the template specialization kind.
7526  Specialization->setTemplateSpecializationKind(TSK);
7527  return Specialization;
7528  }
7529 
7530  // C++ [temp.explicit]p3:
7531  // A definition of a class template or class member template
7532  // shall be in scope at the point of the explicit instantiation of
7533  // the class template or class member template.
7534  //
7535  // This check comes when we actually try to perform the
7536  // instantiation.
7538  = cast_or_null<ClassTemplateSpecializationDecl>(
7539  Specialization->getDefinition());
7540  if (!Def)
7541  InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK);
7542  else if (TSK == TSK_ExplicitInstantiationDefinition) {
7543  MarkVTableUsed(TemplateNameLoc, Specialization, true);
7544  Specialization->setPointOfInstantiation(Def->getPointOfInstantiation());
7545  }
7546 
7547  // Instantiate the members of this class template specialization.
7548  Def = cast_or_null<ClassTemplateSpecializationDecl>(
7549  Specialization->getDefinition());
7550  if (Def) {
7552  // Fix a TSK_ExplicitInstantiationDeclaration followed by a
7553  // TSK_ExplicitInstantiationDefinition
7554  if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
7556  DLLImportExplicitInstantiationDef)) {
7557  // FIXME: Need to notify the ASTMutationListener that we did this.
7559 
7560  if (!getDLLAttr(Def) && getDLLAttr(Specialization) &&
7562  // In the MS ABI, an explicit instantiation definition can add a dll
7563  // attribute to a template with a previous instantiation declaration.
7564  // MinGW doesn't allow this.
7565  auto *A = cast<InheritableAttr>(
7566  getDLLAttr(Specialization)->clone(getASTContext()));
7567  A->setInherited(true);
7568  Def->addAttr(A);
7569 
7570  // We reject explicit instantiations in class scope, so there should
7571  // never be any delayed exported classes to worry about.
7572  assert(DelayedDllExportClasses.empty() &&
7573  "delayed exports present at explicit instantiation");
7574  checkClassLevelDLLAttribute(Def);
7575  referenceDLLExportedClassMethods();
7576 
7577  // Propagate attribute to base class templates.
7578  for (auto &B : Def->bases()) {
7579  if (auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
7580  B.getType()->getAsCXXRecordDecl()))
7581  propagateDLLAttrToBaseClassTemplate(Def, A, BT, B.getLocStart());
7582  }
7583  }
7584  }
7585 
7586  // Set the template specialization kind. Make sure it is set before
7587  // instantiating the members which will trigger ASTConsumer callbacks.
7588  Specialization->setTemplateSpecializationKind(TSK);
7589  InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK);
7590  } else {
7591 
7592  // Set the template specialization kind.
7593  Specialization->setTemplateSpecializationKind(TSK);
7594  }
7595 
7596  return Specialization;
7597 }
7598 
7599 // Explicit instantiation of a member class of a class template.
7600 DeclResult
7602  SourceLocation ExternLoc,
7603  SourceLocation TemplateLoc,
7604  unsigned TagSpec,
7605  SourceLocation KWLoc,
7606  CXXScopeSpec &SS,
7608  SourceLocation NameLoc,
7609  AttributeList *Attr) {
7610 
7611  bool Owned = false;
7612  bool IsDependent = false;
7613  Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference,
7614  KWLoc, SS, Name, NameLoc, Attr, AS_none,
7615  /*ModulePrivateLoc=*/SourceLocation(),
7616  MultiTemplateParamsArg(), Owned, IsDependent,
7617  SourceLocation(), false, TypeResult(),
7618  /*IsTypeSpecifier*/false);
7619  assert(!IsDependent && "explicit instantiation of dependent name not yet handled");
7620 
7621  if (!TagD)
7622  return true;
7623 
7624  TagDecl *Tag = cast<TagDecl>(TagD);
7625  assert(!Tag->isEnum() && "shouldn't see enumerations here");
7626 
7627  if (Tag->isInvalidDecl())
7628  return true;
7629 
7630  CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag);
7631  CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
7632  if (!Pattern) {
7633  Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
7634  << Context.getTypeDeclType(Record);
7635  Diag(Record->getLocation(), diag::note_nontemplate_decl_here);
7636  return true;
7637  }
7638 
7639  // C++0x [temp.explicit]p2:
7640  // If the explicit instantiation is for a class or member class, the
7641  // elaborated-type-specifier in the declaration shall include a
7642  // simple-template-id.
7643  //
7644  // C++98 has the same restriction, just worded differently.
7645  if (!ScopeSpecifierHasTemplateId(SS))
7646  Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
7647  << Record << SS.getRange();
7648 
7649  // C++0x [temp.explicit]p2:
7650  // There are two forms of explicit instantiation: an explicit instantiation
7651  // definition and an explicit instantiation declaration. An explicit
7652  // instantiation declaration begins with the extern keyword. [...]
7656 
7657  // C++0x [temp.explicit]p2:
7658  // [...] An explicit instantiation shall appear in an enclosing
7659  // namespace of its template. [...]
7660  //
7661  // This is C++ DR 275.
7662  CheckExplicitInstantiationScope(*this, Record, NameLoc, true);
7663 
7664  // Verify that it is okay to explicitly instantiate here.
7665  CXXRecordDecl *PrevDecl
7666  = cast_or_null<CXXRecordDecl>(Record->getPreviousDecl());
7667  if (!PrevDecl && Record->getDefinition())
7668  PrevDecl = Record;
7669  if (PrevDecl) {
7671  bool HasNoEffect = false;
7672  assert(MSInfo && "No member specialization information?");
7673  if (CheckSpecializationInstantiationRedecl(TemplateLoc, TSK,
7674  PrevDecl,
7676  MSInfo->getPointOfInstantiation(),
7677  HasNoEffect))
7678  return true;
7679  if (HasNoEffect)
7680  return TagD;
7681  }
7682 
7683  CXXRecordDecl *RecordDef
7684  = cast_or_null<CXXRecordDecl>(Record->getDefinition());
7685  if (!RecordDef) {
7686  // C++ [temp.explicit]p3:
7687  // A definition of a member class of a class template shall be in scope
7688  // at the point of an explicit instantiation of the member class.
7689  CXXRecordDecl *Def
7690  = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
7691  if (!Def) {
7692  Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
7693  << 0 << Record->getDeclName() << Record->getDeclContext();
7694  Diag(Pattern->getLocation(), diag::note_forward_declaration)
7695  << Pattern;
7696  return true;
7697  } else {
7698  if (InstantiateClass(NameLoc, Record, Def,
7699  getTemplateInstantiationArgs(Record),
7700  TSK))
7701  return true;
7702 
7703  RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition());
7704  if (!RecordDef)
7705  return true;
7706  }
7707  }
7708 
7709  // Instantiate all of the members of the class.
7710  InstantiateClassMembers(NameLoc, RecordDef,
7711  getTemplateInstantiationArgs(Record), TSK);
7712 
7714  MarkVTableUsed(NameLoc, RecordDef, true);
7715 
7716  // FIXME: We don't have any representation for explicit instantiations of
7717  // member classes. Such a representation is not needed for compilation, but it
7718  // should be available for clients that want to see all of the declarations in
7719  // the source code.
7720  return TagD;
7721 }
7722 
7724  SourceLocation ExternLoc,
7725  SourceLocation TemplateLoc,
7726  Declarator &D) {
7727  // Explicit instantiations always require a name.
7728  // TODO: check if/when DNInfo should replace Name.
7729  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
7730  DeclarationName Name = NameInfo.getName();
7731  if (!Name) {
7732  if (!D.isInvalidType())
7734  diag::err_explicit_instantiation_requires_name)
7735  << D.getDeclSpec().getSourceRange()
7736  << D.getSourceRange();
7737 
7738  return true;
7739  }
7740 
7741  // The scope passed in may not be a decl scope. Zip up the scope tree until
7742  // we find one that is.
7743  while ((S->getFlags() & Scope::DeclScope) == 0 ||
7744  (S->getFlags() & Scope::TemplateParamScope) != 0)
7745  S = S->getParent();
7746 
7747  // Determine the type of the declaration.
7748  TypeSourceInfo *T = GetTypeForDeclarator(D, S);
7749  QualType R = T->getType();
7750  if (R.isNull())
7751  return true;
7752 
7753  // C++ [dcl.stc]p1:
7754  // A storage-class-specifier shall not be specified in [...] an explicit
7755  // instantiation (14.7.2) directive.
7757  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)
7758  << Name;
7759  return true;
7760  } else if (D.getDeclSpec().getStorageClassSpec()
7762  // Complain about then remove the storage class specifier.
7763  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)
7765 
7767  }
7768 
7769  // C++0x [temp.explicit]p1:
7770  // [...] An explicit instantiation of a function template shall not use the
7771  // inline or constexpr specifiers.
7772  // Presumably, this also applies to member functions of class templates as
7773  // well.
7774  if (D.getDeclSpec().isInlineSpecified())
7776  getLangOpts().CPlusPlus11 ?
7777  diag::err_explicit_instantiation_inline :
7778  diag::warn_explicit_instantiation_inline_0x)
7781  // FIXME: Add a fix-it to remove the 'constexpr' and add a 'const' if one is
7782  // not already specified.
7784  diag::err_explicit_instantiation_constexpr);
7785 
7786  // C++ Concepts TS [dcl.spec.concept]p1: The concept specifier shall be
7787  // applied only to the definition of a function template or variable template,
7788  // declared in namespace scope.
7789  if (D.getDeclSpec().isConceptSpecified()) {
7791  diag::err_concept_specified_specialization) << 0;
7792  return true;
7793  }
7794 
7795  // C++0x [temp.explicit]p2:
7796  // There are two forms of explicit instantiation: an explicit instantiation
7797  // definition and an explicit instantiation declaration. An explicit
7798  // instantiation declaration begins with the extern keyword. [...]
7802 
7803  LookupResult Previous(*this, NameInfo, LookupOrdinaryName);
7804  LookupParsedName(Previous, S, &D.getCXXScopeSpec());
7805 
7806  if (!R->isFunctionType()) {
7807  // C++ [temp.explicit]p1:
7808  // A [...] static data member of a class template can be explicitly
7809  // instantiated from the member definition associated with its class
7810  // template.
7811  // C++1y [temp.explicit]p1:
7812  // A [...] variable [...] template specialization can be explicitly
7813  // instantiated from its template.
7814  if (Previous.isAmbiguous())
7815  return true;
7816 
7817  VarDecl *Prev = Previous.getAsSingle<VarDecl>();
7818  VarTemplateDecl *PrevTemplate = Previous.getAsSingle<VarTemplateDecl>();
7819 
7820  if (!PrevTemplate) {
7821  if (!Prev || !Prev->isStaticDataMember()) {
7822  // We expect to see a data data member here.
7823  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
7824  << Name;
7825  for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
7826  P != PEnd; ++P)
7827  Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
7828  return true;
7829  }
7830 
7831  if (!Prev->getInstantiatedFromStaticDataMember()) {
7832  // FIXME: Check for explicit specialization?
7833  Diag(D.getIdentifierLoc(),
7834  diag::err_explicit_instantiation_data_member_not_instantiated)
7835  << Prev;
7836  Diag(Prev->getLocation(), diag::note_explicit_instantiation_here);
7837  // FIXME: Can we provide a note showing where this was declared?
7838  return true;
7839  }
7840  } else {
7841  // Explicitly instantiate a variable template.
7842 
7843  // C++1y [dcl.spec.auto]p6:
7844  // ... A program that uses auto or decltype(auto) in a context not
7845  // explicitly allowed in this section is ill-formed.
7846  //
7847  // This includes auto-typed variable template instantiations.
7848  if (R->isUndeducedType()) {
7849  Diag(T->getTypeLoc().getLocStart(),
7850  diag::err_auto_not_allowed_var_inst);
7851  return true;
7852  }
7853 
7855  // C++1y [temp.explicit]p3:
7856  // If the explicit instantiation is for a variable, the unqualified-id
7857  // in the declaration shall be a template-id.
7858  Diag(D.getIdentifierLoc(),
7859  diag::err_explicit_instantiation_without_template_id)
7860  << PrevTemplate;
7861  Diag(PrevTemplate->getLocation(),
7862  diag::note_explicit_instantiation_here);
7863  return true;
7864  }
7865 
7866  // C++ Concepts TS [dcl.spec.concept]p7: A program shall not declare an
7867  // explicit instantiation (14.8.2) [...] of a concept definition.
7868  if (PrevTemplate->isConcept()) {
7869  Diag(D.getIdentifierLoc(), diag::err_concept_specialized)
7870  << 1 /*variable*/ << 0 /*explicitly instantiated*/;
7871  Diag(PrevTemplate->getLocation(), diag::note_previous_declaration);
7872  return true;
7873  }
7874 
7875  // Translate the parser's template argument list into our AST format.
7876  TemplateArgumentListInfo TemplateArgs =
7878 
7879  DeclResult Res = CheckVarTemplateId(PrevTemplate, TemplateLoc,
7880  D.getIdentifierLoc(), TemplateArgs);
7881  if (Res.isInvalid())
7882  return true;
7883 
7884  // Ignore access control bits, we don't need them for redeclaration
7885  // checking.
7886  Prev = cast<VarDecl>(Res.get());
7887  }
7888 
7889  // C++0x [temp.explicit]p2:
7890  // If the explicit instantiation is for a member function, a member class
7891  // or a static data member of a class template specialization, the name of
7892  // the class template specialization in the qualified-id for the member
7893  // name shall be a simple-template-id.
7894  //
7895  // C++98 has the same restriction, just worded differently.
7896  //
7897  // This does not apply to variable template specializations, where the
7898  // template-id is in the unqualified-id instead.
7899  if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()) && !PrevTemplate)
7900  Diag(D.getIdentifierLoc(),
7901  diag::ext_explicit_instantiation_without_qualified_id)
7902  << Prev << D.getCXXScopeSpec().getRange();
7903 
7904  // Check the scope of this explicit instantiation.
7905  CheckExplicitInstantiationScope(*this, Prev, D.getIdentifierLoc(), true);
7906 
7907  // Verify that it is okay to explicitly instantiate here.
7910  bool HasNoEffect = false;
7911  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
7912  PrevTSK, POI, HasNoEffect))
7913  return true;
7914 
7915  if (!HasNoEffect) {
7916  // Instantiate static data member or variable template.
7917 
7918  Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
7919  if (PrevTemplate) {
7920  // Merge attributes.
7922  ProcessDeclAttributeList(S, Prev, Attr);
7923  }
7925  InstantiateVariableDefinition(D.getIdentifierLoc(), Prev);
7926  }
7927 
7928  // Check the new variable specialization against the parsed input.
7929  if (PrevTemplate && Prev && !Context.hasSameType(Prev->getType(), R)) {
7930  Diag(T->getTypeLoc().getLocStart(),
7931  diag::err_invalid_var_template_spec_type)
7932  << 0 << PrevTemplate << R << Prev->getType();
7933  Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
7934  << 2 << PrevTemplate->getDeclName();
7935  return true;
7936  }
7937 
7938  // FIXME: Create an ExplicitInstantiation node?
7939  return (Decl*) nullptr;
7940  }
7941 
7942  // If the declarator is a template-id, translate the parser's template
7943  // argument list into our AST format.
7944  bool HasExplicitTemplateArgs = false;
7945  TemplateArgumentListInfo TemplateArgs;
7947  TemplateArgs = makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);
7948  HasExplicitTemplateArgs = true;
7949  }
7950 
7951  // C++ [temp.explicit]p1:
7952  // A [...] function [...] can be explicitly instantiated from its template.
7953  // A member function [...] of a class template can be explicitly
7954  // instantiated from the member definition associated with its class
7955  // template.
7957  TemplateSpecCandidateSet FailedCandidates(D.getIdentifierLoc());
7958  for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
7959  P != PEnd; ++P) {
7960  NamedDecl *Prev = *P;
7961  if (!HasExplicitTemplateArgs) {
7962  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
7963  QualType Adjusted = adjustCCAndNoReturn(R, Method->getType());
7964  if (Context.hasSameUnqualifiedType(Method->getType(), Adjusted)) {
7965  Matches.clear();
7966 
7967  Matches.addDecl(Method, P.getAccess());
7968  if (Method->getTemplateSpecializationKind() == TSK_Undeclared)
7969  break;
7970  }
7971  }
7972  }
7973 
7974  FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Prev);
7975  if (!FunTmpl)
7976  continue;
7977 
7978  TemplateDeductionInfo Info(FailedCandidates.getLocation());
7979  FunctionDecl *Specialization = nullptr;
7980  if (TemplateDeductionResult TDK
7981  = DeduceTemplateArguments(FunTmpl,
7982  (HasExplicitTemplateArgs ? &TemplateArgs
7983  : nullptr),
7984  R, Specialization, Info)) {
7985  // Keep track of almost-matches.
7986  FailedCandidates.addCandidate()
7987  .set(P.getPair(), FunTmpl->getTemplatedDecl(),
7988  MakeDeductionFailureInfo(Context, TDK, Info));
7989  (void)TDK;
7990  continue;
7991  }
7992 
7993  Matches.addDecl(Specialization, P.getAccess());
7994  }
7995 
7996  // Find the most specialized function template specialization.
7997  UnresolvedSetIterator Result = getMostSpecialized(
7998  Matches.begin(), Matches.end(), FailedCandidates,
7999  D.getIdentifierLoc(),
8000  PDiag(diag::err_explicit_instantiation_not_known) << Name,
8001  PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
8002  PDiag(diag::note_explicit_instantiation_candidate));
8003 
8004  if (Result == Matches.end())
8005  return true;
8006 
8007  // Ignore access control bits, we don't need them for redeclaration checking.
8008  FunctionDecl *Specialization = cast<FunctionDecl>(*Result);
8009 
8010  // C++11 [except.spec]p4
8011  // In an explicit instantiation an exception-specification may be specified,
8012  // but is not required.
8013  // If an exception-specification is specified in an explicit instantiation
8014  // directive, it shall be compatible with the exception-specifications of
8015  // other declarations of that function.
8016  if (auto *FPT = R->getAs<FunctionProtoType>())
8017  if (FPT->hasExceptionSpec()) {
8018  unsigned DiagID =
8019  diag::err_mismatched_exception_spec_explicit_instantiation;
8020  if (getLangOpts().MicrosoftExt)
8021  DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
8022  bool Result = CheckEquivalentExceptionSpec(
8023  PDiag(DiagID) << Specialization->getType(),
8024  PDiag(diag::note_explicit_instantiation_here),
8025  Specialization->getType()->getAs<FunctionProtoType>(),
8026  Specialization->getLocation(), FPT, D.getLocStart());
8027  // In Microsoft mode, mismatching exception specifications just cause a
8028  // warning.
8029  if (!getLangOpts().MicrosoftExt && Result)
8030  return true;
8031  }
8032 
8033  if (Specialization->getTemplateSpecializationKind() == TSK_Undeclared) {
8034  Diag(D.getIdentifierLoc(),
8035  diag::err_explicit_instantiation_member_function_not_instantiated)
8036  << Specialization
8037  << (Specialization->getTemplateSpecializationKind() ==
8039  Diag(Specialization->getLocation(), diag::note_explicit_instantiation_here);
8040  return true;
8041  }
8042 
8043  FunctionDecl *PrevDecl = Specialization->getPreviousDecl();
8044  if (!PrevDecl && Specialization->isThisDeclarationADefinition())
8045  PrevDecl = Specialization;
8046 
8047  if (PrevDecl) {
8048  bool HasNoEffect = false;
8049  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK,
8050  PrevDecl,
8051  PrevDecl->getTemplateSpecializationKind(),
8052  PrevDecl->getPointOfInstantiation(),
8053  HasNoEffect))
8054  return true;
8055 
8056  // FIXME: We may still want to build some representation of this
8057  // explicit specialization.
8058  if (HasNoEffect)
8059  return (Decl*) nullptr;
8060  }
8061 
8062  Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
8064  if (Attr)
8065  ProcessDeclAttributeList(S, Specialization, Attr);
8066 
8067  if (Specialization->isDefined()) {
8068  // Let the ASTConsumer know that this function has been explicitly
8069  // instantiated now, and its linkage might have changed.
8070  Consumer.HandleTopLevelDecl(DeclGroupRef(Specialization));
8071  } else if (TSK == TSK_ExplicitInstantiationDefinition)
8072  InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization);
8073 
8074  // C++0x [temp.explicit]p2:
8075  // If the explicit instantiation is for a member function, a member class
8076  // or a static data member of a class template specialization, the name of
8077  // the class template specialization in the qualified-id for the member
8078  // name shall be a simple-template-id.
8079  //
8080  // C++98 has the same restriction, just worded differently.
8081  FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate();
8082  if (D.getName().getKind() != UnqualifiedId::IK_TemplateId && !FunTmpl &&
8083  D.getCXXScopeSpec().isSet() &&
8085  Diag(D.getIdentifierLoc(),
8086  diag::ext_explicit_instantiation_without_qualified_id)
8087  << Specialization << D.getCXXScopeSpec().getRange();
8088 
8089  // C++ Concepts TS [dcl.spec.concept]p7: A program shall not declare an
8090  // explicit instantiation (14.8.2) [...] of a concept definition.
8091  if (FunTmpl && FunTmpl->isConcept() &&
8093  Diag(D.getIdentifierLoc(), diag::err_concept_specialized)
8094  << 0 /*function*/ << 0 /*explicitly instantiated*/;
8095  Diag(FunTmpl->getLocation(), diag::note_previous_declaration);
8096  return true;
8097  }
8098 
8100  FunTmpl? (NamedDecl *)FunTmpl
8101  : Specialization->getInstantiatedFromMemberFunction(),
8102  D.getIdentifierLoc(),
8103  D.getCXXScopeSpec().isSet());
8104 
8105  // FIXME: Create some kind of ExplicitInstantiationDecl here.
8106  return (Decl*) nullptr;
8107 }
8108 
8109 TypeResult
8110 Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
8111  const CXXScopeSpec &SS, IdentifierInfo *Name,
8112  SourceLocation TagLoc, SourceLocation NameLoc) {
8113  // This has to hold, because SS is expected to be defined.
8114  assert(Name && "Expected a name in a dependent tag");
8115 
8116  NestedNameSpecifier *NNS = SS.getScopeRep();
8117  if (!NNS)
8118  return true;
8119 
8121 
8122  if (TUK == TUK_Declaration || TUK == TUK_Definition) {
8123  Diag(NameLoc, diag::err_dependent_tag_decl)
8124  << (TUK == TUK_Definition) << Kind << SS.getRange();
8125  return true;
8126  }
8127 
8128  // Create the resulting type.
8130  QualType Result = Context.getDependentNameType(Kwd, NNS, Name);
8131 
8132  // Create type-source location information for this type.
8133  TypeLocBuilder TLB;
8135  TL.setElaboratedKeywordLoc(TagLoc);
8137  TL.setNameLoc(NameLoc);
8138  return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
8139 }
8140 
8141 TypeResult
8143  const CXXScopeSpec &SS, const IdentifierInfo &II,
8144  SourceLocation IdLoc) {
8145  if (SS.isInvalid())
8146  return true;
8147 
8148  if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
8149  Diag(TypenameLoc,
8150  getLangOpts().CPlusPlus11 ?
8151  diag::warn_cxx98_compat_typename_outside_of_template :
8152  diag::ext_typename_outside_of_template)
8153  << FixItHint::CreateRemoval(TypenameLoc);
8154 
8156  QualType T = CheckTypenameType(TypenameLoc.isValid()? ETK_Typename : ETK_None,
8157  TypenameLoc, QualifierLoc, II, IdLoc);
8158  if (T.isNull())
8159  return true;
8160 
8162  if (isa<DependentNameType>(T)) {
8164  TL.setElaboratedKeywordLoc(TypenameLoc);
8165  TL.setQualifierLoc(QualifierLoc);
8166  TL.setNameLoc(IdLoc);
8167  } else {
8169  TL.setElaboratedKeywordLoc(TypenameLoc);
8170  TL.setQualifierLoc(QualifierLoc);
8171  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
8172  }
8173 
8174  return CreateParsedType(T, TSI);
8175 }
8176 
8177 TypeResult
8179  SourceLocation TypenameLoc,
8180  const CXXScopeSpec &SS,
8181  SourceLocation TemplateKWLoc,
8182  TemplateTy TemplateIn,
8183  SourceLocation TemplateNameLoc,
8184  SourceLocation LAngleLoc,
8185  ASTTemplateArgsPtr TemplateArgsIn,
8186  SourceLocation RAngleLoc) {
8187  if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
8188  Diag(TypenameLoc,
8189  getLangOpts().CPlusPlus11 ?
8190  diag::warn_cxx98_compat_typename_outside_of_template :
8191  diag::ext_typename_outside_of_template)
8192  << FixItHint::CreateRemoval(TypenameLoc);
8193 
8194  // Translate the parser's template argument list in our AST format.
8195  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
8196  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
8197 
8198  TemplateName Template = TemplateIn.get();
8199  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
8200  // Construct a dependent template specialization type.
8201  assert(DTN && "dependent template has non-dependent name?");
8202  assert(DTN->getQualifier() == SS.getScopeRep());
8204  DTN->getQualifier(),
8205  DTN->getIdentifier(),
8206  TemplateArgs);
8207 
8208  // Create source-location information for this type.
8212  SpecTL.setElaboratedKeywordLoc(TypenameLoc);
8214  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
8215  SpecTL.setTemplateNameLoc(TemplateNameLoc);
8216  SpecTL.setLAngleLoc(LAngleLoc);
8217  SpecTL.setRAngleLoc(RAngleLoc);
8218  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
8219  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
8220  return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
8221  }
8222 
8223  QualType T = CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
8224  if (T.isNull())
8225  return true;
8226 
8227  // Provide source-location information for the template specialization type.
8230  = Builder.push<TemplateSpecializationTypeLoc>(T);
8231  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
8232  SpecTL.setTemplateNameLoc(TemplateNameLoc);
8233  SpecTL.setLAngleLoc(LAngleLoc);
8234  SpecTL.setRAngleLoc(RAngleLoc);
8235  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
8236  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
8237 
8239  ElaboratedTypeLoc TL = Builder.push<ElaboratedTypeLoc>(T);
8240  TL.setElaboratedKeywordLoc(TypenameLoc);
8242 
8243  TypeSourceInfo *TSI = Builder.getTypeSourceInfo(Context, T);
8244  return CreateParsedType(T, TSI);
8245 }
8246 
8247 
8248 /// Determine whether this failed name lookup should be treated as being
8249 /// disabled by a usage of std::enable_if.
8251  SourceRange &CondRange) {
8252  // We must be looking for a ::type...
8253  if (!II.isStr("type"))
8254  return false;
8255 
8256  // ... within an explicitly-written template specialization...
8257  if (!NNS || !NNS.getNestedNameSpecifier()->getAsType())
8258  return false;
8259  TypeLoc EnableIfTy = NNS.getTypeLoc();
8260  TemplateSpecializationTypeLoc EnableIfTSTLoc =
8261  EnableIfTy.getAs<TemplateSpecializationTypeLoc>();
8262  if (!EnableIfTSTLoc || EnableIfTSTLoc.getNumArgs() == 0)
8263  return false;
8264  const TemplateSpecializationType *EnableIfTST =
8265  cast<TemplateSpecializationType>(EnableIfTSTLoc.getTypePtr());
8266 
8267  // ... which names a complete class template declaration...
8268  const TemplateDecl *EnableIfDecl =
8269  EnableIfTST->getTemplateName().getAsTemplateDecl();
8270  if (!EnableIfDecl || EnableIfTST->isIncompleteType())
8271  return false;
8272 
8273  // ... called "enable_if".
8274  const IdentifierInfo *EnableIfII =
8275  EnableIfDecl->getDeclName().getAsIdentifierInfo();
8276  if (!EnableIfII || !EnableIfII->isStr("enable_if"))
8277  return false;
8278 
8279  // Assume the first template argument is the condition.
8280  CondRange = EnableIfTSTLoc.getArgLoc(0).getSourceRange();
8281  return true;
8282 }
8283 
8284 /// \brief Build the type that describes a C++ typename specifier,
8285 /// e.g., "typename T::type".
8286 QualType
8288  SourceLocation KeywordLoc,
8289  NestedNameSpecifierLoc QualifierLoc,
8290  const IdentifierInfo &II,
8291  SourceLocation IILoc) {
8292  CXXScopeSpec SS;
8293  SS.Adopt(QualifierLoc);
8294 
8295  DeclContext *Ctx = computeDeclContext(SS);
8296  if (!Ctx) {
8297  // If the nested-name-specifier is dependent and couldn't be
8298  // resolved to a type, build a typename type.
8299  assert(QualifierLoc.getNestedNameSpecifier()->isDependent());
8300  return Context.getDependentNameType(Keyword,
8301  QualifierLoc.getNestedNameSpecifier(),
8302  &II);
8303  }
8304 
8305  // If the nested-name-specifier refers to the current instantiation,
8306  // the "typename" keyword itself is superfluous. In C++03, the
8307  // program is actually ill-formed. However, DR 382 (in C++0x CD1)
8308  // allows such extraneous "typename" keywords, and we retroactively
8309  // apply this DR to C++03 code with only a warning. In any case we continue.
8310 
8311  if (RequireCompleteDeclContext(SS, Ctx))
8312  return QualType();
8313 
8314  DeclarationName Name(&II);
8315  LookupResult Result(*this, Name, IILoc, LookupOrdinaryName);
8316  LookupQualifiedName(Result, Ctx, SS);
8317  unsigned DiagID = 0;
8318  Decl *Referenced = nullptr;
8319  switch (Result.getResultKind()) {
8320  case LookupResult::NotFound: {
8321  // If we're looking up 'type' within a template named 'enable_if', produce
8322  // a more specific diagnostic.
8323  SourceRange CondRange;
8324  if (isEnableIf(QualifierLoc, II, CondRange)) {
8325  Diag(CondRange.getBegin(), diag::err_typename_nested_not_found_enable_if)
8326  << Ctx << CondRange;
8327  return QualType();
8328  }
8329 
8330  DiagID = diag::err_typename_nested_not_found;
8331  break;
8332  }
8333 
8335  // We found a using declaration that is a value. Most likely, the using
8336  // declaration itself is meant to have the 'typename' keyword.
8337  SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
8338  IILoc);
8339  Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
8340  << Name << Ctx << FullRange;
8341  if (UnresolvedUsingValueDecl *Using
8342  = dyn_cast<UnresolvedUsingValueDecl>(Result.getRepresentativeDecl())){
8343  SourceLocation Loc = Using->getQualifierLoc().getBeginLoc();
8344  Diag(Loc, diag::note_using_value_decl_missing_typename)
8345  << FixItHint::CreateInsertion(Loc, "typename ");
8346  }
8347  }
8348  // Fall through to create a dependent typename type, from which we can recover
8349  // better.
8350 
8352  // Okay, it's a member of an unknown instantiation.
8353  return Context.getDependentNameType(Keyword,
8354  QualifierLoc.getNestedNameSpecifier(),
8355  &II);
8356 
8357  case LookupResult::Found:
8358  if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
8359  // We found a type. Build an ElaboratedType, since the
8360  // typename-specifier was just sugar.
8361  MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
8363  QualifierLoc.getNestedNameSpecifier(),
8365  }
8366 
8367  DiagID = diag::err_typename_nested_not_type;
8368  Referenced = Result.getFoundDecl();
8369  break;
8370 
8372  DiagID = diag::err_typename_nested_not_type;
8373  Referenced = *Result.begin();
8374  break;
8375 
8377  return QualType();
8378  }
8379 
8380  // If we get here, it's because name lookup did not find a
8381  // type. Emit an appropriate diagnostic and return an error.
8382  SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
8383  IILoc);
8384  Diag(IILoc, DiagID) << FullRange << Name << Ctx;
8385  if (Referenced)
8386  Diag(Referenced->getLocation(), diag::note_typename_refers_here)
8387  << Name;
8388  return QualType();
8389 }
8390 
8391 namespace {
8392  // See Sema::RebuildTypeInCurrentInstantiation
8393  class CurrentInstantiationRebuilder
8394  : public TreeTransform<CurrentInstantiationRebuilder> {
8395  SourceLocation Loc;
8396  DeclarationName Entity;
8397 
8398  public:
8400 
8401  CurrentInstantiationRebuilder(Sema &SemaRef,
8402  SourceLocation Loc,
8403  DeclarationName Entity)
8404  : TreeTransform<CurrentInstantiationRebuilder>(SemaRef),
8405  Loc(Loc), Entity(Entity) { }
8406 
8407  /// \brief Determine whether the given type \p T has already been
8408  /// transformed.
8409  ///
8410  /// For the purposes of type reconstruction, a type has already been
8411  /// transformed if it is NULL or if it is not dependent.
8412  bool AlreadyTransformed(QualType T) {
8413  return T.isNull() || !T->isDependentType();
8414  }
8415 
8416  /// \brief Returns the location of the entity whose type is being
8417  /// rebuilt.
8418  SourceLocation getBaseLocation() { return Loc; }
8419 
8420  /// \brief Returns the name of the entity whose type is being rebuilt.
8421  DeclarationName getBaseEntity() { return Entity; }
8422 
8423  /// \brief Sets the "base" location and entity when that
8424  /// information is known based on another transformation.
8425  void setBase(SourceLocation Loc, DeclarationName Entity) {
8426  this->Loc = Loc;
8427  this->Entity = Entity;
8428  }
8429 
8430  ExprResult TransformLambdaExpr(LambdaExpr *E) {
8431  // Lambdas never need to be transformed.
8432  return E;
8433  }
8434  };
8435 } // end anonymous namespace
8436 
8437 /// \brief Rebuilds a type within the context of the current instantiation.
8438 ///
8439 /// The type \p T is part of the type of an out-of-line member definition of
8440 /// a class template (or class template partial specialization) that was parsed
8441 /// and constructed before we entered the scope of the class template (or
8442 /// partial specialization thereof). This routine will rebuild that type now
8443 /// that we have entered the declarator's scope, which may produce different
8444 /// canonical types, e.g.,
8445 ///
8446 /// \code
8447 /// template<typename T>
8448 /// struct X {
8449 /// typedef T* pointer;
8450 /// pointer data();
8451 /// };
8452 ///
8453 /// template<typename T>
8454 /// typename X<T>::pointer X<T>::data() { ... }
8455 /// \endcode
8456 ///
8457 /// Here, the type "typename X<T>::pointer" will be created as a DependentNameType,
8458 /// since we do not know that we can look into X<T> when we parsed the type.
8459 /// This function will rebuild the type, performing the lookup of "pointer"
8460 /// in X<T> and returning an ElaboratedType whose canonical type is the same
8461 /// as the canonical type of T*, allowing the return types of the out-of-line
8462 /// definition and the declaration to match.
8464  SourceLocation Loc,
8466  if (!T || !T->getType()->isDependentType())
8467  return T;
8468 
8469  CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name);
8470  return Rebuilder.TransformType(T);
8471 }
8472 
8474  CurrentInstantiationRebuilder Rebuilder(*this, E->getExprLoc(),
8475  DeclarationName());
8476  return Rebuilder.TransformExpr(E);
8477 }
8478 
8480  if (SS.isInvalid())
8481  return true;
8482 
8484  CurrentInstantiationRebuilder Rebuilder(*this, SS.getRange().getBegin(),
8485  DeclarationName());
8486  NestedNameSpecifierLoc Rebuilt
8487  = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
8488  if (!Rebuilt)
8489  return true;
8490 
8491  SS.Adopt(Rebuilt);
8492  return false;
8493 }
8494 
8495 /// \brief Rebuild the template parameters now that we know we're in a current
8496 /// instantiation.
8498  TemplateParameterList *Params) {
8499  for (unsigned I = 0, N = Params->size(); I != N; ++I) {
8500  Decl *Param = Params->getParam(I);
8501 
8502  // There is nothing to rebuild in a type parameter.
8503  if (isa<TemplateTypeParmDecl>(Param))
8504  continue;
8505 
8506  // Rebuild the template parameter list of a template template parameter.
8507  if (TemplateTemplateParmDecl *TTP
8508  = dyn_cast<TemplateTemplateParmDecl>(Param)) {
8509  if (RebuildTemplateParamsInCurrentInstantiation(
8510  TTP->getTemplateParameters()))
8511  return true;
8512 
8513  continue;
8514  }
8515 
8516  // Rebuild the type of a non-type template parameter.
8517  NonTypeTemplateParmDecl *NTTP = cast<NonTypeTemplateParmDecl>(Param);
8518  TypeSourceInfo *NewTSI
8519  = RebuildTypeInCurrentInstantiation(NTTP->getTypeSourceInfo(),
8520  NTTP->getLocation(),
8521  NTTP->getDeclName());
8522  if (!NewTSI)
8523  return true;
8524 
8525  if (NewTSI != NTTP->getTypeSourceInfo()) {
8526  NTTP->setTypeSourceInfo(NewTSI);
8527  NTTP->setType(NewTSI->getType());
8528  }
8529  }
8530 
8531  return false;
8532 }
8533 
8534 /// \brief Produces a formatted string that describes the binding of
8535 /// template parameters to template arguments.
8536 std::string
8538  const TemplateArgumentList &Args) {
8539  return getTemplateArgumentBindingsText(Params, Args.data(), Args.size());
8540 }
8541 
8542 std::string
8544  const TemplateArgument *Args,
8545  unsigned NumArgs) {
8546  SmallString<128> Str;
8547  llvm::raw_svector_ostream Out(Str);
8548 
8549  if (!Params || Params->size() == 0 || NumArgs == 0)
8550  return std::string();
8551 
8552  for (unsigned I = 0, N = Params->size(); I != N; ++I) {
8553  if (I >= NumArgs)
8554  break;
8555 
8556  if (I == 0)
8557  Out << "[with ";
8558  else
8559  Out << ", ";
8560 
8561  if (const IdentifierInfo *Id = Params->getParam(I)->getIdentifier()) {
8562  Out << Id->getName();
8563  } else {
8564  Out << '$' << I;
8565  }
8566 
8567  Out << " = ";
8568  Args[I].print(getPrintingPolicy(), Out);
8569  }
8570 
8571  Out << ']';
8572  return Out.str();
8573 }
8574 
8576  CachedTokens &Toks) {
8577  if (!FD)
8578  return;
8579 
8581 
8582  // Take tokens to avoid allocations
8583  LPT->Toks.swap(Toks);
8584  LPT->D = FnD;
8585  LateParsedTemplateMap.insert(std::make_pair(FD, LPT));
8586 
8587  FD->setLateTemplateParsed(true);
8588 }
8589 
8591  if (!FD)
8592  return;
8593  FD->setLateTemplateParsed(false);
8594 }
8595 
8597  DeclContext *DC = CurContext;
8598 
8599  while (DC) {
8600  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(CurContext)) {
8601  const FunctionDecl *FD = RD->isLocalClass();
8602  return (FD && FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate);
8603  } else if (DC->isTranslationUnit() || DC->isNamespace())
8604  return false;
8605 
8606  DC = DC->getParent();
8607  }
8608  return false;
8609 }
8610 
8611 /// \brief Walk the path from which a declaration was instantiated, and check
8612 /// that every explicit specialization along that path is visible. This enforces
8613 /// C++ [temp.expl.spec]/6:
8614 ///
8615 /// If a template, a member template or a member of a class template is
8616 /// explicitly specialized then that specialization shall be declared before
8617 /// the first use of that specialization that would cause an implicit
8618 /// instantiation to take place, in every translation unit in which such a
8619 /// use occurs; no diagnostic is required.
8620 ///
8621 /// and also C++ [temp.class.spec]/1:
8622 ///
8623 /// A partial specialization shall be declared before the first use of a
8624 /// class template specialization that would make use of the partial
8625 /// specialization as the result of an implicit or explicit instantiation
8626 /// in every translation unit in which such a use occurs; no diagnostic is
8627 /// required.
8629  Sema &S;
8630  SourceLocation Loc;
8632 
8633 public:
8635  : S(S), Loc(Loc) {}
8636 
8637  void check(NamedDecl *ND) {
8638  if (auto *FD = dyn_cast<FunctionDecl>(ND))
8639  return checkImpl(FD);
8640  if (auto *RD = dyn_cast<CXXRecordDecl>(ND))
8641  return checkImpl(RD);
8642  if (auto *VD = dyn_cast<VarDecl>(ND))
8643  return checkImpl(VD);
8644  if (auto *ED = dyn_cast<EnumDecl>(ND))
8645  return checkImpl(ED);
8646  }
8647 
8648 private:
8649  void diagnose(NamedDecl *D, bool IsPartialSpec) {
8652  const bool Recover = true;
8653 
8654  // If we got a custom set of modules (because only a subset of the
8655  // declarations are interesting), use them, otherwise let
8656  // diagnoseMissingImport intelligently pick some.
8657  if (Modules.empty())
8658  S.diagnoseMissingImport(Loc, D, Kind, Recover);
8659  else
8660  S.diagnoseMissingImport(Loc, D, D->getLocation(), Modules, Kind, Recover);
8661  }
8662 
8663  // Check a specific declaration. There are three problematic cases:
8664  //
8665  // 1) The declaration is an explicit specialization of a template
8666  // specialization.
8667  // 2) The declaration is an explicit specialization of a member of an
8668  // templated class.
8669  // 3) The declaration is an instantiation of a template, and that template
8670  // is an explicit specialization of a member of a templated class.
8671  //
8672  // We don't need to go any deeper than that, as the instantiation of the
8673  // surrounding class / etc is not triggered by whatever triggered this
8674  // instantiation, and thus should be checked elsewhere.
8675  template<typename SpecDecl>
8676  void checkImpl(SpecDecl *Spec) {
8677  bool IsHiddenExplicitSpecialization = false;
8678  if (Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
8679  IsHiddenExplicitSpecialization =
8680  Spec->getMemberSpecializationInfo()
8681  ? !S.hasVisibleMemberSpecialization(Spec, &Modules)
8682  : !S.hasVisibleDeclaration(Spec);
8683  } else {
8684  checkInstantiated(Spec);
8685  }
8686 
8687  if (IsHiddenExplicitSpecialization)
8688  diagnose(Spec->getMostRecentDecl(), false);
8689  }
8690 
8691  void checkInstantiated(FunctionDecl *FD) {
8692  if (auto *TD = FD->getPrimaryTemplate())
8693  checkTemplate(TD);
8694  }
8695 
8696  void checkInstantiated(CXXRecordDecl *RD) {
8697  auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
8698  if (!SD)
8699  return;
8700 
8701  auto From = SD->getSpecializedTemplateOrPartial();
8702  if (auto *TD = From.dyn_cast<ClassTemplateDecl *>())
8703  checkTemplate(TD);
8704  else if (auto *TD =
8705  From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
8706  if (!S.hasVisibleDeclaration(TD))
8707  diagnose(TD, true);
8708  checkTemplate(TD);
8709  }
8710  }
8711 
8712  void checkInstantiated(VarDecl *RD) {
8713  auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
8714  if (!SD)
8715  return;
8716 
8717  auto From = SD->getSpecializedTemplateOrPartial();
8718  if (auto *TD = From.dyn_cast<VarTemplateDecl *>())
8719  checkTemplate(TD);
8720  else if (auto *TD =
8721  From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
8722  if (!S.hasVisibleDeclaration(TD))
8723  diagnose(TD, true);
8724  checkTemplate(TD);
8725  }
8726  }
8727 
8728  void checkInstantiated(EnumDecl *FD) {}
8729 
8730  template<typename TemplDecl>
8731  void checkTemplate(TemplDecl *TD) {
8732  if (TD->isMemberSpecialization()) {
8733  if (!S.hasVisibleMemberSpecialization(TD, &Modules))
8734  diagnose(TD->getMostRecentDecl(), false);
8735  }
8736  }
8737 };
8738 
8740  if (!getLangOpts().Modules)
8741  return;
8742 
8744 }
8745 
8746 /// \brief Check whether a template partial specialization that we've discovered
8747 /// is hidden, and produce suitable diagnostics if so.
8749  NamedDecl *Spec) {
8751  if (!hasVisibleDeclaration(Spec, &Modules))
8752  diagnoseMissingImport(Loc, Spec, Spec->getLocation(), Modules,
8753  MissingImportKind::PartialSpecialization,
8754  /*Recover*/true);
8755 }
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition: Ownership.h:266
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:210
bool isObjCObjectOrInterfaceType() const
Definition: Type.h:5560
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType) const
ExprResult BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg, SourceLocation Loc)
Construct a new expression that refers to the given integral template argument with the given source-...
Defines the clang::ASTContext interface.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this function template specialization.
Definition: DeclTemplate.h:473
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:64
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:505
IdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:981
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1561
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
Definition: DeclTemplate.h:462
Name lookup found a set of overloaded functions that met the criteria.
Definition: Sema/Lookup.h:47
int Position
TypeResult ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK, const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation TagLoc, SourceLocation NameLoc)
BuiltinTemplateKind getBuiltinTemplateKind() const
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
DeclResult ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, SourceLocation ModulePrivateLoc, TemplateIdAnnotation &TemplateId, AttributeList *Attr, MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody=nullptr)
bool isTransparentContext() const
isTransparentContext - Determines whether this context is a "transparent" context, meaning that the members declared in this context are semantically declared in the nearest enclosing non-transparent (opaque) context but are lexically declared in this context.
Definition: DeclBase.cpp:954
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
static bool CheckTemplateArgumentIsCompatibleWithParameter(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, Expr *Arg, QualType ArgType)
Checks whether the given template argument is compatible with its template parameter.
bool isNullPtrType() const
Definition: Type.h:5693
unsigned getDepth() const
Definition: Type.h:3945
TemplateParameterList * getExpansionTemplateParameters(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
bool TemplateParameterListsAreEqual(TemplateParameterList *New, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2179
SourceLocation getDefaultArgumentLoc() const
Retrieves the location of the default argument declaration.
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:3473
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization, retrieves the member specialization information.
Definition: DeclCXX.cpp:1288
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2256
A (possibly-)qualified type.
Definition: Type.h:598
Simple class containing the result of Sema::CorrectTypo.
TemplateDeductionResult
Describes the result of template argument deduction.
Definition: Sema.h:6414
base_class_range bases()
Definition: DeclCXX.h:718
bool isInvalid() const
Definition: Ownership.h:160
void setDefaultArgument(TypeSourceInfo *DefArg)
Set the default argument for this template parameter.
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
Definition: TemplateBase.h:282
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1087
A stack-allocated class that identifies which local variable declaration instantiations are present i...
Definition: Template.h:178
bool isMemberPointerType() const
Definition: Type.h:5506
bool isSuppressingDiagnostics() const
Determines whether this lookup is suppressing diagnostics.
Definition: Sema/Lookup.h:571
static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II, SourceRange &CondRange)
Determine whether this failed name lookup should be treated as being disabled by a usage of std::enab...
static CXXDependentScopeMemberExpr * Create(const ASTContext &C, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:1143
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2705
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:232
void addOuterTemplateArguments(const TemplateArgumentList *TemplateArgs)
Add a new outermost level to the multi-level template argument list.
Definition: Template.h:96
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1693
const LangOptions & getLangOpts() const
Definition: Sema.h:1062
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Sema/Lookup.h:252
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
ParsedType getAsType() const
Retrieve the template type argument's type.
static UnresolvedLookupExpr * Create(const ASTContext &C, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool ADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.h:2719
DeclClass * getAsSingle() const
Definition: Sema/Lookup.h:491
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Sema/Lookup.h:508
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
Definition: DeclSpec.h:931
Filter makeFilter()
Create a filter for this result set.
Definition: Sema/Lookup.h:665
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:973
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1458
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1686
We are matching the template parameter lists of two templates that might be redeclarations.
Definition: Sema.h:5971
TypeLoc getNamedTypeLoc() const
Definition: TypeLoc.h:1759
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
Provides information about an attempted template argument deduction, whose success or failure was des...
ClassTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
static bool DiagnoseDefaultTemplateArgument(Sema &S, Sema::TemplateParamListContext TPC, SourceLocation ParamLoc, SourceRange DefArgRange)
Diagnose the presence of a default template argument on a template parameter, which is ill-formed in ...
The name refers to a function template or a set of overloaded functions that includes at least one fu...
Definition: TemplateKinds.h:26
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:218
The name refers to a dependent template name.
Definition: TemplateKinds.h:38
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:4496
void setObjCLifetime(ObjCLifetime type)
Definition: Type.h:311
The template argument is an expression, and we've not resolved it to one of the other forms yet...
Definition: TemplateBase.h:69
CXXRecordDecl * getDecl() const
Definition: Type.cpp:3065
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, TemplateParameterList *Params)
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments...
void erase()
Erase the last element returned from this iterator.
Definition: Sema/Lookup.h:637
static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)
Determine what kind of template specialization the given declaration is.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
QualType getUnderlyingType() const
Definition: Decl.h:2649
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1139
bool isChar16Type() const
Definition: Type.cpp:1672
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2671
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
Defines the C++ template declaration subclasses.
StringRef P
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4084
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
bool isEnumeralType() const
Definition: Type.h:5542
static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context, QualType T, const CXXScopeSpec &SS)
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1619
SCS getStorageClassSpec() const
Definition: DeclSpec.h:447
void AddDecl(Decl *D)
Definition: Scope.h:275
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization...
Definition: Decl.h:3230
std::string getAsString() const
Definition: Type.h:924
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:315
PtrTy get() const
Definition: Ownership.h:164
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition: Type.cpp:2404
QualType getPointeeType() const
Definition: Type.h:2420
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn't a simple identifier.
The base class of the type hierarchy.
Definition: Type.h:1281
bool isMemberPointer() const
Definition: APValue.h:191
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:922
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Definition: Decl.cpp:3610
iterator begin() const
Definition: Sema/Lookup.h:319
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:5292
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1874
DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, ArrayRef< TemplateArgument > Args, QualType Canon)
Declaration of a variable template.
TemplateParamListContext
The context in which we are checking a template parameter list.
Definition: Sema.h:5721
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:51
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:471
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:46
bool hasLValuePath() const
Definition: APValue.cpp:568
void setSpecializationKind(TemplateSpecializationKind TSK)
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:101
SourceLocation getInlineSpecLoc() const
Definition: DeclSpec.h:563
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:93
bool isBooleanType() const
Definition: Type.h:5743
A container of type source information.
Definition: Decl.h:62
unsigned getIndex() const
Definition: Type.h:3946
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:305
void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo)
static void StripImplicitInstantiation(NamedDecl *D)
Strips various properties off an implicit instantiation that has just been explicitly specialized...
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, ArrayRef< TemplateParameterList * > FriendTypeTPLists=None)
Definition: DeclFriend.cpp:27
Abstract base class used for diagnosing integer constant expression violations.
Definition: Sema.h:9065
bool isConceptSpecified() const
Definition: DeclSpec.h:709
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
static bool CheckTemplatePartialSpecializationArgs(Sema &S, SourceLocation NameLoc, TemplateParameterList *TemplateParams, unsigned ExplicitArgs, SmallVectorImpl< TemplateArgument > &TemplateArgs)
Check the non-type template arguments of a class template partial specialization according to C++ [te...
An identifier, stored as an IdentifierInfo*.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:125
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:40
RAII object that enters a new expression evaluation context.
Definition: Sema.h:9606
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:768
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1624
static SourceLocation DiagLocForExplicitInstantiation(NamedDecl *D, SourceLocation PointOfInstantiation)
Compute the diagnostic location for an explicit instantiation.
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:46
Extra information about a function prototype.
Definition: Type.h:3167
bool isCanonical() const
Definition: Type.h:5303
SourceLocation getLocation() const
Retrieve the location of the template argument.
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:45
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1813
Represents a variable template specialization, which refers to a variable template with a given set o...
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:387
static bool isTemplateArgumentTemplateParameter(const TemplateArgument &Arg, unsigned Depth, unsigned Index)
A namespace, stored as a NamespaceDecl*.
VarTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member variable template partial specialization from which this particular variable temp...
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:49
TemplateArgumentLoc SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, Decl *Param, SmallVectorImpl< TemplateArgument > &Converted, bool &HasDefaultArg)
If the given template parameter has a default template argument, substitute into that default templat...
static Optional< unsigned > getExpandedPackSize(NamedDecl *Param)
Check whether the template parameter is a pack expansion, and if so, determine the number of paramete...
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:3983
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Definition: Expr.cpp:3132
Defines the clang::Expr interface and subclasses for C++ expressions.
void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD, CachedTokens &Toks)
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1739
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
A reasonable base class for TypeLocs that correspond to types that are written as a type-specifier...
Definition: TypeLoc.h:485
The collection of all-type qualifiers we support.
Definition: Type.h:117
Information about a template-id annotation token.
PipeType - OpenCL20.
Definition: Type.h:5190
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
Definition: TemplateName.h:474
static void DiagnoseTemplateParameterListArityMismatch(Sema &S, TemplateParameterList *New, TemplateParameterList *Old, Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc)
Diagnose a known arity mismatch when comparing template argument lists.
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
Definition: DeclCXX.cpp:1322
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
Expr * IgnoreImpCasts() LLVM_READONLY
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
Definition: Expr.h:2777
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3253
A semantic tree transformation that allows one to transform one abstract syntax tree into another...
Definition: TreeTransform.h:95
static bool hasVisibleDefaultArgument(Sema &S, const ParmDecl *D, llvm::SmallVectorImpl< Module * > *Modules)
Scope * getTemplateParamParent()
Definition: Scope.h:253
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:952
QualType getElementType() const
Definition: Type.h:2732
DeclarationName getName() const
getName - Returns the embedded declaration name.
bool isConst() const
Definition: DeclCXX.h:1777
One of these records is kept for each identifier that is lexed.
Represents a class template specialization, which refers to a class template with a given set of temp...
iterator end() const
Definition: Sema/Lookup.h:320
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Sema/Lookup.h:57
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
Definition: APValue.cpp:622
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template.
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter 'PrevD...
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
Definition: Decl.cpp:3699
void replace(NamedDecl *D)
Replaces the current entry with the given one, preserving the access bits.
Definition: Sema/Lookup.h:644
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
ExprResult RebuildExprInCurrentInstantiation(Expr *E)
Represents a class type in Objective C.
Definition: Type.h:4727
AttributeList * getList() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1789
CXXRecordDecl * getPreviousDecl()
Definition: DeclCXX.h:661
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:92
A C++ nested-name-specifier augmented with source location information.
Represents a dependent template name that cannot be resolved prior to template instantiation.
Definition: TemplateName.h:412
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3276
static NamedDecl * isAcceptableTemplateName(ASTContext &Context, NamedDecl *Orig, bool AllowFunctionTemplates)
Determine whether the declaration found is acceptable as the name of a template and, if so, return that template declaration.
bool isIdentifier() const
Determine whether this template name refers to an identifier.
Definition: TemplateName.h:471
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:57
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2266
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:1472
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1744
bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, const TemplateArgumentListInfo &ExplicitTemplateArgs, LookupResult &Previous)
Perform semantic analysis for the given dependent function template specialization.
Decl * ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, unsigned Depth, unsigned Position, SourceLocation EqualLoc, Expr *DefaultArg)
bool isReferenceType() const
Definition: Type.h:5491
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
bool hasVisibleDeclaration(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine whether any declaration of an entity is visible.
Definition: Sema.h:1415
VarTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:899
void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We've found a use of a templated declaration that would trigger an implicit instantiation.
SourceLocation getLocation() const
Fetches the primary location of the argument.
Definition: TemplateBase.h:459
OverloadedOperatorKind Operator
The kind of overloaded operator.
Definition: DeclSpec.h:914
An operation on a type.
Definition: TypeVisitor.h:65
TypeResult ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false)
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:3544
struct OFI OperatorFunctionId
When Kind == IK_OperatorFunctionId, the overloaded operator that we parsed.
Definition: DeclSpec.h:935
bool isChar32Type() const
Definition: Type.cpp:1678
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:678
bool isTranslationUnit() const
Definition: DeclBase.h:1283
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:231
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:4516
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1788
TagKind getTagKind() const
Definition: Decl.h:2930
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:28
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1982
CachedTokens Toks
Definition: Sema.h:9644
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4038
A non-type template parameter, stored as an expression.
bool hasAnyAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true)
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1761
unsigned size() const
Definition: DeclTemplate.h:92
bool DiagnoseUnknownTemplateName(const IdentifierInfo &II, SourceLocation IILoc, Scope *S, const CXXScopeSpec *SS, TemplateTy &SuggestedTemplate, TemplateNameKind &SuggestedKind)
bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
Perform semantic analysis for the given non-template member specialization.
static QualType checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD, const SmallVectorImpl< TemplateArgument > &Converted, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
void ClearStorageClassSpecs()
Definition: DeclSpec.h:461
The type of a non-type template parameter.
Definition: Sema.h:6118
TypeSourceInfo * getTypeSourceInfo() const
Definition: TemplateBase.h:478
SourceRange getSourceRange() const LLVM_READONLY
Fetches the full source range of the argument.
void set(DeclAccessPair Found, Decl *Spec, DeductionFailureInfo Info)
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
Definition: SemaExpr.cpp:509
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1199
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2007
SourceLocation getTemplateEllipsisLoc() const
Definition: TemplateBase.h:515
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Sema/Lookup.h:39
QualType getUnderlyingType() const
Definition: Type.h:3578
void setDefaultArgument(Expr *DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:105
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:399
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, bool isAddressOfOperand, const TemplateArgumentListInfo *TemplateArgs)
ActOnDependentIdExpression - Handle a dependent id-expression that was just parsed.
static void maybeDiagnoseTemplateParameterShadow(Sema &SemaRef, Scope *S, SourceLocation Loc, IdentifierInfo *Name)
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:884
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3083
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1452
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2383
static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From, QualType T, APValue &Value, Sema::CCEKind CCE, bool RequireInt)
CheckConvertedConstantExpression - Check that the expression From is a converted constant expression ...
param_type_range param_types() const
Definition: Type.h:3389
SourceLocation getLAngleLoc() const
Definition: DeclTemplate.h:132
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
Definition: Expr.h:549
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
Definition: DeclBase.cpp:1542
Represents the results of name lookup.
Definition: Sema/Lookup.h:30
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:588
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For an enumeration member that was instantiated from a member enumeration of a templated class...
Definition: Decl.cpp:3673
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1895
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:564
A convenient class for passing around template argument information.
Definition: TemplateBase.h:523
QualType getReturnType() const
Definition: Type.h:3009
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true)
const ValueDecl * getMemberPointerDecl() const
Definition: APValue.cpp:608
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
ParsedTemplateTy getAsTemplate() const
Retrieve the template template argument's template name.
KindType getKind() const
Determine what kind of template argument we have.
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:3718
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:3525
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Definition: TemplateBase.h:503
char * location_data() const
Retrieve the data associated with the source-location information.
Definition: DeclSpec.h:217
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack)
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1090
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2569
void setRedeclaration(bool Val)
Definition: DeclSpec.h:2262
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:147
RecordDecl * getDecl() const
Definition: Type.h:3716
static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old, bool Complain, Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc)
Match two template parameters within template parameter lists.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2326
void setSpecializationKind(TemplateSpecializationKind TSK)
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
static TemplateArgument CreatePackCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument pack by copying the given set of template arguments.
NullPointerValueKind
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
SourceLocation getRAngleLoc() const
Definition: TemplateBase.h:540
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
SourceLocation getConceptSpecLoc() const
Definition: DeclSpec.h:710
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1892
SourceLocation getTemplateNameLoc() const
Definition: TemplateBase.h:509
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
Definition: TemplateName.h:468
std::string getAsString() const
getNameAsString - Retrieve the human-readable string for this name.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1503
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:720
Decl * ActOnTemplateDeclarator(Scope *S, MultiTemplateParamsArg TemplateParameterLists, Declarator &D)
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &Converted)
Check that the given template arguments can be be provided to the given template, converting the argu...
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3128
A class that does preordor or postorder depth-first traversal on the entire Clang AST and visits each...
static bool CheckTemplateArgumentPointerToMember(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *&ResultArg, TemplateArgument &Converted)
Checks whether the given template argument is a pointer to member constant according to C++ [temp...
DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, AttributeList *Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
ParsedTemplateArgument getTemplatePackExpansion(SourceLocation EllipsisLoc) const
Retrieve a pack expansion of the given template template argument.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:503
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Sema/Lookup.h:410
We are matching the template parameter lists of a template template argument against the template par...
Definition: Sema.h:5992
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:502
detail::InMemoryDirectory::const_iterator I
Decl * ActOnTypeParameter(Scope *S, bool Typename, SourceLocation EllipsisLoc, SourceLocation KeyLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position, SourceLocation EqualLoc, ParsedType DefaultArg)
ActOnTypeParameter - Called when a C++ template type parameter (e.g., "typename T") has been parsed...
QualType getCanonicalTypeInternal() const
Definition: Type.h:2001
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
QualType getType() const
Definition: Decl.h:599
bool isInvalid() const
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:53
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition: Sema.h:2756
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
Definition: Expr.h:1044
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:2718
const UnresolvedSetImpl & asUnresolvedSet() const
Definition: Sema/Lookup.h:315
SourceRange getRange() const
Definition: DeclSpec.h:68
bool isDefined(const FunctionDecl *&Definition) const
isDefined - Returns true if the function is defined at all, including a deleted definition.
Definition: Decl.cpp:2479
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
EnumDecl * getDecl() const
Definition: Type.h:3739
We are matching the template parameter lists of two template template parameters as part of matching ...
Definition: Sema.h:5981
Represents a K&R-style 'int foo()' function, which has no information available about its arguments...
Definition: Type.h:3039
TemplateName getUnderlying() const
Definition: TemplateName.h:337
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5173
QualType getInjectedSpecializationType() const
Definition: Type.h:4326
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:3183
bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, TemplateArgumentLoc &Arg, SmallVectorImpl< TemplateArgument > &Converted)
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1736
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:263
bool isNamespace() const
Definition: DeclBase.h:1291
TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x alias-declaration.
Definition: Decl.h:2701
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the class template or class template partial specialization which was specialized by this...
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
TemplateParameterList * ActOnTemplateParameterList(unsigned Depth, SourceLocation ExportLoc, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< Decl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
ActOnTemplateParameterList - Builds a TemplateParameterList, optionally constrained by RequiresClause...
bool hasVisibleDefaultArgument(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if the template parameter D has a visible default argument.
bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, SmallVectorImpl< TemplateArgument > &Converted, CheckTemplateArgumentKind CTAK=CTAK_Specified)
Check that the given template argument corresponds to the given template parameter.
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Sema/Lookup.h:237
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3073
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:119
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
Definition: DeclCXX.cpp:1281
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
Definition: SemaExpr.cpp:14058
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2593
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1009
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
static TypeSourceInfo * SubstDefaultTemplateArgument(Sema &SemaRef, TemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, TemplateTypeParmDecl *Param, SmallVectorImpl< TemplateArgument > &Converted)
Substitute template arguments into the default template argument for the given template type paramete...
static bool CheckNonTypeTemplatePartialSpecializationArgs(Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param, const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument)
Subroutine of Sema::CheckTemplatePartialSpecializationArgs that checks non-type template partial spec...
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:462
Specifies that the expression should never be value-dependent.
Definition: Expr.h:688
bool CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, TemplateSpecializationKind NewTSK, NamedDecl *PrevDecl, TemplateSpecializationKind PrevTSK, SourceLocation PrevPtOfInstantiation, bool &SuppressNew)
Diagnose cases where we have an explicit template specialization before/after an explicit template in...
ASTContext * Context
bool isEnum() const
Definition: Decl.h:2940
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization, retrieves the member specialization information.
Definition: Decl.cpp:2285
TemplateParameterListEqualKind
Enumeration describing how template parameter lists are compared for equality.
Definition: Sema.h:5963
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:189
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:1903
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1881
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, const TemplateArgumentListInfo &Args) const
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:2659
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1722
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
int * Depth
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:1909
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:155
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1855
QualType getPointeeType() const
Definition: Type.h:2300
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:590
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition: Type.h:5749
Expr - This represents one expression.
Definition: Expr.h:105
Defines the clang::LangOptions interface.
DeclResult CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation TemplateNameLoc, const TemplateArgumentListInfo &TemplateArgs)
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Sema/Lookup.h:247
StringRef getName() const
Return the actual identifier string.
static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, const TemplateArgumentListInfo &ArgInfos, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl)
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:102
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition: Type.h:4370
CXXRecordDecl * getNamingClass() const
Returns the 'naming class' for this lookup, i.e.
Definition: Sema/Lookup.h:387
StateNode * Previous
Declaration of a template type parameter.
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Sema/Lookup.h:589
This file defines the classes used to store parsed information about declaration-specifiers and decla...
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:981
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:4357
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:54
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl, ClassTemplateDecl *PrevDecl)
Create a class template node.
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis that makes a template template argument into a pack expansion...
ExprResult BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc)
Given a non-type template argument that refers to a declaration and the type of its corresponding non...
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:886
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Sema/Lookup.h:501
SourceLocation getLocation() const
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:216
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3280
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:2391
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
void setMemberSpecialization()
Note that this member template is a specialization.
Definition: DeclTemplate.h:753
void NoteAllFoundTemplates(TemplateName Name)
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
Definition: TemplateName.h:176
static DependentScopeDeclRefExpr * Create(const ASTContext &C, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:375
Represents the type decltype(expr) (C++11).
Definition: Type.h:3590
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous)
Perform semantic analysis for the given function template specialization.
TypeSourceInfo * getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &Args, QualType Canon=QualType()) const
A namespace alias, stored as a NamespaceAliasDecl*.
void setLateTemplateParsed(bool ILT=true)
Definition: Decl.h:1842
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
bool isConstexprSpecified() const
Definition: DeclSpec.h:706
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
Definition: TemplateKinds.h:21
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:107
StorageClass
Storage classes.
Definition: Specifiers.h:201
TemplateDecl * AdjustDeclIfTemplate(Decl *&Decl)
AdjustDeclIfTemplate - If the given decl happens to be a template, reset the parameter D to reference...
A unary type transform, which is a type constructed from another.
Definition: Type.h:3631
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1774
bool isFunctionOrMethod() const
Definition: DeclBase.h:1263
Declaration of an alias template.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1214
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion, return the pattern as a template name.
Definition: TemplateBase.h:269
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
Definition: DeclTemplate.h:234
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:42
void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl, MissingImportKind MIK, bool Recover=true)
Diagnose that the specified declaration needs to be visible but isn't, and suggest a module import th...
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1668
SmallVector< ActiveTemplateInstantiation, 16 > ActiveTemplateInstantiations
List of active template instantiations.
Definition: Sema.h:6732
Represents a GCC generic vector type.
Definition: Type.h:2756
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2366
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3767
class LLVM_ALIGNAS(8) TemplateSpecializationType unsigned NumArgs
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4154
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization)
ValueDecl * getDecl()
Definition: Expr.h:1017
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
void setDescribedClassTemplate(ClassTemplateDecl *Template)
Definition: DeclCXX.cpp:1306
QualType getElementType() const
Definition: Type.h:2780
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:147
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type...
Definition: Decl.h:2957
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1797
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:456
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3372
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition: Type.cpp:1762
static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef, const ParsedTemplateArgument &Arg)
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:671
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4004
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:1883
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateDecl *Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
Definition: DeclCXX.cpp:94
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:473
bool isLValueOnePastTheEnd() const
Definition: APValue.cpp:558
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
bool isAmbiguous() const
Definition: Sema/Lookup.h:285
bool hasUnnamedOrLocalType() const
Whether this type is or contains a local or unnamed type.
Definition: Type.cpp:3381
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc)
static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, bool OnlyDeduced, unsigned Level, llvm::SmallBitVector &Deduced)
Mark the template parameters that are used by the given type.
static bool DiagnoseUnexpandedParameterPacks(Sema &S, TemplateTemplateParmDecl *TTP)
Check for unexpanded parameter packs within the template parameters of a template template parameter...
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
CanQualType OverloadTy
Definition: ASTContext.h:909
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:1479
DeclContext * getEntity() const
Definition: Scope.h:313
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:215
ASTMatchFinder *const Finder
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1579
#define false
Definition: stdbool.h:33
static NullPointerValueKind isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *Arg)
Determine whether the given template argument is a null pointer value of the appropriate type...
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:145
Kind
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5730
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:144
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1888
Represents the parsed form of a C++ template argument.
A stack object to be created when performing template instantiation.
Definition: Sema.h:6822
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
TypeSourceInfo * getDefaultArgumentInfo() const
Retrieves the default argument's source information, if any.
static bool isSameAsPrimaryTemplate(TemplateParameterList *Params, ArrayRef< TemplateArgument > Args)
Encodes a location in the source.
Expr * getAsExpr() const
Retrieve the non-type template argument's expression.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5259
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3733
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:262
Walk the path from which a declaration was instantiated, and check that every explicit specialization...
QualType getElementType() const
Definition: Type.h:2131
bool InEnclosingNamespaceSetOf(const DeclContext *NS) const
Test if this context is part of the enclosing namespace set of the context NS, as defined in C++0x [n...
Definition: DeclBase.cpp:1561
Represents typeof(type), a GCC extension.
Definition: Type.h:3566
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:4936
void setBraceRange(SourceRange R)
Definition: Decl.h:2847
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
An overloaded operator name, e.g., operator+.
Definition: DeclSpec.h:895
static bool CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, TemplateArgument &Converted)
Checks whether the given template argument is the address of an object or function according to C++ [...
This names the __make_integer_seq BuiltinTemplateDecl.
Definition: Builtins.h:222
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1748
bool isValid() const
Return true if this is a valid SourceLocation object.
void setExternLoc(SourceLocation Loc)
Sets the location of the extern keyword.
static void SetNestedNameSpecifier(TagDecl *T, const CXXScopeSpec &SS)
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2727
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:143
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc)
Build the type that describes a C++ typename specifier, e.g., "typename T::type". ...
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply...
bool isValid() const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
ASTContext & getASTContext() const
Definition: Sema.h:1069
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
Definition: SemaInternal.h:93
ValueKind getKind() const
Definition: APValue.h:180
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3185
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1736
unsigned getDepth() const
Retrieve the depth of the template parameter.
void print(const PrintingPolicy &Policy, raw_ostream &Out) const
Print this template argument to the given output stream.
SourceLocation getNameLoc() const
Definition: TypeLoc.h:493
QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc)
Check that the type of a non-type template parameter is well-formed.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Sema/Lookup.h:52
static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized, NamedDecl *PrevDecl, SourceLocation Loc, bool IsPartialSpecialization)
Check whether a specialization is well-formed in the current context.
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template...
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:707
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
Definition: Scope.h:365
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:82
bool Matches
void setPointOfInstantiation(SourceLocation Loc)
A class for iterating through a result set and possibly filtering out results.
Definition: Sema/Lookup.h:600
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1843
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2734
SourceLocation getBegin() const
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:165
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5849
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
No entity found met the criteria.
Definition: Sema/Lookup.h:34
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:159
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:144
bool isFileContext() const
Definition: DeclBase.h:1279
PtrTy get() const
Definition: Ownership.h:75
A template type parameter, stored as a type.
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization, returns the templated static data member from which it was instantiated.
Definition: Decl.cpp:2249
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema's representation of template deduction information to the form used in overload-can...
Attr * clone(ASTContext &C) const
void checkPartialSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We've found a use of a template specialization that would select a partial specialization.
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:70
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:563
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:245
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:193
void UnmarkAsLateParsedTemplate(FunctionDecl *FD)
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4294
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1302
QualType getPointeeType() const
Definition: Type.h:2193
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:2791
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Represents a pack expansion of types.
Definition: Type.h:4641
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
A POD class for pairing a NamedDecl* with an access specifier.
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1451
TypeResult ActOnTagTemplateIdType(TagUseKind TUK, TypeSpecifierType TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy TemplateD, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc)
Parsed an elaborated-type-specifier that refers to a template-id, such as class T::template apply<U>...
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1760
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template...
Definition: Decl.cpp:2294
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
Decl * ActOnTemplateTemplateParameter(Scope *S, SourceLocation TmpLoc, TemplateParameterList *Params, SourceLocation EllipsisLoc, IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth, unsigned Position, SourceLocation EqualLoc, ParsedTemplateArgument DefaultArg)
ActOnTemplateTemplateParameter - Called when a C++ template template parameter (e.g.
QualType getType() const
Definition: Expr.h:126
Represents a template argument.
Definition: TemplateBase.h:40
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1310
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:238
TagTypeKind
The kind of a tag type.
Definition: Type.h:4342
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3169
The name does not refer to a template.
Definition: TemplateKinds.h:23
const CXXScopeSpec & getScopeSpec() const
Retrieve the nested-name-specifier that precedes the template name in a template template argument...
void setMemberSpecialization()
Note that this member template is a specialization.
bool RebuildTemplateParamsInCurrentInstantiation(TemplateParameterList *Params)
Rebuild the template parameters now that we know we're in a current instantiation.
void removeDefaultArgument()
Removes the default argument of this template parameter.
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:3030
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
UnaryOperatorKind
ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1135
CanQualType NullPtrTy
Definition: ASTContext.h:908
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:562
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:330
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Sema/Lookup.h:257
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
bool isDependent() const
Determines whether this is a dependent template name.
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
Definition: Sema.cpp:368
SourceLocation getLocStart() const LLVM_READONLY
Definition: TypeLoc.h:130
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:63
TemplateSpecializationKind getTemplateSpecializationKind() const
If this enumeration is a member of a specialization of a templated class, determine what kind of temp...
Definition: Decl.cpp:3666
SourceRange getSourceRange(const SourceRange &Range)
Returns the SourceRange of a SourceRange.
Definition: FixIt.h:34
CXXScopeSpec SS
The nested-name-specifier that precedes the template name.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
TemplateName getCanonicalTemplateName(TemplateName Name) const
Retrieves the "canonical" template name that refers to a given template.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:104
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:76
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:155
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:522
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
DeclarationName - The name of a declaration.
void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo &TemplateArgs)
Specifies that this function declaration is actually a dependent function template specialization...
Definition: Decl.cpp:3230
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3581
std::string getAsString(ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:545
bool isThisDeclarationADefinition() const
isThisDeclarationADefinition - Returns whether this specific declaration of the function is also a de...
Definition: Decl.h:1814
EnumDecl - Represents an enum.
Definition: Decl.h:3013
detail::InMemoryDirectory::const_iterator E
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2401
This names the __type_pack_element BuiltinTemplateDecl.
Definition: Builtins.h:225
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:141
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set...
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Sema/Lookup.h:292
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1966
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
A type that was preceded by the 'template' keyword, stored as a Type*.
The name refers to a template whose specialization produces a type.
Definition: TemplateKinds.h:30
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
bool isWideCharType() const
Definition: Type.cpp:1665
unsigned getDepth() const
Get the nesting depth of the template parameter.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:5432
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1807
Represents a pointer to an Objective C object.
Definition: Type.h:4991
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:127
Pointer to a block type.
Definition: Type.h:2286
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
Name lookup found a single declaration that met the criteria.
Definition: Sema/Lookup.h:43
bool empty() const
Return true if no decls were found.
Definition: Sema/Lookup.h:323
ArrayRef< LValuePathEntry > getLValuePath() const
Definition: APValue.cpp:573
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:191
bool HasSideEffects
Whether the evaluated expression has side effects.
Definition: Expr.h:535
bool hasVisibleMemberSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module * > *Modules=nullptr)
Determine if there is a visible declaration of D that is a member specialization declaration (as oppo...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3707
Complex values, per C99 6.2.5p11.
Definition: Type.h:2119
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:427
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:3590
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5818
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3290
CheckTemplateArgumentKind
Specifies the context in which a particular template argument is being checked.
Definition: Sema.h:5889
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
Definition: DeclTemplate.h:540
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:151
static SourceRange findTemplateParameter(unsigned Depth, Expr *E)
static VarTemplatePartialSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args, const TemplateArgumentListInfo &ArgInfos)
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3273
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)
Definition: Expr.cpp:1673
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:294
bool isNull() const
Determine whether this template name is NULL.
void setTypeSourceInfo(TypeSourceInfo *TI)
Definition: Decl.h:676
void setInstantiationOfStaticDataMember(VarDecl *VD, TemplateSpecializationKind TSK)
Specify that this variable is an instantiation of the static data member VD.
Definition: Decl.cpp:2317
ExplicitSpecializationVisibilityChecker(Sema &S, SourceLocation Loc)
bool isFunctionType() const
Definition: Type.h:5479
ExtVectorType - Extended vector type.
Definition: Type.h:2816
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList * > ParamLists, bool IsFriend, bool &IsExplicitSpecialization, bool &Invalid)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2319
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1534
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1528
bool isInvalid() const
Determine whether the given template argument is invalid.
TypeSourceInfo * RebuildTypeInCurrentInstantiation(TypeSourceInfo *T, SourceLocation Loc, DeclarationName Name)
Rebuilds a type within the context of the current instantiation.
SourceRange getTemplateParamsRange(TemplateParameterList const *const *Params, unsigned NumParams)
Retrieves the range of the given template parameter lists.
DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy Template, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, AttributeList *Attr)
The template argument is a type.
Definition: TemplateBase.h:48
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
ActionResult< ParsedType > TypeResult
Definition: Ownership.h:255
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:78
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1296
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:379
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:551
bool isInlineSpecified() const
Definition: DeclSpec.h:560
The template argument is actually a parameter pack.
Definition: TemplateBase.h:72
A template-id, e.g., f<int>.
Definition: DeclSpec.h:907
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1058
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2533
static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS)
Determine whether the given scope specifier has a template-id in it.
bool isConcept() const
Whether this is a (C++ Concepts TS) function or variable concept.
Definition: DeclTemplate.h:372
void setInstantiationOf(VarTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this variable template specialization is actually an instantiation of the given variable te...
QualType getPointeeType() const
Definition: Type.h:2340
This is a scope that can contain a declaration.
Definition: Scope.h:58
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:1972
A template argument list.
Definition: DeclTemplate.h:173
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
const Type * getClass() const
Definition: Type.h:2434
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II)
getCXXLiteralOperatorName - Get the name of the literal operator function with II as the identifier...
TemplateNameKind ActOnDependentTemplateName(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template)
Form a dependent template name.
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:335
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:1978
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5339
const LValueBase getLValueBase() const
Definition: APValue.cpp:553
Represents a C++ struct/union/class.
Definition: DeclCXX.h:263
BoundNodesTreeBuilder *const Builder
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
A user-defined literal name, e.g., operator "" _i.
Definition: DeclSpec.h:899
Decl * D
The template function declaration to be late parsed.
Definition: Sema.h:9646
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:60
Represents a C array with an unspecified size.
Definition: Type.h:2562
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:445
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member...
Definition: Decl.cpp:2065
void setConstexpr(bool IC)
Definition: Decl.h:1884
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
Definition: Sema.h:814
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:500
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
A structure for storing the information associated with an overloaded template name.
Definition: TemplateName.h:93
ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
Location information for a TemplateArgument.
Definition: TemplateBase.h:368
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:311
The "enum" keyword.
Definition: Type.h:4352
Declaration of a class template.
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
Definition: DeclBase.cpp:891
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:115
This class is used for builtin types like 'int'.
Definition: Type.h:2039
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:353
LookupResultKind getResultKind() const
Definition: Sema/Lookup.h:305
bool isArrayType() const
Definition: Type.h:5521
DeclResult ActOnVarTemplateSpecialization(Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, StorageClass SC, bool IsPartialSpecialization)
static TemplateArgumentListInfo makeTemplateArgumentListInfo(Sema &S, TemplateIdAnnotation &TemplateId)
Convert the parser's template argument list representation into our form.
Defines the clang::TargetInfo interface.
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:4668
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1330
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1465
static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D, SourceLocation InstLoc, bool WasQualifiedName)
Check the scope of an explicit instantiation.
ExprResult ExprError()
Definition: Ownership.h:268
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:810
CanQualType IntTy
Definition: ASTContext.h:901
bool isRecord() const
Definition: DeclBase.h:1287
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
void LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, bool &MemberOfUnknownSpecialization)
The name refers to a variable template whose specialization produces a variable.
Definition: TemplateKinds.h:33
bool hasEllipsis() const
Definition: DeclSpec.h:2233
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:196
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:932
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:401
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
NamedDecl * getMostRecentDecl()
Definition: Decl.h:401
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:133
QualType getElementType() const
Definition: Type.h:2490
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5334
void setMemberSpecialization()
Note that this member template is a specialization.
void setInheritedDefaultArgument(const ASTContext &C, TemplateTemplateParmDecl *Prev)
static bool diagnoseArityMismatch(Sema &S, TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
Diagnose an arity mismatch in the.
Contains a late templated function.
Definition: Sema.h:9643
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Sema/Lookup.h:566
AttributeList * getNext() const
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:109
static bool DependsOnTemplateParameters(QualType T, TemplateParameterList *Params)
Determines whether a given type depends on the given parameter list.
StringRef getKindName() const
Definition: Decl.h:2926
Wrapper for template type parameters.
Definition: TypeLoc.h:688
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
Definition: Sema.h:6910
A trivial tuple used to represent a source range.
static VarTemplateSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< TemplateArgument > Args)
ASTContext & Context
Definition: Sema.h:299
FunctionDecl * getCanonicalDecl() override
Definition: Decl.cpp:2676
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
bool isInvalidType() const
Definition: DeclSpec.h:2222
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:471
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization, retrieves the function from which it was instantiated.
Definition: Decl.cpp:3046
SourceLocation getDefaultArgumentLoc() const
Retrieve the location of the default argument, if any.
A template template argument, stored as a template name.
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2607
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1486
No keyword precedes the qualified type name.
Definition: Type.h:4372
APSInt & getInt()
Definition: APValue.h:200
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:665
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
unsigned NumArgs
NumArgs - The number of template arguments.
The global specifier '::'. There is no stored value.
void setType(QualType newType)
Definition: Decl.h:600
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:470
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:135
void setDeletedAsWritten(bool D=true)
Definition: Decl.h:1911
TemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon, QualType Aliased)
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2512
Defines enum values for all the target-independent builtin functions.
Declaration of a template function.
Definition: DeclTemplate.h:838
void clear()
Clears out any current state.
Definition: Sema/Lookup.h:538
bool IsInsideALocalClassWithinATemplateFunction()
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1730
Attr - This represents one attribute.
Definition: Attr.h:45
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:749
static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc, TemplateDecl *TD, const TemplateParmDecl *D, TemplateArgumentListInfo &Args)
Diagnose a missing template argument.
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > & getPartialSpecializations()
Retrieve the set of partial specializations of this class template.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1729
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:94
TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity)
Perform substitution on the type T with a given set of template arguments.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5286
bool isLValue() const
Definition: APValue.h:186
bool isPointerType() const
Definition: Type.h:5482
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
A RAII object to temporarily push a declaration context.
Definition: Sema.h:634
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:131
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type...
Definition: Type.h:1583
QualType getDeducedType() const
Get the type deduced for this auto type, or null if it's either not been deduced or was deduced to a ...
Definition: Type.h:4111