clang  7.0.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 namespace clang {
49 /// [temp.constr.decl]p2: A template's associated constraints are
50 /// defined as a single constraint-expression derived from the introduced
51 /// constraint-expressions [ ... ].
52 ///
53 /// \param Params The template parameter list and optional requires-clause.
54 ///
55 /// \param FD The underlying templated function declaration for a function
56 /// template.
58  FunctionDecl *FD);
59 }
60 
62  FunctionDecl *FD) {
63  // FIXME: Concepts: collect additional introduced constraint-expressions
64  assert(!FD && "Cannot collect constraints from function declaration yet.");
65  return Params->getRequiresClause();
66 }
67 
68 /// Determine whether the declaration found is acceptable as the name
69 /// of a template and, if so, return that template declaration. Otherwise,
70 /// returns NULL.
72  NamedDecl *Orig,
73  bool AllowFunctionTemplates) {
74  NamedDecl *D = Orig->getUnderlyingDecl();
75 
76  if (isa<TemplateDecl>(D)) {
77  if (!AllowFunctionTemplates && isa<FunctionTemplateDecl>(D))
78  return nullptr;
79 
80  return Orig;
81  }
82 
83  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
84  // C++ [temp.local]p1:
85  // Like normal (non-template) classes, class templates have an
86  // injected-class-name (Clause 9). The injected-class-name
87  // can be used with or without a template-argument-list. When
88  // it is used without a template-argument-list, it is
89  // equivalent to the injected-class-name followed by the
90  // template-parameters of the class template enclosed in
91  // <>. When it is used with a template-argument-list, it
92  // refers to the specified class template specialization,
93  // which could be the current specialization or another
94  // specialization.
95  if (Record->isInjectedClassName()) {
96  Record = cast<CXXRecordDecl>(Record->getDeclContext());
97  if (Record->getDescribedClassTemplate())
98  return Record->getDescribedClassTemplate();
99 
101  = dyn_cast<ClassTemplateSpecializationDecl>(Record))
102  return Spec->getSpecializedTemplate();
103  }
104 
105  return nullptr;
106  }
107 
108  // 'using Dependent::foo;' can resolve to a template name.
109  // 'using typename Dependent::foo;' cannot (not even if 'foo' is an
110  // injected-class-name).
111  if (isa<UnresolvedUsingValueDecl>(D))
112  return D;
113 
114  return nullptr;
115 }
116 
118  bool AllowFunctionTemplates) {
119  // The set of class templates we've already seen.
120  llvm::SmallPtrSet<ClassTemplateDecl *, 8> ClassTemplates;
121  LookupResult::Filter filter = R.makeFilter();
122  while (filter.hasNext()) {
123  NamedDecl *Orig = filter.next();
124  NamedDecl *Repl = isAcceptableTemplateName(Context, Orig,
125  AllowFunctionTemplates);
126  if (!Repl)
127  filter.erase();
128  else if (Repl != Orig) {
129 
130  // C++ [temp.local]p3:
131  // A lookup that finds an injected-class-name (10.2) can result in an
132  // ambiguity in certain cases (for example, if it is found in more than
133  // one base class). If all of the injected-class-names that are found
134  // refer to specializations of the same class template, and if the name
135  // is used as a template-name, the reference refers to the class
136  // template itself and not a specialization thereof, and is not
137  // ambiguous.
138  if (ClassTemplateDecl *ClassTmpl = dyn_cast<ClassTemplateDecl>(Repl))
139  if (!ClassTemplates.insert(ClassTmpl).second) {
140  filter.erase();
141  continue;
142  }
143 
144  // FIXME: we promote access to public here as a workaround to
145  // the fact that LookupResult doesn't let us remember that we
146  // found this template through a particular injected class name,
147  // which means we end up doing nasty things to the invariants.
148  // Pretending that access is public is *much* safer.
149  filter.replace(Repl, AS_public);
150  }
151  }
152  filter.done();
153 }
154 
156  bool AllowFunctionTemplates) {
157  for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I)
158  if (isAcceptableTemplateName(Context, *I, AllowFunctionTemplates))
159  return true;
160 
161  return false;
162 }
163 
165  CXXScopeSpec &SS,
166  bool hasTemplateKeyword,
167  const UnqualifiedId &Name,
168  ParsedType ObjectTypePtr,
169  bool EnteringContext,
170  TemplateTy &TemplateResult,
171  bool &MemberOfUnknownSpecialization) {
172  assert(getLangOpts().CPlusPlus && "No template names in C!");
173 
174  DeclarationName TName;
175  MemberOfUnknownSpecialization = false;
176 
177  switch (Name.getKind()) {
179  TName = DeclarationName(Name.Identifier);
180  break;
181 
183  TName = Context.DeclarationNames.getCXXOperatorName(
185  break;
186 
189  break;
190 
191  default:
192  return TNK_Non_template;
193  }
194 
195  QualType ObjectType = ObjectTypePtr.get();
196 
197  LookupResult R(*this, TName, Name.getLocStart(), LookupOrdinaryName);
198  if (LookupTemplateName(R, S, SS, ObjectType, EnteringContext,
199  MemberOfUnknownSpecialization))
200  return TNK_Non_template;
201  if (R.empty()) return TNK_Non_template;
202  if (R.isAmbiguous()) {
203  // Suppress diagnostics; we'll redo this lookup later.
204  R.suppressDiagnostics();
205 
206  // FIXME: we might have ambiguous templates, in which case we
207  // should at least parse them properly!
208  return TNK_Non_template;
209  }
210 
211  TemplateName Template;
212  TemplateNameKind TemplateKind;
213 
214  unsigned ResultCount = R.end() - R.begin();
215  if (ResultCount > 1) {
216  // We assume that we'll preserve the qualifier from a function
217  // template name in other ways.
218  Template = Context.getOverloadedTemplateName(R.begin(), R.end());
219  TemplateKind = TNK_Function_template;
220 
221  // We'll do this lookup again later.
222  R.suppressDiagnostics();
223  } else if (isa<UnresolvedUsingValueDecl>((*R.begin())->getUnderlyingDecl())) {
224  // We don't yet know whether this is a template-name or not.
225  MemberOfUnknownSpecialization = true;
226  return TNK_Non_template;
227  } else {
228  TemplateDecl *TD = cast<TemplateDecl>((*R.begin())->getUnderlyingDecl());
229 
230  if (SS.isSet() && !SS.isInvalid()) {
231  NestedNameSpecifier *Qualifier = SS.getScopeRep();
232  Template = Context.getQualifiedTemplateName(Qualifier,
233  hasTemplateKeyword, TD);
234  } else {
235  Template = TemplateName(TD);
236  }
237 
238  if (isa<FunctionTemplateDecl>(TD)) {
239  TemplateKind = TNK_Function_template;
240 
241  // We'll do this lookup again later.
242  R.suppressDiagnostics();
243  } else {
244  assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
245  isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||
246  isa<BuiltinTemplateDecl>(TD));
247  TemplateKind =
248  isa<VarTemplateDecl>(TD) ? TNK_Var_template : TNK_Type_template;
249  }
250  }
251 
252  TemplateResult = TemplateTy::make(Template);
253  return TemplateKind;
254 }
255 
257  SourceLocation NameLoc,
258  ParsedTemplateTy *Template) {
259  CXXScopeSpec SS;
260  bool MemberOfUnknownSpecialization = false;
261 
262  // We could use redeclaration lookup here, but we don't need to: the
263  // syntactic form of a deduction guide is enough to identify it even
264  // if we can't look up the template name at all.
265  LookupResult R(*this, DeclarationName(&Name), NameLoc, LookupOrdinaryName);
266  if (LookupTemplateName(R, S, SS, /*ObjectType*/ QualType(),
267  /*EnteringContext*/ false,
268  MemberOfUnknownSpecialization))
269  return false;
270 
271  if (R.empty()) return false;
272  if (R.isAmbiguous()) {
273  // FIXME: Diagnose an ambiguity if we find at least one template.
275  return false;
276  }
277 
278  // We only treat template-names that name type templates as valid deduction
279  // guide names.
281  if (!TD || !getAsTypeTemplateDecl(TD))
282  return false;
283 
284  if (Template)
285  *Template = TemplateTy::make(TemplateName(TD));
286  return true;
287 }
288 
290  SourceLocation IILoc,
291  Scope *S,
292  const CXXScopeSpec *SS,
293  TemplateTy &SuggestedTemplate,
294  TemplateNameKind &SuggestedKind) {
295  // We can't recover unless there's a dependent scope specifier preceding the
296  // template name.
297  // FIXME: Typo correction?
298  if (!SS || !SS->isSet() || !isDependentScopeSpecifier(*SS) ||
299  computeDeclContext(*SS))
300  return false;
301 
302  // The code is missing a 'template' keyword prior to the dependent template
303  // name.
305  Diag(IILoc, diag::err_template_kw_missing)
306  << Qualifier << II.getName()
307  << FixItHint::CreateInsertion(IILoc, "template ");
308  SuggestedTemplate
309  = TemplateTy::make(Context.getDependentTemplateName(Qualifier, &II));
310  SuggestedKind = TNK_Dependent_template_name;
311  return true;
312 }
313 
315  Scope *S, CXXScopeSpec &SS,
316  QualType ObjectType,
317  bool EnteringContext,
318  bool &MemberOfUnknownSpecialization,
319  SourceLocation TemplateKWLoc) {
320  // Determine where to perform name lookup
321  MemberOfUnknownSpecialization = false;
322  DeclContext *LookupCtx = nullptr;
323  bool IsDependent = false;
324  if (!ObjectType.isNull()) {
325  // This nested-name-specifier occurs in a member access expression, e.g.,
326  // x->B::f, and we are looking into the type of the object.
327  assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
328  LookupCtx = computeDeclContext(ObjectType);
329  IsDependent = !LookupCtx;
330  assert((IsDependent || !ObjectType->isIncompleteType() ||
331  ObjectType->castAs<TagType>()->isBeingDefined()) &&
332  "Caller should have completed object type");
333 
334  // Template names cannot appear inside an Objective-C class or object type.
335  if (ObjectType->isObjCObjectOrInterfaceType()) {
336  Found.clear();
337  return false;
338  }
339  } else if (SS.isSet()) {
340  // This nested-name-specifier occurs after another nested-name-specifier,
341  // so long into the context associated with the prior nested-name-specifier.
342  LookupCtx = computeDeclContext(SS, EnteringContext);
343  IsDependent = !LookupCtx;
344 
345  // The declaration context must be complete.
346  if (LookupCtx && RequireCompleteDeclContext(SS, LookupCtx))
347  return true;
348  }
349 
350  bool ObjectTypeSearchedInScope = false;
351  bool AllowFunctionTemplatesInLookup = true;
352  if (LookupCtx) {
353  // Perform "qualified" name lookup into the declaration context we
354  // computed, which is either the type of the base of a member access
355  // expression or the declaration context associated with a prior
356  // nested-name-specifier.
357  LookupQualifiedName(Found, LookupCtx);
358 
359  // FIXME: The C++ standard does not clearly specify what happens in the
360  // case where the object type is dependent, and implementations vary. In
361  // Clang, we treat a name after a . or -> as a template-name if lookup
362  // finds a non-dependent member or member of the current instantiation that
363  // is a type template, or finds no such members and lookup in the context
364  // of the postfix-expression finds a type template. In the latter case, the
365  // name is nonetheless dependent, and we may resolve it to a member of an
366  // unknown specialization when we come to instantiate the template.
367  IsDependent |= Found.wasNotFoundInCurrentInstantiation();
368  }
369 
370  if (!SS.isSet() && (ObjectType.isNull() || Found.empty())) {
371  // C++ [basic.lookup.classref]p1:
372  // In a class member access expression (5.2.5), if the . or -> token is
373  // immediately followed by an identifier followed by a <, the
374  // identifier must be looked up to determine whether the < is the
375  // beginning of a template argument list (14.2) or a less-than operator.
376  // The identifier is first looked up in the class of the object
377  // expression. If the identifier is not found, it is then looked up in
378  // the context of the entire postfix-expression and shall name a class
379  // template.
380  if (S)
381  LookupName(Found, S);
382 
383  if (!ObjectType.isNull()) {
384  // FIXME: We should filter out all non-type templates here, particularly
385  // variable templates and concepts. But the exclusion of alias templates
386  // and template template parameters is a wording defect.
387  AllowFunctionTemplatesInLookup = false;
388  ObjectTypeSearchedInScope = true;
389  }
390 
391  IsDependent |= Found.wasNotFoundInCurrentInstantiation();
392  }
393 
394  if (Found.empty() && !IsDependent) {
395  // If we did not find any names, attempt to correct any typos.
396  DeclarationName Name = Found.getLookupName();
397  Found.clear();
398  // Simple filter callback that, for keywords, only accepts the C++ *_cast
399  auto FilterCCC = llvm::make_unique<CorrectionCandidateCallback>();
400  FilterCCC->WantTypeSpecifiers = false;
401  FilterCCC->WantExpressionKeywords = false;
402  FilterCCC->WantRemainingKeywords = false;
403  FilterCCC->WantCXXNamedCasts = true;
404  if (TypoCorrection Corrected = CorrectTypo(
405  Found.getLookupNameInfo(), Found.getLookupKind(), S, &SS,
406  std::move(FilterCCC), CTK_ErrorRecovery, LookupCtx)) {
407  Found.setLookupName(Corrected.getCorrection());
408  if (auto *ND = Corrected.getFoundDecl())
409  Found.addDecl(ND);
410  FilterAcceptableTemplateNames(Found);
411  if (!Found.empty()) {
412  if (LookupCtx) {
413  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
414  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
415  Name.getAsString() == CorrectedStr;
416  diagnoseTypo(Corrected, PDiag(diag::err_no_member_template_suggest)
417  << Name << LookupCtx << DroppedSpecifier
418  << SS.getRange());
419  } else {
420  diagnoseTypo(Corrected, PDiag(diag::err_no_template_suggest) << Name);
421  }
422  }
423  } else {
424  Found.setLookupName(Name);
425  }
426  }
427 
428  NamedDecl *ExampleLookupResult =
429  Found.empty() ? nullptr : Found.getRepresentativeDecl();
430  FilterAcceptableTemplateNames(Found, AllowFunctionTemplatesInLookup);
431  if (Found.empty()) {
432  if (IsDependent) {
433  MemberOfUnknownSpecialization = true;
434  return false;
435  }
436 
437  // If a 'template' keyword was used, a lookup that finds only non-template
438  // names is an error.
439  if (ExampleLookupResult && TemplateKWLoc.isValid()) {
440  Diag(Found.getNameLoc(), diag::err_template_kw_refers_to_non_template)
441  << Found.getLookupName() << SS.getRange();
442  Diag(ExampleLookupResult->getUnderlyingDecl()->getLocation(),
443  diag::note_template_kw_refers_to_non_template)
444  << Found.getLookupName();
445  return true;
446  }
447 
448  return false;
449  }
450 
451  if (S && !ObjectType.isNull() && !ObjectTypeSearchedInScope &&
452  !getLangOpts().CPlusPlus11) {
453  // C++03 [basic.lookup.classref]p1:
454  // [...] If the lookup in the class of the object expression finds a
455  // template, the name is also looked up in the context of the entire
456  // postfix-expression and [...]
457  //
458  // Note: C++11 does not perform this second lookup.
459  LookupResult FoundOuter(*this, Found.getLookupName(), Found.getNameLoc(),
460  LookupOrdinaryName);
461  LookupName(FoundOuter, S);
462  FilterAcceptableTemplateNames(FoundOuter, /*AllowFunctionTemplates=*/false);
463 
464  if (FoundOuter.empty()) {
465  // - if the name is not found, the name found in the class of the
466  // object expression is used, otherwise
467  } else if (!FoundOuter.getAsSingle<ClassTemplateDecl>() ||
468  FoundOuter.isAmbiguous()) {
469  // - if the name is found in the context of the entire
470  // postfix-expression and does not name a class template, the name
471  // found in the class of the object expression is used, otherwise
472  FoundOuter.clear();
473  } else if (!Found.isSuppressingDiagnostics()) {
474  // - if the name found is a class template, it must refer to the same
475  // entity as the one found in the class of the object expression,
476  // otherwise the program is ill-formed.
477  if (!Found.isSingleResult() ||
478  Found.getFoundDecl()->getCanonicalDecl()
479  != FoundOuter.getFoundDecl()->getCanonicalDecl()) {
480  Diag(Found.getNameLoc(),
481  diag::ext_nested_name_member_ref_lookup_ambiguous)
482  << Found.getLookupName()
483  << ObjectType;
485  diag::note_ambig_member_ref_object_type)
486  << ObjectType;
487  Diag(FoundOuter.getFoundDecl()->getLocation(),
488  diag::note_ambig_member_ref_scope);
489 
490  // Recover by taking the template that we found in the object
491  // expression's type.
492  }
493  }
494  }
495 
496  return false;
497 }
498 
500  SourceLocation Less,
501  SourceLocation Greater) {
502  if (TemplateName.isInvalid())
503  return;
504 
505  DeclarationNameInfo NameInfo;
506  CXXScopeSpec SS;
507  LookupNameKind LookupKind;
508 
509  DeclContext *LookupCtx = nullptr;
510  NamedDecl *Found = nullptr;
511  bool MissingTemplateKeyword = false;
512 
513  // Figure out what name we looked up.
514  if (auto *DRE = dyn_cast<DeclRefExpr>(TemplateName.get())) {
515  NameInfo = DRE->getNameInfo();
516  SS.Adopt(DRE->getQualifierLoc());
517  LookupKind = LookupOrdinaryName;
518  Found = DRE->getFoundDecl();
519  } else if (auto *ME = dyn_cast<MemberExpr>(TemplateName.get())) {
520  NameInfo = ME->getMemberNameInfo();
521  SS.Adopt(ME->getQualifierLoc());
522  LookupKind = LookupMemberName;
523  LookupCtx = ME->getBase()->getType()->getAsCXXRecordDecl();
524  Found = ME->getMemberDecl();
525  } else if (auto *DSDRE =
526  dyn_cast<DependentScopeDeclRefExpr>(TemplateName.get())) {
527  NameInfo = DSDRE->getNameInfo();
528  SS.Adopt(DSDRE->getQualifierLoc());
529  MissingTemplateKeyword = true;
530  } else if (auto *DSME =
531  dyn_cast<CXXDependentScopeMemberExpr>(TemplateName.get())) {
532  NameInfo = DSME->getMemberNameInfo();
533  SS.Adopt(DSME->getQualifierLoc());
534  MissingTemplateKeyword = true;
535  } else {
536  llvm_unreachable("unexpected kind of potential template name");
537  }
538 
539  // If this is a dependent-scope lookup, diagnose that the 'template' keyword
540  // was missing.
541  if (MissingTemplateKeyword) {
542  Diag(NameInfo.getLocStart(), diag::err_template_kw_missing)
543  << "" << NameInfo.getName().getAsString()
544  << SourceRange(Less, Greater);
545  return;
546  }
547 
548  // Try to correct the name by looking for templates and C++ named casts.
549  struct TemplateCandidateFilter : CorrectionCandidateCallback {
550  TemplateCandidateFilter() {
551  WantTypeSpecifiers = false;
552  WantExpressionKeywords = false;
553  WantRemainingKeywords = false;
554  WantCXXNamedCasts = true;
555  };
556  bool ValidateCandidate(const TypoCorrection &Candidate) override {
557  if (auto *ND = Candidate.getCorrectionDecl())
558  return isAcceptableTemplateName(ND->getASTContext(), ND, true);
559  return Candidate.isKeyword();
560  }
561  };
562 
563  DeclarationName Name = NameInfo.getName();
564  if (TypoCorrection Corrected =
565  CorrectTypo(NameInfo, LookupKind, S, &SS,
566  llvm::make_unique<TemplateCandidateFilter>(),
567  CTK_ErrorRecovery, LookupCtx)) {
568  auto *ND = Corrected.getFoundDecl();
569  if (ND)
570  ND = isAcceptableTemplateName(Context, ND,
571  /*AllowFunctionTemplates*/ true);
572  if (ND || Corrected.isKeyword()) {
573  if (LookupCtx) {
574  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
575  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
576  Name.getAsString() == CorrectedStr;
577  diagnoseTypo(Corrected,
578  PDiag(diag::err_non_template_in_member_template_id_suggest)
579  << Name << LookupCtx << DroppedSpecifier
580  << SS.getRange(), false);
581  } else {
582  diagnoseTypo(Corrected,
583  PDiag(diag::err_non_template_in_template_id_suggest)
584  << Name, false);
585  }
586  if (Found)
587  Diag(Found->getLocation(),
588  diag::note_non_template_in_template_id_found);
589  return;
590  }
591  }
592 
593  Diag(NameInfo.getLoc(), diag::err_non_template_in_template_id)
594  << Name << SourceRange(Less, Greater);
595  if (Found)
596  Diag(Found->getLocation(), diag::note_non_template_in_template_id_found);
597 }
598 
599 /// ActOnDependentIdExpression - Handle a dependent id-expression that
600 /// was just parsed. This is only possible with an explicit scope
601 /// specifier naming a dependent type.
604  SourceLocation TemplateKWLoc,
605  const DeclarationNameInfo &NameInfo,
606  bool isAddressOfOperand,
607  const TemplateArgumentListInfo *TemplateArgs) {
608  DeclContext *DC = getFunctionLevelDeclContext();
609 
610  // C++11 [expr.prim.general]p12:
611  // An id-expression that denotes a non-static data member or non-static
612  // member function of a class can only be used:
613  // (...)
614  // - if that id-expression denotes a non-static data member and it
615  // appears in an unevaluated operand.
616  //
617  // If this might be the case, form a DependentScopeDeclRefExpr instead of a
618  // CXXDependentScopeMemberExpr. The former can instantiate to either
619  // DeclRefExpr or MemberExpr depending on lookup results, while the latter is
620  // always a MemberExpr.
621  bool MightBeCxx11UnevalField =
622  getLangOpts().CPlusPlus11 && isUnevaluatedContext();
623 
624  // Check if the nested name specifier is an enum type.
625  bool IsEnum = false;
626  if (NestedNameSpecifier *NNS = SS.getScopeRep())
627  IsEnum = dyn_cast_or_null<EnumType>(NNS->getAsType());
628 
629  if (!MightBeCxx11UnevalField && !isAddressOfOperand && !IsEnum &&
630  isa<CXXMethodDecl>(DC) && cast<CXXMethodDecl>(DC)->isInstance()) {
631  QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType(Context);
632 
633  // Since the 'this' expression is synthesized, we don't need to
634  // perform the double-lookup check.
635  NamedDecl *FirstQualifierInScope = nullptr;
636 
638  Context, /*This*/ nullptr, ThisType, /*IsArrow*/ true,
639  /*Op*/ SourceLocation(), SS.getWithLocInContext(Context), TemplateKWLoc,
640  FirstQualifierInScope, NameInfo, TemplateArgs);
641  }
642 
643  return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
644 }
645 
648  SourceLocation TemplateKWLoc,
649  const DeclarationNameInfo &NameInfo,
650  const TemplateArgumentListInfo *TemplateArgs) {
652  Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
653  TemplateArgs);
654 }
655 
656 
657 /// Determine whether we would be unable to instantiate this template (because
658 /// it either has no definition, or is in the process of being instantiated).
660  NamedDecl *Instantiation,
661  bool InstantiatedFromMember,
662  const NamedDecl *Pattern,
663  const NamedDecl *PatternDef,
665  bool Complain /*= true*/) {
666  assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||
667  isa<VarDecl>(Instantiation));
668 
669  bool IsEntityBeingDefined = false;
670  if (const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
671  IsEntityBeingDefined = TD->isBeingDefined();
672 
673  if (PatternDef && !IsEntityBeingDefined) {
674  NamedDecl *SuggestedDef = nullptr;
675  if (!hasVisibleDefinition(const_cast<NamedDecl*>(PatternDef), &SuggestedDef,
676  /*OnlyNeedComplete*/false)) {
677  // If we're allowed to diagnose this and recover, do so.
678  bool Recover = Complain && !isSFINAEContext();
679  if (Complain)
680  diagnoseMissingImport(PointOfInstantiation, SuggestedDef,
682  return !Recover;
683  }
684  return false;
685  }
686 
687  if (!Complain || (PatternDef && PatternDef->isInvalidDecl()))
688  return true;
689 
691  QualType InstantiationTy;
692  if (TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
693  InstantiationTy = Context.getTypeDeclType(TD);
694  if (PatternDef) {
695  Diag(PointOfInstantiation,
696  diag::err_template_instantiate_within_definition)
697  << /*implicit|explicit*/(TSK != TSK_ImplicitInstantiation)
698  << InstantiationTy;
699  // Not much point in noting the template declaration here, since
700  // we're lexically inside it.
701  Instantiation->setInvalidDecl();
702  } else if (InstantiatedFromMember) {
703  if (isa<FunctionDecl>(Instantiation)) {
704  Diag(PointOfInstantiation,
705  diag::err_explicit_instantiation_undefined_member)
706  << /*member function*/ 1 << Instantiation->getDeclName()
707  << Instantiation->getDeclContext();
708  Note = diag::note_explicit_instantiation_here;
709  } else {
710  assert(isa<TagDecl>(Instantiation) && "Must be a TagDecl!");
711  Diag(PointOfInstantiation,
712  diag::err_implicit_instantiate_member_undefined)
713  << InstantiationTy;
714  Note = diag::note_member_declared_at;
715  }
716  } else {
717  if (isa<FunctionDecl>(Instantiation)) {
718  Diag(PointOfInstantiation,
719  diag::err_explicit_instantiation_undefined_func_template)
720  << Pattern;
721  Note = diag::note_explicit_instantiation_here;
722  } else if (isa<TagDecl>(Instantiation)) {
723  Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
724  << (TSK != TSK_ImplicitInstantiation)
725  << InstantiationTy;
726  Note = diag::note_template_decl_here;
727  } else {
728  assert(isa<VarDecl>(Instantiation) && "Must be a VarDecl!");
729  if (isa<VarTemplateSpecializationDecl>(Instantiation)) {
730  Diag(PointOfInstantiation,
731  diag::err_explicit_instantiation_undefined_var_template)
732  << Instantiation;
733  Instantiation->setInvalidDecl();
734  } else
735  Diag(PointOfInstantiation,
736  diag::err_explicit_instantiation_undefined_member)
737  << /*static data member*/ 2 << Instantiation->getDeclName()
738  << Instantiation->getDeclContext();
739  Note = diag::note_explicit_instantiation_here;
740  }
741  }
742  if (Note) // Diagnostics were emitted.
743  Diag(Pattern->getLocation(), Note.getValue());
744 
745  // In general, Instantiation isn't marked invalid to get more than one
746  // error for multiple undefined instantiations. But the code that does
747  // explicit declaration -> explicit definition conversion can't handle
748  // invalid declarations, so mark as invalid in that case.
750  Instantiation->setInvalidDecl();
751  return true;
752 }
753 
754 /// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining
755 /// that the template parameter 'PrevDecl' is being shadowed by a new
756 /// declaration at location Loc. Returns true to indicate that this is
757 /// an error, and false otherwise.
759  assert(PrevDecl->isTemplateParameter() && "Not a template parameter");
760 
761  // Microsoft Visual C++ permits template parameters to be shadowed.
762  if (getLangOpts().MicrosoftExt)
763  return;
764 
765  // C++ [temp.local]p4:
766  // A template-parameter shall not be redeclared within its
767  // scope (including nested scopes).
768  Diag(Loc, diag::err_template_param_shadow)
769  << cast<NamedDecl>(PrevDecl)->getDeclName();
770  Diag(PrevDecl->getLocation(), diag::note_template_param_here);
771 }
772 
773 /// AdjustDeclIfTemplate - If the given decl happens to be a template, reset
774 /// the parameter D to reference the templated declaration and return a pointer
775 /// to the template declaration. Otherwise, do nothing to D and return null.
777  if (TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
778  D = Temp->getTemplatedDecl();
779  return Temp;
780  }
781  return nullptr;
782 }
783 
785  SourceLocation EllipsisLoc) const {
786  assert(Kind == Template &&
787  "Only template template arguments can be pack expansions here");
788  assert(getAsTemplate().get().containsUnexpandedParameterPack() &&
789  "Template template argument pack expansion without packs");
790  ParsedTemplateArgument Result(*this);
791  Result.EllipsisLoc = EllipsisLoc;
792  return Result;
793 }
794 
796  const ParsedTemplateArgument &Arg) {
797 
798  switch (Arg.getKind()) {
800  TypeSourceInfo *DI;
801  QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &DI);
802  if (!DI)
803  DI = SemaRef.Context.getTrivialTypeSourceInfo(T, Arg.getLocation());
804  return TemplateArgumentLoc(TemplateArgument(T), DI);
805  }
806 
808  Expr *E = static_cast<Expr *>(Arg.getAsExpr());
810  }
811 
813  TemplateName Template = Arg.getAsTemplate().get();
814  TemplateArgument TArg;
815  if (Arg.getEllipsisLoc().isValid())
816  TArg = TemplateArgument(Template, Optional<unsigned int>());
817  else
818  TArg = Template;
819  return TemplateArgumentLoc(TArg,
821  SemaRef.Context),
822  Arg.getLocation(),
823  Arg.getEllipsisLoc());
824  }
825  }
826 
827  llvm_unreachable("Unhandled parsed template argument");
828 }
829 
830 /// Translates template arguments as provided by the parser
831 /// into template arguments used by semantic analysis.
833  TemplateArgumentListInfo &TemplateArgs) {
834  for (unsigned I = 0, Last = TemplateArgsIn.size(); I != Last; ++I)
835  TemplateArgs.addArgument(translateTemplateArgument(*this,
836  TemplateArgsIn[I]));
837 }
838 
840  SourceLocation Loc,
841  IdentifierInfo *Name) {
842  NamedDecl *PrevDecl = SemaRef.LookupSingleName(
844  if (PrevDecl && PrevDecl->isTemplateParameter())
845  SemaRef.DiagnoseTemplateParameterShadow(Loc, PrevDecl);
846 }
847 
848 /// Convert a parsed type into a parsed template argument. This is mostly
849 /// trivial, except that we may have parsed a C++17 deduced class template
850 /// specialization type, in which case we should form a template template
851 /// argument instead of a type template argument.
853  TypeSourceInfo *TInfo;
854  QualType T = GetTypeFromParser(ParsedType.get(), &TInfo);
855  if (T.isNull())
856  return ParsedTemplateArgument();
857  assert(TInfo && "template argument with no location");
858 
859  // If we might have formed a deduced template specialization type, convert
860  // it to a template template argument.
861  if (getLangOpts().CPlusPlus17) {
862  TypeLoc TL = TInfo->getTypeLoc();
863  SourceLocation EllipsisLoc;
864  if (auto PET = TL.getAs<PackExpansionTypeLoc>()) {
865  EllipsisLoc = PET.getEllipsisLoc();
866  TL = PET.getPatternLoc();
867  }
868 
869  CXXScopeSpec SS;
870  if (auto ET = TL.getAs<ElaboratedTypeLoc>()) {
871  SS.Adopt(ET.getQualifierLoc());
872  TL = ET.getNamedTypeLoc();
873  }
874 
875  if (auto DTST = TL.getAs<DeducedTemplateSpecializationTypeLoc>()) {
876  TemplateName Name = DTST.getTypePtr()->getTemplateName();
877  if (SS.isSet())
878  Name = Context.getQualifiedTemplateName(SS.getScopeRep(),
879  /*HasTemplateKeyword*/ false,
880  Name.getAsTemplateDecl());
881  ParsedTemplateArgument Result(SS, TemplateTy::make(Name),
882  DTST.getTemplateNameLoc());
883  if (EllipsisLoc.isValid())
884  Result = Result.getTemplatePackExpansion(EllipsisLoc);
885  return Result;
886  }
887  }
888 
889  // This is a normal type template argument. Note, if the type template
890  // argument is an injected-class-name for a template, it has a dual nature
891  // and can be used as either a type or a template. We handle that in
892  // convertTypeTemplateArgumentToTemplate.
894  ParsedType.get().getAsOpaquePtr(),
895  TInfo->getTypeLoc().getLocStart());
896 }
897 
898 /// ActOnTypeParameter - Called when a C++ template type parameter
899 /// (e.g., "typename T") has been parsed. Typename specifies whether
900 /// the keyword "typename" was used to declare the type parameter
901 /// (otherwise, "class" was used), and KeyLoc is the location of the
902 /// "class" or "typename" keyword. ParamName is the name of the
903 /// parameter (NULL indicates an unnamed template parameter) and
904 /// ParamNameLoc is the location of the parameter name (if any).
905 /// If the type parameter has a default argument, it will be added
906 /// later via ActOnTypeParameterDefault.
908  SourceLocation EllipsisLoc,
909  SourceLocation KeyLoc,
910  IdentifierInfo *ParamName,
911  SourceLocation ParamNameLoc,
912  unsigned Depth, unsigned Position,
913  SourceLocation EqualLoc,
914  ParsedType DefaultArg) {
915  assert(S->isTemplateParamScope() &&
916  "Template type parameter not in template parameter scope!");
917 
918  SourceLocation Loc = ParamNameLoc;
919  if (!ParamName)
920  Loc = KeyLoc;
921 
922  bool IsParameterPack = EllipsisLoc.isValid();
923  TemplateTypeParmDecl *Param
925  KeyLoc, Loc, Depth, Position, ParamName,
926  Typename, IsParameterPack);
927  Param->setAccess(AS_public);
928 
929  if (ParamName) {
930  maybeDiagnoseTemplateParameterShadow(*this, S, ParamNameLoc, ParamName);
931 
932  // Add the template parameter into the current scope.
933  S->AddDecl(Param);
934  IdResolver.AddDecl(Param);
935  }
936 
937  // C++0x [temp.param]p9:
938  // A default template-argument may be specified for any kind of
939  // template-parameter that is not a template parameter pack.
940  if (DefaultArg && IsParameterPack) {
941  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
942  DefaultArg = nullptr;
943  }
944 
945  // Handle the default argument, if provided.
946  if (DefaultArg) {
947  TypeSourceInfo *DefaultTInfo;
948  GetTypeFromParser(DefaultArg, &DefaultTInfo);
949 
950  assert(DefaultTInfo && "expected source information for type");
951 
952  // Check for unexpanded parameter packs.
953  if (DiagnoseUnexpandedParameterPack(Loc, DefaultTInfo,
954  UPPC_DefaultArgument))
955  return Param;
956 
957  // Check the template argument itself.
958  if (CheckTemplateArgument(Param, DefaultTInfo)) {
959  Param->setInvalidDecl();
960  return Param;
961  }
962 
963  Param->setDefaultArgument(DefaultTInfo);
964  }
965 
966  return Param;
967 }
968 
969 /// Check that the type of a non-type template parameter is
970 /// well-formed.
971 ///
972 /// \returns the (possibly-promoted) parameter type if valid;
973 /// otherwise, produces a diagnostic and returns a NULL type.
975  SourceLocation Loc) {
976  if (TSI->getType()->isUndeducedType()) {
977  // C++1z [temp.dep.expr]p3:
978  // An id-expression is type-dependent if it contains
979  // - an identifier associated by name lookup with a non-type
980  // template-parameter declared with a type that contains a
981  // placeholder type (7.1.7.4),
982  TSI = SubstAutoTypeSourceInfo(TSI, Context.DependentTy);
983  }
984 
985  return CheckNonTypeTemplateParameterType(TSI->getType(), Loc);
986 }
987 
989  SourceLocation Loc) {
990  // We don't allow variably-modified types as the type of non-type template
991  // parameters.
992  if (T->isVariablyModifiedType()) {
993  Diag(Loc, diag::err_variably_modified_nontype_template_param)
994  << T;
995  return QualType();
996  }
997 
998  // C++ [temp.param]p4:
999  //
1000  // A non-type template-parameter shall have one of the following
1001  // (optionally cv-qualified) types:
1002  //
1003  // -- integral or enumeration type,
1004  if (T->isIntegralOrEnumerationType() ||
1005  // -- pointer to object or pointer to function,
1006  T->isPointerType() ||
1007  // -- reference to object or reference to function,
1008  T->isReferenceType() ||
1009  // -- pointer to member,
1010  T->isMemberPointerType() ||
1011  // -- std::nullptr_t.
1012  T->isNullPtrType() ||
1013  // If T is a dependent type, we can't do the check now, so we
1014  // assume that it is well-formed.
1015  T->isDependentType() ||
1016  // Allow use of auto in template parameter declarations.
1017  T->isUndeducedType()) {
1018  // C++ [temp.param]p5: The top-level cv-qualifiers on the template-parameter
1019  // are ignored when determining its type.
1020  return T.getUnqualifiedType();
1021  }
1022 
1023  // C++ [temp.param]p8:
1024  //
1025  // A non-type template-parameter of type "array of T" or
1026  // "function returning T" is adjusted to be of type "pointer to
1027  // T" or "pointer to function returning T", respectively.
1028  else if (T->isArrayType() || T->isFunctionType())
1029  return Context.getDecayedType(T);
1030 
1031  Diag(Loc, diag::err_template_nontype_parm_bad_type)
1032  << T;
1033 
1034  return QualType();
1035 }
1036 
1038  unsigned Depth,
1039  unsigned Position,
1040  SourceLocation EqualLoc,
1041  Expr *Default) {
1042  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
1043 
1044  // Check that we have valid decl-specifiers specified.
1045  auto CheckValidDeclSpecifiers = [this, &D] {
1046  // C++ [temp.param]
1047  // p1
1048  // template-parameter:
1049  // ...
1050  // parameter-declaration
1051  // p2
1052  // ... A storage class shall not be specified in a template-parameter
1053  // declaration.
1054  // [dcl.typedef]p1:
1055  // The typedef specifier [...] shall not be used in the decl-specifier-seq
1056  // of a parameter-declaration
1057  const DeclSpec &DS = D.getDeclSpec();
1058  auto EmitDiag = [this](SourceLocation Loc) {
1059  Diag(Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
1060  << FixItHint::CreateRemoval(Loc);
1061  };
1063  EmitDiag(DS.getStorageClassSpecLoc());
1064 
1066  EmitDiag(DS.getThreadStorageClassSpecLoc());
1067 
1068  // [dcl.inline]p1:
1069  // The inline specifier can be applied only to the declaration or
1070  // definition of a variable or function.
1071 
1072  if (DS.isInlineSpecified())
1073  EmitDiag(DS.getInlineSpecLoc());
1074 
1075  // [dcl.constexpr]p1:
1076  // The constexpr specifier shall be applied only to the definition of a
1077  // variable or variable template or the declaration of a function or
1078  // function template.
1079 
1080  if (DS.isConstexprSpecified())
1081  EmitDiag(DS.getConstexprSpecLoc());
1082 
1083  // [dcl.fct.spec]p1:
1084  // Function-specifiers can be used only in function declarations.
1085 
1086  if (DS.isVirtualSpecified())
1087  EmitDiag(DS.getVirtualSpecLoc());
1088 
1089  if (DS.isExplicitSpecified())
1090  EmitDiag(DS.getExplicitSpecLoc());
1091 
1092  if (DS.isNoreturnSpecified())
1093  EmitDiag(DS.getNoreturnSpecLoc());
1094  };
1095 
1096  CheckValidDeclSpecifiers();
1097 
1098  if (TInfo->getType()->isUndeducedType()) {
1099  Diag(D.getIdentifierLoc(),
1100  diag::warn_cxx14_compat_template_nontype_parm_auto_type)
1101  << QualType(TInfo->getType()->getContainedAutoType(), 0);
1102  }
1103 
1104  assert(S->isTemplateParamScope() &&
1105  "Non-type template parameter not in template parameter scope!");
1106  bool Invalid = false;
1107 
1108  QualType T = CheckNonTypeTemplateParameterType(TInfo, D.getIdentifierLoc());
1109  if (T.isNull()) {
1110  T = Context.IntTy; // Recover with an 'int' type.
1111  Invalid = true;
1112  }
1113 
1114  IdentifierInfo *ParamName = D.getIdentifier();
1115  bool IsParameterPack = D.hasEllipsis();
1118  D.getLocStart(),
1119  D.getIdentifierLoc(),
1120  Depth, Position, ParamName, T,
1121  IsParameterPack, TInfo);
1122  Param->setAccess(AS_public);
1123 
1124  if (Invalid)
1125  Param->setInvalidDecl();
1126 
1127  if (ParamName) {
1129  ParamName);
1130 
1131  // Add the template parameter into the current scope.
1132  S->AddDecl(Param);
1133  IdResolver.AddDecl(Param);
1134  }
1135 
1136  // C++0x [temp.param]p9:
1137  // A default template-argument may be specified for any kind of
1138  // template-parameter that is not a template parameter pack.
1139  if (Default && IsParameterPack) {
1140  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1141  Default = nullptr;
1142  }
1143 
1144  // Check the well-formedness of the default template argument, if provided.
1145  if (Default) {
1146  // Check for unexpanded parameter packs.
1147  if (DiagnoseUnexpandedParameterPack(Default, UPPC_DefaultArgument))
1148  return Param;
1149 
1150  TemplateArgument Converted;
1151  ExprResult DefaultRes =
1152  CheckTemplateArgument(Param, Param->getType(), Default, Converted);
1153  if (DefaultRes.isInvalid()) {
1154  Param->setInvalidDecl();
1155  return Param;
1156  }
1157  Default = DefaultRes.get();
1158 
1159  Param->setDefaultArgument(Default);
1160  }
1161 
1162  return Param;
1163 }
1164 
1165 /// ActOnTemplateTemplateParameter - Called when a C++ template template
1166 /// parameter (e.g. T in template <template <typename> class T> class array)
1167 /// has been parsed. S is the current scope.
1169  SourceLocation TmpLoc,
1170  TemplateParameterList *Params,
1171  SourceLocation EllipsisLoc,
1172  IdentifierInfo *Name,
1173  SourceLocation NameLoc,
1174  unsigned Depth,
1175  unsigned Position,
1176  SourceLocation EqualLoc,
1177  ParsedTemplateArgument Default) {
1178  assert(S->isTemplateParamScope() &&
1179  "Template template parameter not in template parameter scope!");
1180 
1181  // Construct the parameter object.
1182  bool IsParameterPack = EllipsisLoc.isValid();
1183  TemplateTemplateParmDecl *Param =
1185  NameLoc.isInvalid()? TmpLoc : NameLoc,
1186  Depth, Position, IsParameterPack,
1187  Name, Params);
1188  Param->setAccess(AS_public);
1189 
1190  // If the template template parameter has a name, then link the identifier
1191  // into the scope and lookup mechanisms.
1192  if (Name) {
1193  maybeDiagnoseTemplateParameterShadow(*this, S, NameLoc, Name);
1194 
1195  S->AddDecl(Param);
1196  IdResolver.AddDecl(Param);
1197  }
1198 
1199  if (Params->size() == 0) {
1200  Diag(Param->getLocation(), diag::err_template_template_parm_no_parms)
1201  << SourceRange(Params->getLAngleLoc(), Params->getRAngleLoc());
1202  Param->setInvalidDecl();
1203  }
1204 
1205  // C++0x [temp.param]p9:
1206  // A default template-argument may be specified for any kind of
1207  // template-parameter that is not a template parameter pack.
1208  if (IsParameterPack && !Default.isInvalid()) {
1209  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1210  Default = ParsedTemplateArgument();
1211  }
1212 
1213  if (!Default.isInvalid()) {
1214  // Check only that we have a template template argument. We don't want to
1215  // try to check well-formedness now, because our template template parameter
1216  // might have dependent types in its template parameters, which we wouldn't
1217  // be able to match now.
1218  //
1219  // If none of the template template parameter's template arguments mention
1220  // other template parameters, we could actually perform more checking here.
1221  // However, it isn't worth doing.
1222  TemplateArgumentLoc DefaultArg = translateTemplateArgument(*this, Default);
1223  if (DefaultArg.getArgument().getAsTemplate().isNull()) {
1224  Diag(DefaultArg.getLocation(), diag::err_template_arg_not_valid_template)
1225  << DefaultArg.getSourceRange();
1226  return Param;
1227  }
1228 
1229  // Check for unexpanded parameter packs.
1230  if (DiagnoseUnexpandedParameterPack(DefaultArg.getLocation(),
1231  DefaultArg.getArgument().getAsTemplate(),
1232  UPPC_DefaultArgument))
1233  return Param;
1234 
1235  Param->setDefaultArgument(Context, DefaultArg);
1236  }
1237 
1238  return Param;
1239 }
1240 
1241 /// ActOnTemplateParameterList - Builds a TemplateParameterList, optionally
1242 /// constrained by RequiresClause, that contains the template parameters in
1243 /// Params.
1246  SourceLocation ExportLoc,
1247  SourceLocation TemplateLoc,
1248  SourceLocation LAngleLoc,
1249  ArrayRef<NamedDecl *> Params,
1250  SourceLocation RAngleLoc,
1251  Expr *RequiresClause) {
1252  if (ExportLoc.isValid())
1253  Diag(ExportLoc, diag::warn_template_export_unsupported);
1254 
1256  Context, TemplateLoc, LAngleLoc,
1257  llvm::makeArrayRef(Params.data(), Params.size()),
1258  RAngleLoc, RequiresClause);
1259 }
1260 
1261 static void SetNestedNameSpecifier(TagDecl *T, const CXXScopeSpec &SS) {
1262  if (SS.isSet())
1264 }
1265 
1267  Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
1268  CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
1269  const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,
1270  AccessSpecifier AS, SourceLocation ModulePrivateLoc,
1271  SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists,
1272  TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody) {
1273  assert(TemplateParams && TemplateParams->size() > 0 &&
1274  "No template parameters");
1275  assert(TUK != TUK_Reference && "Can only declare or define class templates");
1276  bool Invalid = false;
1277 
1278  // Check that we can declare a template here.
1279  if (CheckTemplateDeclScope(S, TemplateParams))
1280  return true;
1281 
1283  assert(Kind != TTK_Enum && "can't build template of enumerated type");
1284 
1285  // There is no such thing as an unnamed class template.
1286  if (!Name) {
1287  Diag(KWLoc, diag::err_template_unnamed_class);
1288  return true;
1289  }
1290 
1291  // Find any previous declaration with this name. For a friend with no
1292  // scope explicitly specified, we only look for tag declarations (per
1293  // C++11 [basic.lookup.elab]p2).
1294  DeclContext *SemanticContext;
1295  LookupResult Previous(*this, Name, NameLoc,
1296  (SS.isEmpty() && TUK == TUK_Friend)
1297  ? LookupTagName : LookupOrdinaryName,
1298  forRedeclarationInCurContext());
1299  if (SS.isNotEmpty() && !SS.isInvalid()) {
1300  SemanticContext = computeDeclContext(SS, true);
1301  if (!SemanticContext) {
1302  // FIXME: Horrible, horrible hack! We can't currently represent this
1303  // in the AST, and historically we have just ignored such friend
1304  // class templates, so don't complain here.
1305  Diag(NameLoc, TUK == TUK_Friend
1306  ? diag::warn_template_qualified_friend_ignored
1307  : diag::err_template_qualified_declarator_no_match)
1308  << SS.getScopeRep() << SS.getRange();
1309  return TUK != TUK_Friend;
1310  }
1311 
1312  if (RequireCompleteDeclContext(SS, SemanticContext))
1313  return true;
1314 
1315  // If we're adding a template to a dependent context, we may need to
1316  // rebuilding some of the types used within the template parameter list,
1317  // now that we know what the current instantiation is.
1318  if (SemanticContext->isDependentContext()) {
1319  ContextRAII SavedContext(*this, SemanticContext);
1320  if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
1321  Invalid = true;
1322  } else if (TUK != TUK_Friend && TUK != TUK_Reference)
1323  diagnoseQualifiedDeclaration(SS, SemanticContext, Name, NameLoc, false);
1324 
1325  LookupQualifiedName(Previous, SemanticContext);
1326  } else {
1327  SemanticContext = CurContext;
1328 
1329  // C++14 [class.mem]p14:
1330  // If T is the name of a class, then each of the following shall have a
1331  // name different from T:
1332  // -- every member template of class T
1333  if (TUK != TUK_Friend &&
1334  DiagnoseClassNameShadow(SemanticContext,
1335  DeclarationNameInfo(Name, NameLoc)))
1336  return true;
1337 
1338  LookupName(Previous, S);
1339  }
1340 
1341  if (Previous.isAmbiguous())
1342  return true;
1343 
1344  NamedDecl *PrevDecl = nullptr;
1345  if (Previous.begin() != Previous.end())
1346  PrevDecl = (*Previous.begin())->getUnderlyingDecl();
1347 
1348  if (PrevDecl && PrevDecl->isTemplateParameter()) {
1349  // Maybe we will complain about the shadowed template parameter.
1350  DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
1351  // Just pretend that we didn't see the previous declaration.
1352  PrevDecl = nullptr;
1353  }
1354 
1355  // If there is a previous declaration with the same name, check
1356  // whether this is a valid redeclaration.
1357  ClassTemplateDecl *PrevClassTemplate =
1358  dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
1359 
1360  // We may have found the injected-class-name of a class template,
1361  // class template partial specialization, or class template specialization.
1362  // In these cases, grab the template that is being defined or specialized.
1363  if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) &&
1364  cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
1365  PrevDecl = cast<CXXRecordDecl>(PrevDecl->getDeclContext());
1366  PrevClassTemplate
1367  = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
1368  if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
1369  PrevClassTemplate
1370  = cast<ClassTemplateSpecializationDecl>(PrevDecl)
1371  ->getSpecializedTemplate();
1372  }
1373  }
1374 
1375  if (TUK == TUK_Friend) {
1376  // C++ [namespace.memdef]p3:
1377  // [...] When looking for a prior declaration of a class or a function
1378  // declared as a friend, and when the name of the friend class or
1379  // function is neither a qualified name nor a template-id, scopes outside
1380  // the innermost enclosing namespace scope are not considered.
1381  if (!SS.isSet()) {
1382  DeclContext *OutermostContext = CurContext;
1383  while (!OutermostContext->isFileContext())
1384  OutermostContext = OutermostContext->getLookupParent();
1385 
1386  if (PrevDecl &&
1387  (OutermostContext->Equals(PrevDecl->getDeclContext()) ||
1388  OutermostContext->Encloses(PrevDecl->getDeclContext()))) {
1389  SemanticContext = PrevDecl->getDeclContext();
1390  } else {
1391  // Declarations in outer scopes don't matter. However, the outermost
1392  // context we computed is the semantic context for our new
1393  // declaration.
1394  PrevDecl = PrevClassTemplate = nullptr;
1395  SemanticContext = OutermostContext;
1396 
1397  // Check that the chosen semantic context doesn't already contain a
1398  // declaration of this name as a non-tag type.
1399  Previous.clear(LookupOrdinaryName);
1400  DeclContext *LookupContext = SemanticContext;
1401  while (LookupContext->isTransparentContext())
1402  LookupContext = LookupContext->getLookupParent();
1403  LookupQualifiedName(Previous, LookupContext);
1404 
1405  if (Previous.isAmbiguous())
1406  return true;
1407 
1408  if (Previous.begin() != Previous.end())
1409  PrevDecl = (*Previous.begin())->getUnderlyingDecl();
1410  }
1411  }
1412  } else if (PrevDecl &&
1413  !isDeclInScope(Previous.getRepresentativeDecl(), SemanticContext,
1414  S, SS.isValid()))
1415  PrevDecl = PrevClassTemplate = nullptr;
1416 
1417  if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
1418  PrevDecl ? Previous.getRepresentativeDecl() : nullptr)) {
1419  if (SS.isEmpty() &&
1420  !(PrevClassTemplate &&
1421  PrevClassTemplate->getDeclContext()->getRedeclContext()->Equals(
1422  SemanticContext->getRedeclContext()))) {
1423  Diag(KWLoc, diag::err_using_decl_conflict_reverse);
1424  Diag(Shadow->getTargetDecl()->getLocation(),
1425  diag::note_using_decl_target);
1426  Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
1427  // Recover by ignoring the old declaration.
1428  PrevDecl = PrevClassTemplate = nullptr;
1429  }
1430  }
1431 
1432  // TODO Memory management; associated constraints are not always stored.
1433  Expr *const CurAC = formAssociatedConstraints(TemplateParams, nullptr);
1434 
1435  if (PrevClassTemplate) {
1436  // Ensure that the template parameter lists are compatible. Skip this check
1437  // for a friend in a dependent context: the template parameter list itself
1438  // could be dependent.
1439  if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1440  !TemplateParameterListsAreEqual(TemplateParams,
1441  PrevClassTemplate->getTemplateParameters(),
1442  /*Complain=*/true,
1443  TPL_TemplateMatch))
1444  return true;
1445 
1446  // Check for matching associated constraints on redeclarations.
1447  const Expr *const PrevAC = PrevClassTemplate->getAssociatedConstraints();
1448  const bool RedeclACMismatch = [&] {
1449  if (!(CurAC || PrevAC))
1450  return false; // Nothing to check; no mismatch.
1451  if (CurAC && PrevAC) {
1452  llvm::FoldingSetNodeID CurACInfo, PrevACInfo;
1453  CurAC->Profile(CurACInfo, Context, /*Canonical=*/true);
1454  PrevAC->Profile(PrevACInfo, Context, /*Canonical=*/true);
1455  if (CurACInfo == PrevACInfo)
1456  return false; // All good; no mismatch.
1457  }
1458  return true;
1459  }();
1460 
1461  if (RedeclACMismatch) {
1462  Diag(CurAC ? CurAC->getLocStart() : NameLoc,
1463  diag::err_template_different_associated_constraints);
1464  Diag(PrevAC ? PrevAC->getLocStart() : PrevClassTemplate->getLocation(),
1465  diag::note_template_prev_declaration) << /*declaration*/0;
1466  return true;
1467  }
1468 
1469  // C++ [temp.class]p4:
1470  // In a redeclaration, partial specialization, explicit
1471  // specialization or explicit instantiation of a class template,
1472  // the class-key shall agree in kind with the original class
1473  // template declaration (7.1.5.3).
1474  RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl();
1475  if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind,
1476  TUK == TUK_Definition, KWLoc, Name)) {
1477  Diag(KWLoc, diag::err_use_with_wrong_tag)
1478  << Name
1479  << FixItHint::CreateReplacement(KWLoc, PrevRecordDecl->getKindName());
1480  Diag(PrevRecordDecl->getLocation(), diag::note_previous_use);
1481  Kind = PrevRecordDecl->getTagKind();
1482  }
1483 
1484  // Check for redefinition of this class template.
1485  if (TUK == TUK_Definition) {
1486  if (TagDecl *Def = PrevRecordDecl->getDefinition()) {
1487  // If we have a prior definition that is not visible, treat this as
1488  // simply making that previous definition visible.
1489  NamedDecl *Hidden = nullptr;
1490  if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
1491  SkipBody->ShouldSkip = true;
1492  auto *Tmpl = cast<CXXRecordDecl>(Hidden)->getDescribedClassTemplate();
1493  assert(Tmpl && "original definition of a class template is not a "
1494  "class template?");
1495  makeMergedDefinitionVisible(Hidden);
1496  makeMergedDefinitionVisible(Tmpl);
1497  return Def;
1498  }
1499 
1500  Diag(NameLoc, diag::err_redefinition) << Name;
1501  Diag(Def->getLocation(), diag::note_previous_definition);
1502  // FIXME: Would it make sense to try to "forget" the previous
1503  // definition, as part of error recovery?
1504  return true;
1505  }
1506  }
1507  } else if (PrevDecl) {
1508  // C++ [temp]p5:
1509  // A class template shall not have the same name as any other
1510  // template, class, function, object, enumeration, enumerator,
1511  // namespace, or type in the same scope (3.3), except as specified
1512  // in (14.5.4).
1513  Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
1514  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1515  return true;
1516  }
1517 
1518  // Check the template parameter list of this declaration, possibly
1519  // merging in the template parameter list from the previous class
1520  // template declaration. Skip this check for a friend in a dependent
1521  // context, because the template parameter list might be dependent.
1522  if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1523  CheckTemplateParameterList(
1524  TemplateParams,
1525  PrevClassTemplate ? PrevClassTemplate->getTemplateParameters()
1526  : nullptr,
1527  (SS.isSet() && SemanticContext && SemanticContext->isRecord() &&
1528  SemanticContext->isDependentContext())
1529  ? TPC_ClassTemplateMember
1530  : TUK == TUK_Friend ? TPC_FriendClassTemplate
1531  : TPC_ClassTemplate))
1532  Invalid = true;
1533 
1534  if (SS.isSet()) {
1535  // If the name of the template was qualified, we must be defining the
1536  // template out-of-line.
1537  if (!SS.isInvalid() && !Invalid && !PrevClassTemplate) {
1538  Diag(NameLoc, TUK == TUK_Friend ? diag::err_friend_decl_does_not_match
1539  : diag::err_member_decl_does_not_match)
1540  << Name << SemanticContext << /*IsDefinition*/true << SS.getRange();
1541  Invalid = true;
1542  }
1543  }
1544 
1545  // If this is a templated friend in a dependent context we should not put it
1546  // on the redecl chain. In some cases, the templated friend can be the most
1547  // recent declaration tricking the template instantiator to make substitutions
1548  // there.
1549  // FIXME: Figure out how to combine with shouldLinkDependentDeclWithPrevious
1550  bool ShouldAddRedecl
1551  = !(TUK == TUK_Friend && CurContext->isDependentContext());
1552 
1553  CXXRecordDecl *NewClass =
1554  CXXRecordDecl::Create(Context, Kind, SemanticContext, KWLoc, NameLoc, Name,
1555  PrevClassTemplate && ShouldAddRedecl ?
1556  PrevClassTemplate->getTemplatedDecl() : nullptr,
1557  /*DelayTypeCreation=*/true);
1558  SetNestedNameSpecifier(NewClass, SS);
1559  if (NumOuterTemplateParamLists > 0)
1561  Context, llvm::makeArrayRef(OuterTemplateParamLists,
1562  NumOuterTemplateParamLists));
1563 
1564  // Add alignment attributes if necessary; these attributes are checked when
1565  // the ASTContext lays out the structure.
1566  if (TUK == TUK_Definition) {
1567  AddAlignmentAttributesForRecord(NewClass);
1568  AddMsStructLayoutForRecord(NewClass);
1569  }
1570 
1571  // Attach the associated constraints when the declaration will not be part of
1572  // a decl chain.
1573  Expr *const ACtoAttach =
1574  PrevClassTemplate && ShouldAddRedecl ? nullptr : CurAC;
1575 
1576  ClassTemplateDecl *NewTemplate
1577  = ClassTemplateDecl::Create(Context, SemanticContext, NameLoc,
1578  DeclarationName(Name), TemplateParams,
1579  NewClass, ACtoAttach);
1580 
1581  if (ShouldAddRedecl)
1582  NewTemplate->setPreviousDecl(PrevClassTemplate);
1583 
1584  NewClass->setDescribedClassTemplate(NewTemplate);
1585 
1586  if (ModulePrivateLoc.isValid())
1587  NewTemplate->setModulePrivate();
1588 
1589  // Build the type for the class template declaration now.
1590  QualType T = NewTemplate->getInjectedClassNameSpecialization();
1591  T = Context.getInjectedClassNameType(NewClass, T);
1592  assert(T->isDependentType() && "Class template type is not dependent?");
1593  (void)T;
1594 
1595  // If we are providing an explicit specialization of a member that is a
1596  // class template, make a note of that.
1597  if (PrevClassTemplate &&
1598  PrevClassTemplate->getInstantiatedFromMemberTemplate())
1599  PrevClassTemplate->setMemberSpecialization();
1600 
1601  // Set the access specifier.
1602  if (!Invalid && TUK != TUK_Friend && NewTemplate->getDeclContext()->isRecord())
1603  SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS);
1604 
1605  // Set the lexical context of these templates
1606  NewClass->setLexicalDeclContext(CurContext);
1607  NewTemplate->setLexicalDeclContext(CurContext);
1608 
1609  if (TUK == TUK_Definition)
1610  NewClass->startDefinition();
1611 
1612  ProcessDeclAttributeList(S, NewClass, Attr);
1613 
1614  if (PrevClassTemplate)
1615  mergeDeclAttributes(NewClass, PrevClassTemplate->getTemplatedDecl());
1616 
1617  AddPushedVisibilityAttribute(NewClass);
1618 
1619  if (TUK != TUK_Friend) {
1620  // Per C++ [basic.scope.temp]p2, skip the template parameter scopes.
1621  Scope *Outer = S;
1622  while ((Outer->getFlags() & Scope::TemplateParamScope) != 0)
1623  Outer = Outer->getParent();
1624  PushOnScopeChains(NewTemplate, Outer);
1625  } else {
1626  if (PrevClassTemplate && PrevClassTemplate->getAccess() != AS_none) {
1627  NewTemplate->setAccess(PrevClassTemplate->getAccess());
1628  NewClass->setAccess(PrevClassTemplate->getAccess());
1629  }
1630 
1631  NewTemplate->setObjectOfFriendDecl();
1632 
1633  // Friend templates are visible in fairly strange ways.
1634  if (!CurContext->isDependentContext()) {
1635  DeclContext *DC = SemanticContext->getRedeclContext();
1636  DC->makeDeclVisibleInContext(NewTemplate);
1637  if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
1638  PushOnScopeChains(NewTemplate, EnclosingScope,
1639  /* AddToContext = */ false);
1640  }
1641 
1642  FriendDecl *Friend = FriendDecl::Create(
1643  Context, CurContext, NewClass->getLocation(), NewTemplate, FriendLoc);
1644  Friend->setAccess(AS_public);
1645  CurContext->addDecl(Friend);
1646  }
1647 
1648  if (PrevClassTemplate)
1649  CheckRedeclarationModuleOwnership(NewTemplate, PrevClassTemplate);
1650 
1651  if (Invalid) {
1652  NewTemplate->setInvalidDecl();
1653  NewClass->setInvalidDecl();
1654  }
1655 
1656  ActOnDocumentableDecl(NewTemplate);
1657 
1658  return NewTemplate;
1659 }
1660 
1661 namespace {
1662 /// Tree transform to "extract" a transformed type from a class template's
1663 /// constructor to a deduction guide.
1664 class ExtractTypeForDeductionGuide
1665  : public TreeTransform<ExtractTypeForDeductionGuide> {
1666 public:
1668  ExtractTypeForDeductionGuide(Sema &SemaRef) : Base(SemaRef) {}
1669 
1670  TypeSourceInfo *transform(TypeSourceInfo *TSI) { return TransformType(TSI); }
1671 
1672  QualType TransformTypedefType(TypeLocBuilder &TLB, TypedefTypeLoc TL) {
1673  return TransformType(
1674  TLB,
1676  }
1677 };
1678 
1679 /// Transform to convert portions of a constructor declaration into the
1680 /// corresponding deduction guide, per C++1z [over.match.class.deduct]p1.
1681 struct ConvertConstructorToDeductionGuideTransform {
1682  ConvertConstructorToDeductionGuideTransform(Sema &S,
1683  ClassTemplateDecl *Template)
1684  : SemaRef(S), Template(Template) {}
1685 
1686  Sema &SemaRef;
1687  ClassTemplateDecl *Template;
1688 
1689  DeclContext *DC = Template->getDeclContext();
1690  CXXRecordDecl *Primary = Template->getTemplatedDecl();
1691  DeclarationName DeductionGuideName =
1693 
1694  QualType DeducedType = SemaRef.Context.getTypeDeclType(Primary);
1695 
1696  // Index adjustment to apply to convert depth-1 template parameters into
1697  // depth-0 template parameters.
1698  unsigned Depth1IndexAdjustment = Template->getTemplateParameters()->size();
1699 
1700  /// Transform a constructor declaration into a deduction guide.
1701  NamedDecl *transformConstructor(FunctionTemplateDecl *FTD,
1702  CXXConstructorDecl *CD) {
1704 
1705  LocalInstantiationScope Scope(SemaRef);
1706 
1707  // C++ [over.match.class.deduct]p1:
1708  // -- For each constructor of the class template designated by the
1709  // template-name, a function template with the following properties:
1710 
1711  // -- The template parameters are the template parameters of the class
1712  // template followed by the template parameters (including default
1713  // template arguments) of the constructor, if any.
1714  TemplateParameterList *TemplateParams = Template->getTemplateParameters();
1715  if (FTD) {
1716  TemplateParameterList *InnerParams = FTD->getTemplateParameters();
1717  SmallVector<NamedDecl *, 16> AllParams;
1718  AllParams.reserve(TemplateParams->size() + InnerParams->size());
1719  AllParams.insert(AllParams.begin(),
1720  TemplateParams->begin(), TemplateParams->end());
1721  SubstArgs.reserve(InnerParams->size());
1722 
1723  // Later template parameters could refer to earlier ones, so build up
1724  // a list of substituted template arguments as we go.
1725  for (NamedDecl *Param : *InnerParams) {
1727  Args.addOuterTemplateArguments(SubstArgs);
1728  Args.addOuterRetainedLevel();
1729  NamedDecl *NewParam = transformTemplateParameter(Param, Args);
1730  if (!NewParam)
1731  return nullptr;
1732  AllParams.push_back(NewParam);
1733  SubstArgs.push_back(SemaRef.Context.getCanonicalTemplateArgument(
1734  SemaRef.Context.getInjectedTemplateArg(NewParam)));
1735  }
1736  TemplateParams = TemplateParameterList::Create(
1737  SemaRef.Context, InnerParams->getTemplateLoc(),
1738  InnerParams->getLAngleLoc(), AllParams, InnerParams->getRAngleLoc(),
1739  /*FIXME: RequiresClause*/ nullptr);
1740  }
1741 
1742  // If we built a new template-parameter-list, track that we need to
1743  // substitute references to the old parameters into references to the
1744  // new ones.
1746  if (FTD) {
1747  Args.addOuterTemplateArguments(SubstArgs);
1748  Args.addOuterRetainedLevel();
1749  }
1750 
1753  assert(FPTL && "no prototype for constructor declaration");
1754 
1755  // Transform the type of the function, adjusting the return type and
1756  // replacing references to the old parameters with references to the
1757  // new ones.
1758  TypeLocBuilder TLB;
1760  QualType NewType = transformFunctionProtoType(TLB, FPTL, Params, Args);
1761  if (NewType.isNull())
1762  return nullptr;
1763  TypeSourceInfo *NewTInfo = TLB.getTypeSourceInfo(SemaRef.Context, NewType);
1764 
1765  return buildDeductionGuide(TemplateParams, CD->isExplicit(), NewTInfo,
1766  CD->getLocStart(), CD->getLocation(),
1767  CD->getLocEnd());
1768  }
1769 
1770  /// Build a deduction guide with the specified parameter types.
1771  NamedDecl *buildSimpleDeductionGuide(MutableArrayRef<QualType> ParamTypes) {
1772  SourceLocation Loc = Template->getLocation();
1773 
1774  // Build the requested type.
1776  EPI.HasTrailingReturn = true;
1777  QualType Result = SemaRef.BuildFunctionType(DeducedType, ParamTypes, Loc,
1778  DeductionGuideName, EPI);
1779  TypeSourceInfo *TSI = SemaRef.Context.getTrivialTypeSourceInfo(Result, Loc);
1780 
1781  FunctionProtoTypeLoc FPTL =
1783 
1784  // Build the parameters, needed during deduction / substitution.
1786  for (auto T : ParamTypes) {
1787  ParmVarDecl *NewParam = ParmVarDecl::Create(
1788  SemaRef.Context, DC, Loc, Loc, nullptr, T,
1789  SemaRef.Context.getTrivialTypeSourceInfo(T, Loc), SC_None, nullptr);
1790  NewParam->setScopeInfo(0, Params.size());
1791  FPTL.setParam(Params.size(), NewParam);
1792  Params.push_back(NewParam);
1793  }
1794 
1795  return buildDeductionGuide(Template->getTemplateParameters(), false, TSI,
1796  Loc, Loc, Loc);
1797  }
1798 
1799 private:
1800  /// Transform a constructor template parameter into a deduction guide template
1801  /// parameter, rebuilding any internal references to earlier parameters and
1802  /// renumbering as we go.
1803  NamedDecl *transformTemplateParameter(NamedDecl *TemplateParam,
1805  if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(TemplateParam)) {
1806  // TemplateTypeParmDecl's index cannot be changed after creation, so
1807  // substitute it directly.
1808  auto *NewTTP = TemplateTypeParmDecl::Create(
1809  SemaRef.Context, DC, TTP->getLocStart(), TTP->getLocation(),
1810  /*Depth*/0, Depth1IndexAdjustment + TTP->getIndex(),
1811  TTP->getIdentifier(), TTP->wasDeclaredWithTypename(),
1812  TTP->isParameterPack());
1813  if (TTP->hasDefaultArgument()) {
1814  TypeSourceInfo *InstantiatedDefaultArg =
1815  SemaRef.SubstType(TTP->getDefaultArgumentInfo(), Args,
1816  TTP->getDefaultArgumentLoc(), TTP->getDeclName());
1817  if (InstantiatedDefaultArg)
1818  NewTTP->setDefaultArgument(InstantiatedDefaultArg);
1819  }
1820  SemaRef.CurrentInstantiationScope->InstantiatedLocal(TemplateParam,
1821  NewTTP);
1822  return NewTTP;
1823  }
1824 
1825  if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TemplateParam))
1826  return transformTemplateParameterImpl(TTP, Args);
1827 
1828  return transformTemplateParameterImpl(
1829  cast<NonTypeTemplateParmDecl>(TemplateParam), Args);
1830  }
1831  template<typename TemplateParmDecl>
1832  TemplateParmDecl *
1833  transformTemplateParameterImpl(TemplateParmDecl *OldParam,
1835  // Ask the template instantiator to do the heavy lifting for us, then adjust
1836  // the index of the parameter once it's done.
1837  auto *NewParam =
1838  cast_or_null<TemplateParmDecl>(SemaRef.SubstDecl(OldParam, DC, Args));
1839  assert(NewParam->getDepth() == 0 && "unexpected template param depth");
1840  NewParam->setPosition(NewParam->getPosition() + Depth1IndexAdjustment);
1841  return NewParam;
1842  }
1843 
1844  QualType transformFunctionProtoType(TypeLocBuilder &TLB,
1848  SmallVector<QualType, 4> ParamTypes;
1849  const FunctionProtoType *T = TL.getTypePtr();
1850 
1851  // -- The types of the function parameters are those of the constructor.
1852  for (auto *OldParam : TL.getParams()) {
1853  ParmVarDecl *NewParam = transformFunctionTypeParam(OldParam, Args);
1854  if (!NewParam)
1855  return QualType();
1856  ParamTypes.push_back(NewParam->getType());
1857  Params.push_back(NewParam);
1858  }
1859 
1860  // -- The return type is the class template specialization designated by
1861  // the template-name and template arguments corresponding to the
1862  // template parameters obtained from the class template.
1863  //
1864  // We use the injected-class-name type of the primary template instead.
1865  // This has the convenient property that it is different from any type that
1866  // the user can write in a deduction-guide (because they cannot enter the
1867  // context of the template), so implicit deduction guides can never collide
1868  // with explicit ones.
1869  QualType ReturnType = DeducedType;
1870  TLB.pushTypeSpec(ReturnType).setNameLoc(Primary->getLocation());
1871 
1872  // Resolving a wording defect, we also inherit the variadicness of the
1873  // constructor.
1875  EPI.Variadic = T->isVariadic();
1876  EPI.HasTrailingReturn = true;
1877 
1878  QualType Result = SemaRef.BuildFunctionType(
1879  ReturnType, ParamTypes, TL.getLocStart(), DeductionGuideName, EPI);
1880  if (Result.isNull())
1881  return QualType();
1882 
1883  FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
1885  NewTL.setLParenLoc(TL.getLParenLoc());
1886  NewTL.setRParenLoc(TL.getRParenLoc());
1888  NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
1889  for (unsigned I = 0, E = NewTL.getNumParams(); I != E; ++I)
1890  NewTL.setParam(I, Params[I]);
1891 
1892  return Result;
1893  }
1894 
1895  ParmVarDecl *
1896  transformFunctionTypeParam(ParmVarDecl *OldParam,
1898  TypeSourceInfo *OldDI = OldParam->getTypeSourceInfo();
1899  TypeSourceInfo *NewDI;
1900  if (auto PackTL = OldDI->getTypeLoc().getAs<PackExpansionTypeLoc>()) {
1901  // Expand out the one and only element in each inner pack.
1902  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, 0);
1903  NewDI =
1904  SemaRef.SubstType(PackTL.getPatternLoc(), Args,
1905  OldParam->getLocation(), OldParam->getDeclName());
1906  if (!NewDI) return nullptr;
1907  NewDI =
1908  SemaRef.CheckPackExpansion(NewDI, PackTL.getEllipsisLoc(),
1909  PackTL.getTypePtr()->getNumExpansions());
1910  } else
1911  NewDI = SemaRef.SubstType(OldDI, Args, OldParam->getLocation(),
1912  OldParam->getDeclName());
1913  if (!NewDI)
1914  return nullptr;
1915 
1916  // Extract the type. This (for instance) replaces references to typedef
1917  // members of the current instantiations with the definitions of those
1918  // typedefs, avoiding triggering instantiation of the deduced type during
1919  // deduction.
1920  NewDI = ExtractTypeForDeductionGuide(SemaRef).transform(NewDI);
1921 
1922  // Resolving a wording defect, we also inherit default arguments from the
1923  // constructor.
1924  ExprResult NewDefArg;
1925  if (OldParam->hasDefaultArg()) {
1926  NewDefArg = SemaRef.SubstExpr(OldParam->getDefaultArg(), Args);
1927  if (NewDefArg.isInvalid())
1928  return nullptr;
1929  }
1930 
1931  ParmVarDecl *NewParam = ParmVarDecl::Create(SemaRef.Context, DC,
1932  OldParam->getInnerLocStart(),
1933  OldParam->getLocation(),
1934  OldParam->getIdentifier(),
1935  NewDI->getType(),
1936  NewDI,
1937  OldParam->getStorageClass(),
1938  NewDefArg.get());
1939  NewParam->setScopeInfo(OldParam->getFunctionScopeDepth(),
1940  OldParam->getFunctionScopeIndex());
1941  SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldParam, NewParam);
1942  return NewParam;
1943  }
1944 
1945  NamedDecl *buildDeductionGuide(TemplateParameterList *TemplateParams,
1946  bool Explicit, TypeSourceInfo *TInfo,
1947  SourceLocation LocStart, SourceLocation Loc,
1948  SourceLocation LocEnd) {
1949  DeclarationNameInfo Name(DeductionGuideName, Loc);
1950  ArrayRef<ParmVarDecl *> Params =
1951  TInfo->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams();
1952 
1953  // Build the implicit deduction guide template.
1954  auto *Guide =
1955  CXXDeductionGuideDecl::Create(SemaRef.Context, DC, LocStart, Explicit,
1956  Name, TInfo->getType(), TInfo, LocEnd);
1957  Guide->setImplicit();
1958  Guide->setParams(Params);
1959 
1960  for (auto *Param : Params)
1961  Param->setDeclContext(Guide);
1962 
1963  auto *GuideTemplate = FunctionTemplateDecl::Create(
1964  SemaRef.Context, DC, Loc, DeductionGuideName, TemplateParams, Guide);
1965  GuideTemplate->setImplicit();
1966  Guide->setDescribedFunctionTemplate(GuideTemplate);
1967 
1968  if (isa<CXXRecordDecl>(DC)) {
1969  Guide->setAccess(AS_public);
1970  GuideTemplate->setAccess(AS_public);
1971  }
1972 
1973  DC->addDecl(GuideTemplate);
1974  return GuideTemplate;
1975  }
1976 };
1977 }
1978 
1980  SourceLocation Loc) {
1981  DeclContext *DC = Template->getDeclContext();
1982  if (DC->isDependentContext())
1983  return;
1984 
1985  ConvertConstructorToDeductionGuideTransform Transform(
1986  *this, cast<ClassTemplateDecl>(Template));
1987  if (!isCompleteType(Loc, Transform.DeducedType))
1988  return;
1989 
1990  // Check whether we've already declared deduction guides for this template.
1991  // FIXME: Consider storing a flag on the template to indicate this.
1992  auto Existing = DC->lookup(Transform.DeductionGuideName);
1993  for (auto *D : Existing)
1994  if (D->isImplicit())
1995  return;
1996 
1997  // In case we were expanding a pack when we attempted to declare deduction
1998  // guides, turn off pack expansion for everything we're about to do.
1999  ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
2000  // Create a template instantiation record to track the "instantiation" of
2001  // constructors into deduction guides.
2002  // FIXME: Add a kind for this to give more meaningful diagnostics. But can
2003  // this substitution process actually fail?
2004  InstantiatingTemplate BuildingDeductionGuides(*this, Loc, Template);
2005  if (BuildingDeductionGuides.isInvalid())
2006  return;
2007 
2008  // Convert declared constructors into deduction guide templates.
2009  // FIXME: Skip constructors for which deduction must necessarily fail (those
2010  // for which some class template parameter without a default argument never
2011  // appears in a deduced context).
2012  bool AddedAny = false;
2013  for (NamedDecl *D : LookupConstructors(Transform.Primary)) {
2014  D = D->getUnderlyingDecl();
2015  if (D->isInvalidDecl() || D->isImplicit())
2016  continue;
2017  D = cast<NamedDecl>(D->getCanonicalDecl());
2018 
2019  auto *FTD = dyn_cast<FunctionTemplateDecl>(D);
2020  auto *CD =
2021  dyn_cast_or_null<CXXConstructorDecl>(FTD ? FTD->getTemplatedDecl() : D);
2022  // Class-scope explicit specializations (MS extension) do not result in
2023  // deduction guides.
2024  if (!CD || (!FTD && CD->isFunctionTemplateSpecialization()))
2025  continue;
2026 
2027  Transform.transformConstructor(FTD, CD);
2028  AddedAny = true;
2029  }
2030 
2031  // C++17 [over.match.class.deduct]
2032  // -- If C is not defined or does not declare any constructors, an
2033  // additional function template derived as above from a hypothetical
2034  // constructor C().
2035  if (!AddedAny)
2036  Transform.buildSimpleDeductionGuide(None);
2037 
2038  // -- An additional function template derived as above from a hypothetical
2039  // constructor C(C), called the copy deduction candidate.
2040  cast<CXXDeductionGuideDecl>(
2041  cast<FunctionTemplateDecl>(
2042  Transform.buildSimpleDeductionGuide(Transform.DeducedType))
2043  ->getTemplatedDecl())
2044  ->setIsCopyDeductionCandidate();
2045 }
2046 
2047 /// Diagnose the presence of a default template argument on a
2048 /// template parameter, which is ill-formed in certain contexts.
2049 ///
2050 /// \returns true if the default template argument should be dropped.
2053  SourceLocation ParamLoc,
2054  SourceRange DefArgRange) {
2055  switch (TPC) {
2057  case Sema::TPC_VarTemplate:
2059  return false;
2060 
2063  // C++ [temp.param]p9:
2064  // A default template-argument shall not be specified in a
2065  // function template declaration or a function template
2066  // definition [...]
2067  // If a friend function template declaration specifies a default
2068  // template-argument, that declaration shall be a definition and shall be
2069  // the only declaration of the function template in the translation unit.
2070  // (C++98/03 doesn't have this wording; see DR226).
2071  S.Diag(ParamLoc, S.getLangOpts().CPlusPlus11 ?
2072  diag::warn_cxx98_compat_template_parameter_default_in_function_template
2073  : diag::ext_template_parameter_default_in_function_template)
2074  << DefArgRange;
2075  return false;
2076 
2078  // C++0x [temp.param]p9:
2079  // A default template-argument shall not be specified in the
2080  // template-parameter-lists of the definition of a member of a
2081  // class template that appears outside of the member's class.
2082  S.Diag(ParamLoc, diag::err_template_parameter_default_template_member)
2083  << DefArgRange;
2084  return true;
2085 
2088  // C++ [temp.param]p9:
2089  // A default template-argument shall not be specified in a
2090  // friend template declaration.
2091  S.Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
2092  << DefArgRange;
2093  return true;
2094 
2095  // FIXME: C++0x [temp.param]p9 allows default template-arguments
2096  // for friend function templates if there is only a single
2097  // declaration (and it is a definition). Strange!
2098  }
2099 
2100  llvm_unreachable("Invalid TemplateParamListContext!");
2101 }
2102 
2103 /// Check for unexpanded parameter packs within the template parameters
2104 /// of a template template parameter, recursively.
2106  TemplateTemplateParmDecl *TTP) {
2107  // A template template parameter which is a parameter pack is also a pack
2108  // expansion.
2109  if (TTP->isParameterPack())
2110  return false;
2111 
2113  for (unsigned I = 0, N = Params->size(); I != N; ++I) {
2114  NamedDecl *P = Params->getParam(I);
2115  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
2116  if (!NTTP->isParameterPack() &&
2117  S.DiagnoseUnexpandedParameterPack(NTTP->getLocation(),
2118  NTTP->getTypeSourceInfo(),
2120  return true;
2121 
2122  continue;
2123  }
2124 
2125  if (TemplateTemplateParmDecl *InnerTTP
2126  = dyn_cast<TemplateTemplateParmDecl>(P))
2127  if (DiagnoseUnexpandedParameterPacks(S, InnerTTP))
2128  return true;
2129  }
2130 
2131  return false;
2132 }
2133 
2134 /// Checks the validity of a template parameter list, possibly
2135 /// considering the template parameter list from a previous
2136 /// declaration.
2137 ///
2138 /// If an "old" template parameter list is provided, it must be
2139 /// equivalent (per TemplateParameterListsAreEqual) to the "new"
2140 /// template parameter list.
2141 ///
2142 /// \param NewParams Template parameter list for a new template
2143 /// declaration. This template parameter list will be updated with any
2144 /// default arguments that are carried through from the previous
2145 /// template parameter list.
2146 ///
2147 /// \param OldParams If provided, template parameter list from a
2148 /// previous declaration of the same template. Default template
2149 /// arguments will be merged from the old template parameter list to
2150 /// the new template parameter list.
2151 ///
2152 /// \param TPC Describes the context in which we are checking the given
2153 /// template parameter list.
2154 ///
2155 /// \returns true if an error occurred, false otherwise.
2157  TemplateParameterList *OldParams,
2159  bool Invalid = false;
2160 
2161  // C++ [temp.param]p10:
2162  // The set of default template-arguments available for use with a
2163  // template declaration or definition is obtained by merging the
2164  // default arguments from the definition (if in scope) and all
2165  // declarations in scope in the same way default function
2166  // arguments are (8.3.6).
2167  bool SawDefaultArgument = false;
2168  SourceLocation PreviousDefaultArgLoc;
2169 
2170  // Dummy initialization to avoid warnings.
2171  TemplateParameterList::iterator OldParam = NewParams->end();
2172  if (OldParams)
2173  OldParam = OldParams->begin();
2174 
2175  bool RemoveDefaultArguments = false;
2176  for (TemplateParameterList::iterator NewParam = NewParams->begin(),
2177  NewParamEnd = NewParams->end();
2178  NewParam != NewParamEnd; ++NewParam) {
2179  // Variables used to diagnose redundant default arguments
2180  bool RedundantDefaultArg = false;
2181  SourceLocation OldDefaultLoc;
2182  SourceLocation NewDefaultLoc;
2183 
2184  // Variable used to diagnose missing default arguments
2185  bool MissingDefaultArg = false;
2186 
2187  // Variable used to diagnose non-final parameter packs
2188  bool SawParameterPack = false;
2189 
2190  if (TemplateTypeParmDecl *NewTypeParm
2191  = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
2192  // Check the presence of a default argument here.
2193  if (NewTypeParm->hasDefaultArgument() &&
2195  NewTypeParm->getLocation(),
2196  NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
2197  .getSourceRange()))
2198  NewTypeParm->removeDefaultArgument();
2199 
2200  // Merge default arguments for template type parameters.
2201  TemplateTypeParmDecl *OldTypeParm
2202  = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : nullptr;
2203  if (NewTypeParm->isParameterPack()) {
2204  assert(!NewTypeParm->hasDefaultArgument() &&
2205  "Parameter packs can't have a default argument!");
2206  SawParameterPack = true;
2207  } else if (OldTypeParm && hasVisibleDefaultArgument(OldTypeParm) &&
2208  NewTypeParm->hasDefaultArgument()) {
2209  OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc();
2210  NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
2211  SawDefaultArgument = true;
2212  RedundantDefaultArg = true;
2213  PreviousDefaultArgLoc = NewDefaultLoc;
2214  } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) {
2215  // Merge the default argument from the old declaration to the
2216  // new declaration.
2217  NewTypeParm->setInheritedDefaultArgument(Context, OldTypeParm);
2218  PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc();
2219  } else if (NewTypeParm->hasDefaultArgument()) {
2220  SawDefaultArgument = true;
2221  PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
2222  } else if (SawDefaultArgument)
2223  MissingDefaultArg = true;
2224  } else if (NonTypeTemplateParmDecl *NewNonTypeParm
2225  = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
2226  // Check for unexpanded parameter packs.
2227  if (!NewNonTypeParm->isParameterPack() &&
2228  DiagnoseUnexpandedParameterPack(NewNonTypeParm->getLocation(),
2229  NewNonTypeParm->getTypeSourceInfo(),
2230  UPPC_NonTypeTemplateParameterType)) {
2231  Invalid = true;
2232  continue;
2233  }
2234 
2235  // Check the presence of a default argument here.
2236  if (NewNonTypeParm->hasDefaultArgument() &&
2238  NewNonTypeParm->getLocation(),
2239  NewNonTypeParm->getDefaultArgument()->getSourceRange())) {
2240  NewNonTypeParm->removeDefaultArgument();
2241  }
2242 
2243  // Merge default arguments for non-type template parameters
2244  NonTypeTemplateParmDecl *OldNonTypeParm
2245  = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : nullptr;
2246  if (NewNonTypeParm->isParameterPack()) {
2247  assert(!NewNonTypeParm->hasDefaultArgument() &&
2248  "Parameter packs can't have a default argument!");
2249  if (!NewNonTypeParm->isPackExpansion())
2250  SawParameterPack = true;
2251  } else if (OldNonTypeParm && hasVisibleDefaultArgument(OldNonTypeParm) &&
2252  NewNonTypeParm->hasDefaultArgument()) {
2253  OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc();
2254  NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
2255  SawDefaultArgument = true;
2256  RedundantDefaultArg = true;
2257  PreviousDefaultArgLoc = NewDefaultLoc;
2258  } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) {
2259  // Merge the default argument from the old declaration to the
2260  // new declaration.
2261  NewNonTypeParm->setInheritedDefaultArgument(Context, OldNonTypeParm);
2262  PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc();
2263  } else if (NewNonTypeParm->hasDefaultArgument()) {
2264  SawDefaultArgument = true;
2265  PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
2266  } else if (SawDefaultArgument)
2267  MissingDefaultArg = true;
2268  } else {
2269  TemplateTemplateParmDecl *NewTemplateParm
2270  = cast<TemplateTemplateParmDecl>(*NewParam);
2271 
2272  // Check for unexpanded parameter packs, recursively.
2273  if (::DiagnoseUnexpandedParameterPacks(*this, NewTemplateParm)) {
2274  Invalid = true;
2275  continue;
2276  }
2277 
2278  // Check the presence of a default argument here.
2279  if (NewTemplateParm->hasDefaultArgument() &&
2281  NewTemplateParm->getLocation(),
2282  NewTemplateParm->getDefaultArgument().getSourceRange()))
2283  NewTemplateParm->removeDefaultArgument();
2284 
2285  // Merge default arguments for template template parameters
2286  TemplateTemplateParmDecl *OldTemplateParm
2287  = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : nullptr;
2288  if (NewTemplateParm->isParameterPack()) {
2289  assert(!NewTemplateParm->hasDefaultArgument() &&
2290  "Parameter packs can't have a default argument!");
2291  if (!NewTemplateParm->isPackExpansion())
2292  SawParameterPack = true;
2293  } else if (OldTemplateParm &&
2294  hasVisibleDefaultArgument(OldTemplateParm) &&
2295  NewTemplateParm->hasDefaultArgument()) {
2296  OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation();
2297  NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation();
2298  SawDefaultArgument = true;
2299  RedundantDefaultArg = true;
2300  PreviousDefaultArgLoc = NewDefaultLoc;
2301  } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) {
2302  // Merge the default argument from the old declaration to the
2303  // new declaration.
2304  NewTemplateParm->setInheritedDefaultArgument(Context, OldTemplateParm);
2305  PreviousDefaultArgLoc
2306  = OldTemplateParm->getDefaultArgument().getLocation();
2307  } else if (NewTemplateParm->hasDefaultArgument()) {
2308  SawDefaultArgument = true;
2309  PreviousDefaultArgLoc
2310  = NewTemplateParm->getDefaultArgument().getLocation();
2311  } else if (SawDefaultArgument)
2312  MissingDefaultArg = true;
2313  }
2314 
2315  // C++11 [temp.param]p11:
2316  // If a template parameter of a primary class template or alias template
2317  // is a template parameter pack, it shall be the last template parameter.
2318  if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
2319  (TPC == TPC_ClassTemplate || TPC == TPC_VarTemplate ||
2320  TPC == TPC_TypeAliasTemplate)) {
2321  Diag((*NewParam)->getLocation(),
2322  diag::err_template_param_pack_must_be_last_template_parameter);
2323  Invalid = true;
2324  }
2325 
2326  if (RedundantDefaultArg) {
2327  // C++ [temp.param]p12:
2328  // A template-parameter shall not be given default arguments
2329  // by two different declarations in the same scope.
2330  Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
2331  Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
2332  Invalid = true;
2333  } else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) {
2334  // C++ [temp.param]p11:
2335  // If a template-parameter of a class template has a default
2336  // template-argument, each subsequent template-parameter shall either
2337  // have a default template-argument supplied or be a template parameter
2338  // pack.
2339  Diag((*NewParam)->getLocation(),
2340  diag::err_template_param_default_arg_missing);
2341  Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
2342  Invalid = true;
2343  RemoveDefaultArguments = true;
2344  }
2345 
2346  // If we have an old template parameter list that we're merging
2347  // in, move on to the next parameter.
2348  if (OldParams)
2349  ++OldParam;
2350  }
2351 
2352  // We were missing some default arguments at the end of the list, so remove
2353  // all of the default arguments.
2354  if (RemoveDefaultArguments) {
2355  for (TemplateParameterList::iterator NewParam = NewParams->begin(),
2356  NewParamEnd = NewParams->end();
2357  NewParam != NewParamEnd; ++NewParam) {
2358  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*NewParam))
2359  TTP->removeDefaultArgument();
2360  else if (NonTypeTemplateParmDecl *NTTP
2361  = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
2362  NTTP->removeDefaultArgument();
2363  else
2364  cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
2365  }
2366  }
2367 
2368  return Invalid;
2369 }
2370 
2371 namespace {
2372 
2373 /// A class which looks for a use of a certain level of template
2374 /// parameter.
2375 struct DependencyChecker : RecursiveASTVisitor<DependencyChecker> {
2377 
2378  unsigned Depth;
2379 
2380  // Whether we're looking for a use of a template parameter that makes the
2381  // overall construct type-dependent / a dependent type. This is strictly
2382  // best-effort for now; we may fail to match at all for a dependent type
2383  // in some cases if this is set.
2384  bool IgnoreNonTypeDependent;
2385 
2386  bool Match;
2387  SourceLocation MatchLoc;
2388 
2389  DependencyChecker(unsigned Depth, bool IgnoreNonTypeDependent)
2390  : Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
2391  Match(false) {}
2392 
2393  DependencyChecker(TemplateParameterList *Params, bool IgnoreNonTypeDependent)
2394  : IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(false) {
2395  NamedDecl *ND = Params->getParam(0);
2396  if (TemplateTypeParmDecl *PD = dyn_cast<TemplateTypeParmDecl>(ND)) {
2397  Depth = PD->getDepth();
2398  } else if (NonTypeTemplateParmDecl *PD =
2399  dyn_cast<NonTypeTemplateParmDecl>(ND)) {
2400  Depth = PD->getDepth();
2401  } else {
2402  Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
2403  }
2404  }
2405 
2406  bool Matches(unsigned ParmDepth, SourceLocation Loc = SourceLocation()) {
2407  if (ParmDepth >= Depth) {
2408  Match = true;
2409  MatchLoc = Loc;
2410  return true;
2411  }
2412  return false;
2413  }
2414 
2415  bool TraverseStmt(Stmt *S, DataRecursionQueue *Q = nullptr) {
2416  // Prune out non-type-dependent expressions if requested. This can
2417  // sometimes result in us failing to find a template parameter reference
2418  // (if a value-dependent expression creates a dependent type), but this
2419  // mode is best-effort only.
2420  if (auto *E = dyn_cast_or_null<Expr>(S))
2421  if (IgnoreNonTypeDependent && !E->isTypeDependent())
2422  return true;
2423  return super::TraverseStmt(S, Q);
2424  }
2425 
2426  bool TraverseTypeLoc(TypeLoc TL) {
2427  if (IgnoreNonTypeDependent && !TL.isNull() &&
2428  !TL.getType()->isDependentType())
2429  return true;
2430  return super::TraverseTypeLoc(TL);
2431  }
2432 
2433  bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
2434  return !Matches(TL.getTypePtr()->getDepth(), TL.getNameLoc());
2435  }
2436 
2437  bool VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
2438  // For a best-effort search, keep looking until we find a location.
2439  return IgnoreNonTypeDependent || !Matches(T->getDepth());
2440  }
2441 
2442  bool TraverseTemplateName(TemplateName N) {
2443  if (TemplateTemplateParmDecl *PD =
2444  dyn_cast_or_null<TemplateTemplateParmDecl>(N.getAsTemplateDecl()))
2445  if (Matches(PD->getDepth()))
2446  return false;
2447  return super::TraverseTemplateName(N);
2448  }
2449 
2450  bool VisitDeclRefExpr(DeclRefExpr *E) {
2451  if (NonTypeTemplateParmDecl *PD =
2452  dyn_cast<NonTypeTemplateParmDecl>(E->getDecl()))
2453  if (Matches(PD->getDepth(), E->getExprLoc()))
2454  return false;
2455  return super::VisitDeclRefExpr(E);
2456  }
2457 
2458  bool VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
2459  return TraverseType(T->getReplacementType());
2460  }
2461 
2462  bool
2463  VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
2464  return TraverseTemplateArgument(T->getArgumentPack());
2465  }
2466 
2467  bool TraverseInjectedClassNameType(const InjectedClassNameType *T) {
2468  return TraverseType(T->getInjectedSpecializationType());
2469  }
2470 };
2471 } // end anonymous namespace
2472 
2473 /// Determines whether a given type depends on the given parameter
2474 /// list.
2475 static bool
2477  DependencyChecker Checker(Params, /*IgnoreNonTypeDependent*/false);
2478  Checker.TraverseType(T);
2479  return Checker.Match;
2480 }
2481 
2482 // Find the source range corresponding to the named type in the given
2483 // nested-name-specifier, if any.
2485  QualType T,
2486  const CXXScopeSpec &SS) {
2488  while (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier()) {
2489  if (const Type *CurType = NNS->getAsType()) {
2490  if (Context.hasSameUnqualifiedType(T, QualType(CurType, 0)))
2491  return NNSLoc.getTypeLoc().getSourceRange();
2492  } else
2493  break;
2494 
2495  NNSLoc = NNSLoc.getPrefix();
2496  }
2497 
2498  return SourceRange();
2499 }
2500 
2501 /// Match the given template parameter lists to the given scope
2502 /// specifier, returning the template parameter list that applies to the
2503 /// name.
2504 ///
2505 /// \param DeclStartLoc the start of the declaration that has a scope
2506 /// specifier or a template parameter list.
2507 ///
2508 /// \param DeclLoc The location of the declaration itself.
2509 ///
2510 /// \param SS the scope specifier that will be matched to the given template
2511 /// parameter lists. This scope specifier precedes a qualified name that is
2512 /// being declared.
2513 ///
2514 /// \param TemplateId The template-id following the scope specifier, if there
2515 /// is one. Used to check for a missing 'template<>'.
2516 ///
2517 /// \param ParamLists the template parameter lists, from the outermost to the
2518 /// innermost template parameter lists.
2519 ///
2520 /// \param IsFriend Whether to apply the slightly different rules for
2521 /// matching template parameters to scope specifiers in friend
2522 /// declarations.
2523 ///
2524 /// \param IsMemberSpecialization will be set true if the scope specifier
2525 /// denotes a fully-specialized type, and therefore this is a declaration of
2526 /// a member specialization.
2527 ///
2528 /// \returns the template parameter list, if any, that corresponds to the
2529 /// name that is preceded by the scope specifier @p SS. This template
2530 /// parameter list may have template parameters (if we're declaring a
2531 /// template) or may have no template parameters (if we're declaring a
2532 /// template specialization), or may be NULL (if what we're declaring isn't
2533 /// itself a template).
2535  SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS,
2536  TemplateIdAnnotation *TemplateId,
2537  ArrayRef<TemplateParameterList *> ParamLists, bool IsFriend,
2538  bool &IsMemberSpecialization, bool &Invalid) {
2539  IsMemberSpecialization = false;
2540  Invalid = false;
2541 
2542  // The sequence of nested types to which we will match up the template
2543  // parameter lists. We first build this list by starting with the type named
2544  // by the nested-name-specifier and walking out until we run out of types.
2545  SmallVector<QualType, 4> NestedTypes;
2546  QualType T;
2547  if (SS.getScopeRep()) {
2548  if (CXXRecordDecl *Record
2549  = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, true)))
2550  T = Context.getTypeDeclType(Record);
2551  else
2552  T = QualType(SS.getScopeRep()->getAsType(), 0);
2553  }
2554 
2555  // If we found an explicit specialization that prevents us from needing
2556  // 'template<>' headers, this will be set to the location of that
2557  // explicit specialization.
2558  SourceLocation ExplicitSpecLoc;
2559 
2560  while (!T.isNull()) {
2561  NestedTypes.push_back(T);
2562 
2563  // Retrieve the parent of a record type.
2564  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
2565  // If this type is an explicit specialization, we're done.
2567  = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
2568  if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
2569  Spec->getSpecializationKind() == TSK_ExplicitSpecialization) {
2570  ExplicitSpecLoc = Spec->getLocation();
2571  break;
2572  }
2573  } else if (Record->getTemplateSpecializationKind()
2575  ExplicitSpecLoc = Record->getLocation();
2576  break;
2577  }
2578 
2579  if (TypeDecl *Parent = dyn_cast<TypeDecl>(Record->getParent()))
2580  T = Context.getTypeDeclType(Parent);
2581  else
2582  T = QualType();
2583  continue;
2584  }
2585 
2586  if (const TemplateSpecializationType *TST
2588  if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2589  if (TypeDecl *Parent = dyn_cast<TypeDecl>(Template->getDeclContext()))
2590  T = Context.getTypeDeclType(Parent);
2591  else
2592  T = QualType();
2593  continue;
2594  }
2595  }
2596 
2597  // Look one step prior in a dependent template specialization type.
2598  if (const DependentTemplateSpecializationType *DependentTST
2600  if (NestedNameSpecifier *NNS = DependentTST->getQualifier())
2601  T = QualType(NNS->getAsType(), 0);
2602  else
2603  T = QualType();
2604  continue;
2605  }
2606 
2607  // Look one step prior in a dependent name type.
2608  if (const DependentNameType *DependentName = T->getAs<DependentNameType>()){
2609  if (NestedNameSpecifier *NNS = DependentName->getQualifier())
2610  T = QualType(NNS->getAsType(), 0);
2611  else
2612  T = QualType();
2613  continue;
2614  }
2615 
2616  // Retrieve the parent of an enumeration type.
2617  if (const EnumType *EnumT = T->getAs<EnumType>()) {
2618  // FIXME: Forward-declared enums require a TSK_ExplicitSpecialization
2619  // check here.
2620  EnumDecl *Enum = EnumT->getDecl();
2621 
2622  // Get to the parent type.
2623  if (TypeDecl *Parent = dyn_cast<TypeDecl>(Enum->getParent()))
2624  T = Context.getTypeDeclType(Parent);
2625  else
2626  T = QualType();
2627  continue;
2628  }
2629 
2630  T = QualType();
2631  }
2632  // Reverse the nested types list, since we want to traverse from the outermost
2633  // to the innermost while checking template-parameter-lists.
2634  std::reverse(NestedTypes.begin(), NestedTypes.end());
2635 
2636  // C++0x [temp.expl.spec]p17:
2637  // A member or a member template may be nested within many
2638  // enclosing class templates. In an explicit specialization for
2639  // such a member, the member declaration shall be preceded by a
2640  // template<> for each enclosing class template that is
2641  // explicitly specialized.
2642  bool SawNonEmptyTemplateParameterList = false;
2643 
2644  auto CheckExplicitSpecialization = [&](SourceRange Range, bool Recovery) {
2645  if (SawNonEmptyTemplateParameterList) {
2646  Diag(DeclLoc, diag::err_specialize_member_of_template)
2647  << !Recovery << Range;
2648  Invalid = true;
2649  IsMemberSpecialization = false;
2650  return true;
2651  }
2652 
2653  return false;
2654  };
2655 
2656  auto DiagnoseMissingExplicitSpecialization = [&] (SourceRange Range) {
2657  // Check that we can have an explicit specialization here.
2658  if (CheckExplicitSpecialization(Range, true))
2659  return true;
2660 
2661  // We don't have a template header, but we should.
2662  SourceLocation ExpectedTemplateLoc;
2663  if (!ParamLists.empty())
2664  ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
2665  else
2666  ExpectedTemplateLoc = DeclStartLoc;
2667 
2668  Diag(DeclLoc, diag::err_template_spec_needs_header)
2669  << Range
2670  << FixItHint::CreateInsertion(ExpectedTemplateLoc, "template<> ");
2671  return false;
2672  };
2673 
2674  unsigned ParamIdx = 0;
2675  for (unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
2676  ++TypeIdx) {
2677  T = NestedTypes[TypeIdx];
2678 
2679  // Whether we expect a 'template<>' header.
2680  bool NeedEmptyTemplateHeader = false;
2681 
2682  // Whether we expect a template header with parameters.
2683  bool NeedNonemptyTemplateHeader = false;
2684 
2685  // For a dependent type, the set of template parameters that we
2686  // expect to see.
2687  TemplateParameterList *ExpectedTemplateParams = nullptr;
2688 
2689  // C++0x [temp.expl.spec]p15:
2690  // A member or a member template may be nested within many enclosing
2691  // class templates. In an explicit specialization for such a member, the
2692  // member declaration shall be preceded by a template<> for each
2693  // enclosing class template that is explicitly specialized.
2694  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
2696  = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) {
2697  ExpectedTemplateParams = Partial->getTemplateParameters();
2698  NeedNonemptyTemplateHeader = true;
2699  } else if (Record->isDependentType()) {
2700  if (Record->getDescribedClassTemplate()) {
2701  ExpectedTemplateParams = Record->getDescribedClassTemplate()
2702  ->getTemplateParameters();
2703  NeedNonemptyTemplateHeader = true;
2704  }
2705  } else if (ClassTemplateSpecializationDecl *Spec
2706  = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
2707  // C++0x [temp.expl.spec]p4:
2708  // Members of an explicitly specialized class template are defined
2709  // in the same manner as members of normal classes, and not using
2710  // the template<> syntax.
2711  if (Spec->getSpecializationKind() != TSK_ExplicitSpecialization)
2712  NeedEmptyTemplateHeader = true;
2713  else
2714  continue;
2715  } else if (Record->getTemplateSpecializationKind()) {
2716  if (Record->getTemplateSpecializationKind()
2718  TypeIdx == NumTypes - 1)
2719  IsMemberSpecialization = true;
2720 
2721  continue;
2722  }
2723  } else if (const TemplateSpecializationType *TST
2725  if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2726  ExpectedTemplateParams = Template->getTemplateParameters();
2727  NeedNonemptyTemplateHeader = true;
2728  }
2729  } else if (T->getAs<DependentTemplateSpecializationType>()) {
2730  // FIXME: We actually could/should check the template arguments here
2731  // against the corresponding template parameter list.
2732  NeedNonemptyTemplateHeader = false;
2733  }
2734 
2735  // C++ [temp.expl.spec]p16:
2736  // In an explicit specialization declaration for a member of a class
2737  // template or a member template that ap- pears in namespace scope, the
2738  // member template and some of its enclosing class templates may remain
2739  // unspecialized, except that the declaration shall not explicitly
2740  // specialize a class member template if its en- closing class templates
2741  // are not explicitly specialized as well.
2742  if (ParamIdx < ParamLists.size()) {
2743  if (ParamLists[ParamIdx]->size() == 0) {
2744  if (CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
2745  false))
2746  return nullptr;
2747  } else
2748  SawNonEmptyTemplateParameterList = true;
2749  }
2750 
2751  if (NeedEmptyTemplateHeader) {
2752  // If we're on the last of the types, and we need a 'template<>' header
2753  // here, then it's a member specialization.
2754  if (TypeIdx == NumTypes - 1)
2755  IsMemberSpecialization = true;
2756 
2757  if (ParamIdx < ParamLists.size()) {
2758  if (ParamLists[ParamIdx]->size() > 0) {
2759  // The header has template parameters when it shouldn't. Complain.
2760  Diag(ParamLists[ParamIdx]->getTemplateLoc(),
2761  diag::err_template_param_list_matches_nontemplate)
2762  << T
2763  << SourceRange(ParamLists[ParamIdx]->getLAngleLoc(),
2764  ParamLists[ParamIdx]->getRAngleLoc())
2765  << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
2766  Invalid = true;
2767  return nullptr;
2768  }
2769 
2770  // Consume this template header.
2771  ++ParamIdx;
2772  continue;
2773  }
2774 
2775  if (!IsFriend)
2776  if (DiagnoseMissingExplicitSpecialization(
2777  getRangeOfTypeInNestedNameSpecifier(Context, T, SS)))
2778  return nullptr;
2779 
2780  continue;
2781  }
2782 
2783  if (NeedNonemptyTemplateHeader) {
2784  // In friend declarations we can have template-ids which don't
2785  // depend on the corresponding template parameter lists. But
2786  // assume that empty parameter lists are supposed to match this
2787  // template-id.
2788  if (IsFriend && T->isDependentType()) {
2789  if (ParamIdx < ParamLists.size() &&
2790  DependsOnTemplateParameters(T, ParamLists[ParamIdx]))
2791  ExpectedTemplateParams = nullptr;
2792  else
2793  continue;
2794  }
2795 
2796  if (ParamIdx < ParamLists.size()) {
2797  // Check the template parameter list, if we can.
2798  if (ExpectedTemplateParams &&
2799  !TemplateParameterListsAreEqual(ParamLists[ParamIdx],
2800  ExpectedTemplateParams,
2801  true, TPL_TemplateMatch))
2802  Invalid = true;
2803 
2804  if (!Invalid &&
2805  CheckTemplateParameterList(ParamLists[ParamIdx], nullptr,
2806  TPC_ClassTemplateMember))
2807  Invalid = true;
2808 
2809  ++ParamIdx;
2810  continue;
2811  }
2812 
2813  Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
2814  << T
2815  << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
2816  Invalid = true;
2817  continue;
2818  }
2819  }
2820 
2821  // If there were at least as many template-ids as there were template
2822  // parameter lists, then there are no template parameter lists remaining for
2823  // the declaration itself.
2824  if (ParamIdx >= ParamLists.size()) {
2825  if (TemplateId && !IsFriend) {
2826  // We don't have a template header for the declaration itself, but we
2827  // should.
2828  DiagnoseMissingExplicitSpecialization(SourceRange(TemplateId->LAngleLoc,
2829  TemplateId->RAngleLoc));
2830 
2831  // Fabricate an empty template parameter list for the invented header.
2833  SourceLocation(), None,
2834  SourceLocation(), nullptr);
2835  }
2836 
2837  return nullptr;
2838  }
2839 
2840  // If there were too many template parameter lists, complain about that now.
2841  if (ParamIdx < ParamLists.size() - 1) {
2842  bool HasAnyExplicitSpecHeader = false;
2843  bool AllExplicitSpecHeaders = true;
2844  for (unsigned I = ParamIdx, E = ParamLists.size() - 1; I != E; ++I) {
2845  if (ParamLists[I]->size() == 0)
2846  HasAnyExplicitSpecHeader = true;
2847  else
2848  AllExplicitSpecHeaders = false;
2849  }
2850 
2851  Diag(ParamLists[ParamIdx]->getTemplateLoc(),
2852  AllExplicitSpecHeaders ? diag::warn_template_spec_extra_headers
2853  : diag::err_template_spec_extra_headers)
2854  << SourceRange(ParamLists[ParamIdx]->getTemplateLoc(),
2855  ParamLists[ParamLists.size() - 2]->getRAngleLoc());
2856 
2857  // If there was a specialization somewhere, such that 'template<>' is
2858  // not required, and there were any 'template<>' headers, note where the
2859  // specialization occurred.
2860  if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader)
2861  Diag(ExplicitSpecLoc,
2862  diag::note_explicit_template_spec_does_not_need_header)
2863  << NestedTypes.back();
2864 
2865  // We have a template parameter list with no corresponding scope, which
2866  // means that the resulting template declaration can't be instantiated
2867  // properly (we'll end up with dependent nodes when we shouldn't).
2868  if (!AllExplicitSpecHeaders)
2869  Invalid = true;
2870  }
2871 
2872  // C++ [temp.expl.spec]p16:
2873  // In an explicit specialization declaration for a member of a class
2874  // template or a member template that ap- pears in namespace scope, the
2875  // member template and some of its enclosing class templates may remain
2876  // unspecialized, except that the declaration shall not explicitly
2877  // specialize a class member template if its en- closing class templates
2878  // are not explicitly specialized as well.
2879  if (ParamLists.back()->size() == 0 &&
2880  CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
2881  false))
2882  return nullptr;
2883 
2884  // Return the last template parameter list, which corresponds to the
2885  // entity being declared.
2886  return ParamLists.back();
2887 }
2888 
2890  if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
2891  Diag(Template->getLocation(), diag::note_template_declared_here)
2892  << (isa<FunctionTemplateDecl>(Template)
2893  ? 0
2894  : isa<ClassTemplateDecl>(Template)
2895  ? 1
2896  : isa<VarTemplateDecl>(Template)
2897  ? 2
2898  : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
2899  << Template->getDeclName();
2900  return;
2901  }
2902 
2904  for (OverloadedTemplateStorage::iterator I = OST->begin(),
2905  IEnd = OST->end();
2906  I != IEnd; ++I)
2907  Diag((*I)->getLocation(), diag::note_template_declared_here)
2908  << 0 << (*I)->getDeclName();
2909 
2910  return;
2911  }
2912 }
2913 
2914 static QualType
2916  const SmallVectorImpl<TemplateArgument> &Converted,
2917  SourceLocation TemplateLoc,
2918  TemplateArgumentListInfo &TemplateArgs) {
2919  ASTContext &Context = SemaRef.getASTContext();
2920  switch (BTD->getBuiltinTemplateKind()) {
2921  case BTK__make_integer_seq: {
2922  // Specializations of __make_integer_seq<S, T, N> are treated like
2923  // S<T, 0, ..., N-1>.
2924 
2925  // C++14 [inteseq.intseq]p1:
2926  // T shall be an integer type.
2927  if (!Converted[1].getAsType()->isIntegralType(Context)) {
2928  SemaRef.Diag(TemplateArgs[1].getLocation(),
2929  diag::err_integer_sequence_integral_element_type);
2930  return QualType();
2931  }
2932 
2933  // C++14 [inteseq.make]p1:
2934  // If N is negative the program is ill-formed.
2935  TemplateArgument NumArgsArg = Converted[2];
2936  llvm::APSInt NumArgs = NumArgsArg.getAsIntegral();
2937  if (NumArgs < 0) {
2938  SemaRef.Diag(TemplateArgs[2].getLocation(),
2939  diag::err_integer_sequence_negative_length);
2940  return QualType();
2941  }
2942 
2943  QualType ArgTy = NumArgsArg.getIntegralType();
2944  TemplateArgumentListInfo SyntheticTemplateArgs;
2945  // The type argument gets reused as the first template argument in the
2946  // synthetic template argument list.
2947  SyntheticTemplateArgs.addArgument(TemplateArgs[1]);
2948  // Expand N into 0 ... N-1.
2949  for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
2950  I < NumArgs; ++I) {
2951  TemplateArgument TA(Context, I, ArgTy);
2952  SyntheticTemplateArgs.addArgument(SemaRef.getTrivialTemplateArgumentLoc(
2953  TA, ArgTy, TemplateArgs[2].getLocation()));
2954  }
2955  // The first template argument will be reused as the template decl that
2956  // our synthetic template arguments will be applied to.
2957  return SemaRef.CheckTemplateIdType(Converted[0].getAsTemplate(),
2958  TemplateLoc, SyntheticTemplateArgs);
2959  }
2960 
2962  // Specializations of
2963  // __type_pack_element<Index, T_1, ..., T_N>
2964  // are treated like T_Index.
2965  assert(Converted.size() == 2 &&
2966  "__type_pack_element should be given an index and a parameter pack");
2967 
2968  // If the Index is out of bounds, the program is ill-formed.
2969  TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
2970  llvm::APSInt Index = IndexArg.getAsIntegral();
2971  assert(Index >= 0 && "the index used with __type_pack_element should be of "
2972  "type std::size_t, and hence be non-negative");
2973  if (Index >= Ts.pack_size()) {
2974  SemaRef.Diag(TemplateArgs[0].getLocation(),
2975  diag::err_type_pack_element_out_of_bounds);
2976  return QualType();
2977  }
2978 
2979  // We simply return the type at index `Index`.
2980  auto Nth = std::next(Ts.pack_begin(), Index.getExtValue());
2981  return Nth->getAsType();
2982  }
2983  llvm_unreachable("unexpected BuiltinTemplateDecl!");
2984 }
2985 
2986 /// Determine whether this alias template is "enable_if_t".
2987 static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate) {
2988  return AliasTemplate->getName().equals("enable_if_t");
2989 }
2990 
2991 /// Collect all of the separable terms in the given condition, which
2992 /// might be a conjunction.
2993 ///
2994 /// FIXME: The right answer is to convert the logical expression into
2995 /// disjunctive normal form, so we can find the first failed term
2996 /// within each possible clause.
2997 static void collectConjunctionTerms(Expr *Clause,
2998  SmallVectorImpl<Expr *> &Terms) {
2999  if (auto BinOp = dyn_cast<BinaryOperator>(Clause->IgnoreParenImpCasts())) {
3000  if (BinOp->getOpcode() == BO_LAnd) {
3001  collectConjunctionTerms(BinOp->getLHS(), Terms);
3002  collectConjunctionTerms(BinOp->getRHS(), Terms);
3003  }
3004 
3005  return;
3006  }
3007 
3008  Terms.push_back(Clause);
3009 }
3010 
3011 // The ranges-v3 library uses an odd pattern of a top-level "||" with
3012 // a left-hand side that is value-dependent but never true. Identify
3013 // the idiom and ignore that term.
3015  // Top-level '||'.
3016  auto *BinOp = dyn_cast<BinaryOperator>(Cond->IgnoreParenImpCasts());
3017  if (!BinOp) return Cond;
3018 
3019  if (BinOp->getOpcode() != BO_LOr) return Cond;
3020 
3021  // With an inner '==' that has a literal on the right-hand side.
3022  Expr *LHS = BinOp->getLHS();
3023  auto *InnerBinOp = dyn_cast<BinaryOperator>(LHS->IgnoreParenImpCasts());
3024  if (!InnerBinOp) return Cond;
3025 
3026  if (InnerBinOp->getOpcode() != BO_EQ ||
3027  !isa<IntegerLiteral>(InnerBinOp->getRHS()))
3028  return Cond;
3029 
3030  // If the inner binary operation came from a macro expansion named
3031  // CONCEPT_REQUIRES or CONCEPT_REQUIRES_, return the right-hand side
3032  // of the '||', which is the real, user-provided condition.
3033  SourceLocation Loc = InnerBinOp->getExprLoc();
3034  if (!Loc.isMacroID()) return Cond;
3035 
3036  StringRef MacroName = PP.getImmediateMacroName(Loc);
3037  if (MacroName == "CONCEPT_REQUIRES" || MacroName == "CONCEPT_REQUIRES_")
3038  return BinOp->getRHS();
3039 
3040  return Cond;
3041 }
3042 
3043 std::pair<Expr *, std::string>
3044 Sema::findFailedBooleanCondition(Expr *Cond, bool AllowTopLevelCond) {
3045  Cond = lookThroughRangesV3Condition(PP, Cond);
3046 
3047  // Separate out all of the terms in a conjunction.
3048  SmallVector<Expr *, 4> Terms;
3049  collectConjunctionTerms(Cond, Terms);
3050 
3051  // Determine which term failed.
3052  Expr *FailedCond = nullptr;
3053  for (Expr *Term : Terms) {
3054  Expr *TermAsWritten = Term->IgnoreParenImpCasts();
3055 
3056  // Literals are uninteresting.
3057  if (isa<CXXBoolLiteralExpr>(TermAsWritten) ||
3058  isa<IntegerLiteral>(TermAsWritten))
3059  continue;
3060 
3061  // The initialization of the parameter from the argument is
3062  // a constant-evaluated context.
3063  EnterExpressionEvaluationContext ConstantEvaluated(
3065 
3066  bool Succeeded;
3067  if (Term->EvaluateAsBooleanCondition(Succeeded, Context) &&
3068  !Succeeded) {
3069  FailedCond = TermAsWritten;
3070  break;
3071  }
3072  }
3073 
3074  if (!FailedCond) {
3075  if (!AllowTopLevelCond)
3076  return { nullptr, "" };
3077 
3078  FailedCond = Cond->IgnoreParenImpCasts();
3079  }
3080 
3081  std::string Description;
3082  {
3083  llvm::raw_string_ostream Out(Description);
3084  FailedCond->printPretty(Out, nullptr, getPrintingPolicy());
3085  }
3086  return { FailedCond, Description };
3087 }
3088 
3090  SourceLocation TemplateLoc,
3091  TemplateArgumentListInfo &TemplateArgs) {
3094  if (DTN && DTN->isIdentifier())
3095  // When building a template-id where the template-name is dependent,
3096  // assume the template is a type template. Either our assumption is
3097  // correct, or the code is ill-formed and will be diagnosed when the
3098  // dependent name is substituted.
3100  DTN->getQualifier(),
3101  DTN->getIdentifier(),
3102  TemplateArgs);
3103 
3104  TemplateDecl *Template = Name.getAsTemplateDecl();
3105  if (!Template || isa<FunctionTemplateDecl>(Template) ||
3106  isa<VarTemplateDecl>(Template)) {
3107  // We might have a substituted template template parameter pack. If so,
3108  // build a template specialization type for it.
3110  return Context.getTemplateSpecializationType(Name, TemplateArgs);
3111 
3112  Diag(TemplateLoc, diag::err_template_id_not_a_type)
3113  << Name;
3114  NoteAllFoundTemplates(Name);
3115  return QualType();
3116  }
3117 
3118  // Check that the template argument list is well-formed for this
3119  // template.
3121  if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
3122  false, Converted))
3123  return QualType();
3124 
3125  QualType CanonType;
3126 
3127  bool InstantiationDependent = false;
3128  if (TypeAliasTemplateDecl *AliasTemplate =
3129  dyn_cast<TypeAliasTemplateDecl>(Template)) {
3130  // Find the canonical type for this type alias template specialization.
3131  TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
3132  if (Pattern->isInvalidDecl())
3133  return QualType();
3134 
3136  Converted);
3137 
3138  // Only substitute for the innermost template argument list.
3139  MultiLevelTemplateArgumentList TemplateArgLists;
3140  TemplateArgLists.addOuterTemplateArguments(&StackTemplateArgs);
3141  unsigned Depth = AliasTemplate->getTemplateParameters()->getDepth();
3142  for (unsigned I = 0; I < Depth; ++I)
3143  TemplateArgLists.addOuterTemplateArguments(None);
3144 
3146  InstantiatingTemplate Inst(*this, TemplateLoc, Template);
3147  if (Inst.isInvalid())
3148  return QualType();
3149 
3150  CanonType = SubstType(Pattern->getUnderlyingType(),
3151  TemplateArgLists, AliasTemplate->getLocation(),
3152  AliasTemplate->getDeclName());
3153  if (CanonType.isNull()) {
3154  // If this was enable_if and we failed to find the nested type
3155  // within enable_if in a SFINAE context, dig out the specific
3156  // enable_if condition that failed and present that instead.
3157  if (isEnableIfAliasTemplate(AliasTemplate)) {
3158  if (auto DeductionInfo = isSFINAEContext()) {
3159  if (*DeductionInfo &&
3160  (*DeductionInfo)->hasSFINAEDiagnostic() &&
3161  (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
3162  diag::err_typename_nested_not_found_enable_if &&
3163  TemplateArgs[0].getArgument().getKind()
3165  Expr *FailedCond;
3166  std::string FailedDescription;
3167  std::tie(FailedCond, FailedDescription) =
3168  findFailedBooleanCondition(
3169  TemplateArgs[0].getSourceExpression(),
3170  /*AllowTopLevelCond=*/true);
3171 
3172  // Remove the old SFINAE diagnostic.
3173  PartialDiagnosticAt OldDiag =
3175  (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);
3176 
3177  // Add a new SFINAE diagnostic specifying which condition
3178  // failed.
3179  (*DeductionInfo)->addSFINAEDiagnostic(
3180  OldDiag.first,
3181  PDiag(diag::err_typename_nested_not_found_requirement)
3182  << FailedDescription
3183  << FailedCond->getSourceRange());
3184  }
3185  }
3186  }
3187 
3188  return QualType();
3189  }
3190  } else if (Name.isDependent() ||
3192  TemplateArgs, InstantiationDependent)) {
3193  // This class template specialization is a dependent
3194  // type. Therefore, its canonical type is another class template
3195  // specialization type that contains all of the converted
3196  // arguments in canonical form. This ensures that, e.g., A<T> and
3197  // A<T, T> have identical types when A is declared as:
3198  //
3199  // template<typename T, typename U = T> struct A;
3200  CanonType = Context.getCanonicalTemplateSpecializationType(Name, Converted);
3201 
3202  // This might work out to be a current instantiation, in which
3203  // case the canonical type needs to be the InjectedClassNameType.
3204  //
3205  // TODO: in theory this could be a simple hashtable lookup; most
3206  // changes to CurContext don't change the set of current
3207  // instantiations.
3208  if (isa<ClassTemplateDecl>(Template)) {
3209  for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getLookupParent()) {
3210  // If we get out to a namespace, we're done.
3211  if (Ctx->isFileContext()) break;
3212 
3213  // If this isn't a record, keep looking.
3214  CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx);
3215  if (!Record) continue;
3216 
3217  // Look for one of the two cases with InjectedClassNameTypes
3218  // and check whether it's the same template.
3219  if (!isa<ClassTemplatePartialSpecializationDecl>(Record) &&
3220  !Record->getDescribedClassTemplate())
3221  continue;
3222 
3223  // Fetch the injected class name type and check whether its
3224  // injected type is equal to the type we just built.
3225  QualType ICNT = Context.getTypeDeclType(Record);
3226  QualType Injected = cast<InjectedClassNameType>(ICNT)
3227  ->getInjectedSpecializationType();
3228 
3229  if (CanonType != Injected->getCanonicalTypeInternal())
3230  continue;
3231 
3232  // If so, the canonical type of this TST is the injected
3233  // class name type of the record we just found.
3234  assert(ICNT.isCanonical());
3235  CanonType = ICNT;
3236  break;
3237  }
3238  }
3239  } else if (ClassTemplateDecl *ClassTemplate
3240  = dyn_cast<ClassTemplateDecl>(Template)) {
3241  // Find the class template specialization declaration that
3242  // corresponds to these arguments.
3243  void *InsertPos = nullptr;
3245  = ClassTemplate->findSpecialization(Converted, InsertPos);
3246  if (!Decl) {
3247  // This is the first time we have referenced this class template
3248  // specialization. Create the canonical declaration and add it to
3249  // the set of specializations.
3251  ClassTemplate->getTemplatedDecl()->getTagKind(),
3252  ClassTemplate->getDeclContext(),
3253  ClassTemplate->getTemplatedDecl()->getLocStart(),
3254  ClassTemplate->getLocation(),
3255  ClassTemplate,
3256  Converted, nullptr);
3257  ClassTemplate->AddSpecialization(Decl, InsertPos);
3258  if (ClassTemplate->isOutOfLine())
3259  Decl->setLexicalDeclContext(ClassTemplate->getLexicalDeclContext());
3260  }
3261 
3262  if (Decl->getSpecializationKind() == TSK_Undeclared) {
3263  MultiLevelTemplateArgumentList TemplateArgLists;
3264  TemplateArgLists.addOuterTemplateArguments(Converted);
3265  InstantiateAttrsForDecl(TemplateArgLists, ClassTemplate->getTemplatedDecl(),
3266  Decl);
3267  }
3268 
3269  // Diagnose uses of this specialization.
3270  (void)DiagnoseUseOfDecl(Decl, TemplateLoc);
3271 
3272  CanonType = Context.getTypeDeclType(Decl);
3273  assert(isa<RecordType>(CanonType) &&
3274  "type of non-dependent specialization is not a RecordType");
3275  } else if (auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
3276  CanonType = checkBuiltinTemplateIdType(*this, BTD, Converted, TemplateLoc,
3277  TemplateArgs);
3278  }
3279 
3280  // Build the fully-sugared type for this class template
3281  // specialization, which refers back to the class template
3282  // specialization we created or found.
3283  return Context.getTemplateSpecializationType(Name, TemplateArgs, CanonType);
3284 }
3285 
3286 TypeResult
3288  TemplateTy TemplateD, IdentifierInfo *TemplateII,
3289  SourceLocation TemplateIILoc,
3290  SourceLocation LAngleLoc,
3291  ASTTemplateArgsPtr TemplateArgsIn,
3292  SourceLocation RAngleLoc,
3293  bool IsCtorOrDtorName, bool IsClassName) {
3294  if (SS.isInvalid())
3295  return true;
3296 
3297  if (!IsCtorOrDtorName && !IsClassName && SS.isSet()) {
3298  DeclContext *LookupCtx = computeDeclContext(SS, /*EnteringContext*/false);
3299 
3300  // C++ [temp.res]p3:
3301  // A qualified-id that refers to a type and in which the
3302  // nested-name-specifier depends on a template-parameter (14.6.2)
3303  // shall be prefixed by the keyword typename to indicate that the
3304  // qualified-id denotes a type, forming an
3305  // elaborated-type-specifier (7.1.5.3).
3306  if (!LookupCtx && isDependentScopeSpecifier(SS)) {
3307  Diag(SS.getBeginLoc(), diag::err_typename_missing_template)
3308  << SS.getScopeRep() << TemplateII->getName();
3309  // Recover as if 'typename' were specified.
3310  // FIXME: This is not quite correct recovery as we don't transform SS
3311  // into the corresponding dependent form (and we don't diagnose missing
3312  // 'template' keywords within SS as a result).
3313  return ActOnTypenameType(nullptr, SourceLocation(), SS, TemplateKWLoc,
3314  TemplateD, TemplateII, TemplateIILoc, LAngleLoc,
3315  TemplateArgsIn, RAngleLoc);
3316  }
3317 
3318  // Per C++ [class.qual]p2, if the template-id was an injected-class-name,
3319  // it's not actually allowed to be used as a type in most cases. Because
3320  // we annotate it before we know whether it's valid, we have to check for
3321  // this case here.
3322  auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
3323  if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
3324  Diag(TemplateIILoc,
3325  TemplateKWLoc.isInvalid()
3326  ? diag::err_out_of_line_qualified_id_type_names_constructor
3327  : diag::ext_out_of_line_qualified_id_type_names_constructor)
3328  << TemplateII << 0 /*injected-class-name used as template name*/
3329  << 1 /*if any keyword was present, it was 'template'*/;
3330  }
3331  }
3332 
3333  TemplateName Template = TemplateD.get();
3334 
3335  // Translate the parser's template argument list in our AST format.
3336  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
3337  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
3338 
3339  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
3340  QualType T
3342  DTN->getQualifier(),
3343  DTN->getIdentifier(),
3344  TemplateArgs);
3345  // Build type-source information.
3346  TypeLocBuilder TLB;
3350  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
3351  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
3352  SpecTL.setTemplateNameLoc(TemplateIILoc);
3353  SpecTL.setLAngleLoc(LAngleLoc);
3354  SpecTL.setRAngleLoc(RAngleLoc);
3355  for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
3356  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
3357  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
3358  }
3359 
3360  QualType Result = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
3361  if (Result.isNull())
3362  return true;
3363 
3364  // Build type-source information.
3365  TypeLocBuilder TLB;
3367  = TLB.push<TemplateSpecializationTypeLoc>(Result);
3368  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
3369  SpecTL.setTemplateNameLoc(TemplateIILoc);
3370  SpecTL.setLAngleLoc(LAngleLoc);
3371  SpecTL.setRAngleLoc(RAngleLoc);
3372  for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
3373  SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
3374 
3375  // NOTE: avoid constructing an ElaboratedTypeLoc if this is a
3376  // constructor or destructor name (in such a case, the scope specifier
3377  // will be attached to the enclosing Decl or Expr node).
3378  if (SS.isNotEmpty() && !IsCtorOrDtorName) {
3379  // Create an elaborated-type-specifier containing the nested-name-specifier.
3380  Result = Context.getElaboratedType(ETK_None, SS.getScopeRep(), Result);
3381  ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
3383  ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
3384  }
3385 
3386  return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
3387 }
3388 
3390  TypeSpecifierType TagSpec,
3391  SourceLocation TagLoc,
3392  CXXScopeSpec &SS,
3393  SourceLocation TemplateKWLoc,
3394  TemplateTy TemplateD,
3395  SourceLocation TemplateLoc,
3396  SourceLocation LAngleLoc,
3397  ASTTemplateArgsPtr TemplateArgsIn,
3398  SourceLocation RAngleLoc) {
3399  TemplateName Template = TemplateD.get();
3400 
3401  // Translate the parser's template argument list in our AST format.
3402  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
3403  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
3404 
3405  // Determine the tag kind
3407  ElaboratedTypeKeyword Keyword
3409 
3410  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
3412  DTN->getQualifier(),
3413  DTN->getIdentifier(),
3414  TemplateArgs);
3415 
3416  // Build type-source information.
3417  TypeLocBuilder TLB;
3420  SpecTL.setElaboratedKeywordLoc(TagLoc);
3421  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
3422  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
3423  SpecTL.setTemplateNameLoc(TemplateLoc);
3424  SpecTL.setLAngleLoc(LAngleLoc);
3425  SpecTL.setRAngleLoc(RAngleLoc);
3426  for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
3427  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
3428  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
3429  }
3430 
3431  if (TypeAliasTemplateDecl *TAT =
3432  dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) {
3433  // C++0x [dcl.type.elab]p2:
3434  // If the identifier resolves to a typedef-name or the simple-template-id
3435  // resolves to an alias template specialization, the
3436  // elaborated-type-specifier is ill-formed.
3437  Diag(TemplateLoc, diag::err_tag_reference_non_tag)
3438  << TAT << NTK_TypeAliasTemplate << TagKind;
3439  Diag(TAT->getLocation(), diag::note_declared_at);
3440  }
3441 
3442  QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
3443  if (Result.isNull())
3444  return TypeResult(true);
3445 
3446  // Check the tag kind
3447  if (const RecordType *RT = Result->getAs<RecordType>()) {
3448  RecordDecl *D = RT->getDecl();
3449 
3451  assert(Id && "templated class must have an identifier");
3452 
3453  if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition,
3454  TagLoc, Id)) {
3455  Diag(TagLoc, diag::err_use_with_wrong_tag)
3456  << Result
3458  Diag(D->getLocation(), diag::note_previous_use);
3459  }
3460  }
3461 
3462  // Provide source-location information for the template specialization.
3463  TypeLocBuilder TLB;
3465  = TLB.push<TemplateSpecializationTypeLoc>(Result);
3466  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
3467  SpecTL.setTemplateNameLoc(TemplateLoc);
3468  SpecTL.setLAngleLoc(LAngleLoc);
3469  SpecTL.setRAngleLoc(RAngleLoc);
3470  for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
3471  SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
3472 
3473  // Construct an elaborated type containing the nested-name-specifier (if any)
3474  // and tag keyword.
3475  Result = Context.getElaboratedType(Keyword, SS.getScopeRep(), Result);
3476  ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
3477  ElabTL.setElaboratedKeywordLoc(TagLoc);
3478  ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
3479  return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
3480 }
3481 
3482 static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized,
3483  NamedDecl *PrevDecl,
3484  SourceLocation Loc,
3486 
3488 
3490  const TemplateArgument &Arg, unsigned Depth, unsigned Index) {
3491  switch (Arg.getKind()) {
3498  return false;
3499 
3500  case TemplateArgument::Type: {
3501  QualType Type = Arg.getAsType();
3502  const TemplateTypeParmType *TPT =
3504  return TPT && !Type.hasQualifiers() &&
3505  TPT->getDepth() == Depth && TPT->getIndex() == Index;
3506  }
3507 
3509  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg.getAsExpr());
3510  if (!DRE || !DRE->getDecl())
3511  return false;
3512  const NonTypeTemplateParmDecl *NTTP =
3513  dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
3514  return NTTP && NTTP->getDepth() == Depth && NTTP->getIndex() == Index;
3515  }
3516 
3518  const TemplateTemplateParmDecl *TTP =
3519  dyn_cast_or_null<TemplateTemplateParmDecl>(
3521  return TTP && TTP->getDepth() == Depth && TTP->getIndex() == Index;
3522  }
3523  llvm_unreachable("unexpected kind of template argument");
3524 }
3525 
3528  if (Params->size() != Args.size())
3529  return false;
3530 
3531  unsigned Depth = Params->getDepth();
3532 
3533  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
3534  TemplateArgument Arg = Args[I];
3535 
3536  // If the parameter is a pack expansion, the argument must be a pack
3537  // whose only element is a pack expansion.
3538  if (Params->getParam(I)->isParameterPack()) {
3539  if (Arg.getKind() != TemplateArgument::Pack || Arg.pack_size() != 1 ||
3540  !Arg.pack_begin()->isPackExpansion())
3541  return false;
3542  Arg = Arg.pack_begin()->getPackExpansionPattern();
3543  }
3544 
3545  if (!isTemplateArgumentTemplateParameter(Arg, Depth, I))
3546  return false;
3547  }
3548 
3549  return true;
3550 }
3551 
3552 /// Convert the parser's template argument list representation into our form.
3555  TemplateArgumentListInfo TemplateArgs(TemplateId.LAngleLoc,
3556  TemplateId.RAngleLoc);
3557  ASTTemplateArgsPtr TemplateArgsPtr(TemplateId.getTemplateArgs(),
3558  TemplateId.NumArgs);
3559  S.translateTemplateArguments(TemplateArgsPtr, TemplateArgs);
3560  return TemplateArgs;
3561 }
3562 
3563 template<typename PartialSpecDecl>
3564 static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial) {
3565  if (Partial->getDeclContext()->isDependentContext())
3566  return;
3567 
3568  // FIXME: Get the TDK from deduction in order to provide better diagnostics
3569  // for non-substitution-failure issues?
3570  TemplateDeductionInfo Info(Partial->getLocation());
3571  if (S.isMoreSpecializedThanPrimary(Partial, Info))
3572  return;
3573 
3574  auto *Template = Partial->getSpecializedTemplate();
3575  S.Diag(Partial->getLocation(),
3576  diag::ext_partial_spec_not_more_specialized_than_primary)
3577  << isa<VarTemplateDecl>(Template);
3578 
3579  if (Info.hasSFINAEDiagnostic()) {
3582  Info.takeSFINAEDiagnostic(Diag);
3583  SmallString<128> SFINAEArgString;
3584  Diag.second.EmitToString(S.getDiagnostics(), SFINAEArgString);
3585  S.Diag(Diag.first,
3586  diag::note_partial_spec_not_more_specialized_than_primary)
3587  << SFINAEArgString;
3588  }
3589 
3590  S.Diag(Template->getLocation(), diag::note_template_decl_here);
3591 }
3592 
3593 static void
3595  const llvm::SmallBitVector &DeducibleParams) {
3596  for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
3597  if (!DeducibleParams[I]) {
3598  NamedDecl *Param = TemplateParams->getParam(I);
3599  if (Param->getDeclName())
3600  S.Diag(Param->getLocation(), diag::note_non_deducible_parameter)
3601  << Param->getDeclName();
3602  else
3603  S.Diag(Param->getLocation(), diag::note_non_deducible_parameter)
3604  << "(anonymous)";
3605  }
3606  }
3607 }
3608 
3609 
3610 template<typename PartialSpecDecl>
3612  PartialSpecDecl *Partial) {
3613  // C++1z [temp.class.spec]p8: (DR1495)
3614  // - The specialization shall be more specialized than the primary
3615  // template (14.5.5.2).
3616  checkMoreSpecializedThanPrimary(S, Partial);
3617 
3618  // C++ [temp.class.spec]p8: (DR1315)
3619  // - Each template-parameter shall appear at least once in the
3620  // template-id outside a non-deduced context.
3621  // C++1z [temp.class.spec.match]p3 (P0127R2)
3622  // If the template arguments of a partial specialization cannot be
3623  // deduced because of the structure of its template-parameter-list
3624  // and the template-id, the program is ill-formed.
3625  auto *TemplateParams = Partial->getTemplateParameters();
3626  llvm::SmallBitVector DeducibleParams(TemplateParams->size());
3627  S.MarkUsedTemplateParameters(Partial->getTemplateArgs(), true,
3628  TemplateParams->getDepth(), DeducibleParams);
3629 
3630  if (!DeducibleParams.all()) {
3631  unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
3632  S.Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
3633  << isa<VarTemplatePartialSpecializationDecl>(Partial)
3634  << (NumNonDeducible > 1)
3635  << SourceRange(Partial->getLocation(),
3636  Partial->getTemplateArgsAsWritten()->RAngleLoc);
3637  noteNonDeducibleParameters(S, TemplateParams, DeducibleParams);
3638  }
3639 }
3640 
3643  checkTemplatePartialSpecialization(*this, Partial);
3644 }
3645 
3648  checkTemplatePartialSpecialization(*this, Partial);
3649 }
3650 
3652  // C++1z [temp.param]p11:
3653  // A template parameter of a deduction guide template that does not have a
3654  // default-argument shall be deducible from the parameter-type-list of the
3655  // deduction guide template.
3656  auto *TemplateParams = TD->getTemplateParameters();
3657  llvm::SmallBitVector DeducibleParams(TemplateParams->size());
3658  MarkDeducedTemplateParameters(TD, DeducibleParams);
3659  for (unsigned I = 0; I != TemplateParams->size(); ++I) {
3660  // A parameter pack is deducible (to an empty pack).
3661  auto *Param = TemplateParams->getParam(I);
3662  if (Param->isParameterPack() || hasVisibleDefaultArgument(Param))
3663  DeducibleParams[I] = true;
3664  }
3665 
3666  if (!DeducibleParams.all()) {
3667  unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
3668  Diag(TD->getLocation(), diag::err_deduction_guide_template_not_deducible)
3669  << (NumNonDeducible > 1);
3670  noteNonDeducibleParameters(*this, TemplateParams, DeducibleParams);
3671  }
3672 }
3673 
3675  Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc,
3676  TemplateParameterList *TemplateParams, StorageClass SC,
3677  bool IsPartialSpecialization) {
3678  // D must be variable template id.
3680  "Variable template specialization is declared with a template it.");
3681 
3682  TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
3683  TemplateArgumentListInfo TemplateArgs =
3684  makeTemplateArgumentListInfo(*this, *TemplateId);
3685  SourceLocation TemplateNameLoc = D.getIdentifierLoc();
3686  SourceLocation LAngleLoc = TemplateId->LAngleLoc;
3687  SourceLocation RAngleLoc = TemplateId->RAngleLoc;
3688 
3689  TemplateName Name = TemplateId->Template.get();
3690 
3691  // The template-id must name a variable template.
3692  VarTemplateDecl *VarTemplate =
3693  dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());
3694  if (!VarTemplate) {
3695  NamedDecl *FnTemplate;
3696  if (auto *OTS = Name.getAsOverloadedTemplate())
3697  FnTemplate = *OTS->begin();
3698  else
3699  FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());
3700  if (FnTemplate)
3701  return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template_but_method)
3702  << FnTemplate->getDeclName();
3703  return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template)
3704  << IsPartialSpecialization;
3705  }
3706 
3707  // Check for unexpanded parameter packs in any of the template arguments.
3708  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
3709  if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
3710  UPPC_PartialSpecialization))
3711  return true;
3712 
3713  // Check that the template argument list is well-formed for this
3714  // template.
3716  if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
3717  false, Converted))
3718  return true;
3719 
3720  // Find the variable template (partial) specialization declaration that
3721  // corresponds to these arguments.
3722  if (IsPartialSpecialization) {
3723  if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, VarTemplate,
3724  TemplateArgs.size(), Converted))
3725  return true;
3726 
3727  // FIXME: Move these checks to CheckTemplatePartialSpecializationArgs so we
3728  // also do them during instantiation.
3729  bool InstantiationDependent;
3730  if (!Name.isDependent() &&
3732  TemplateArgs.arguments(),
3733  InstantiationDependent)) {
3734  Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
3735  << VarTemplate->getDeclName();
3736  IsPartialSpecialization = false;
3737  }
3738 
3740  Converted)) {
3741  // C++ [temp.class.spec]p9b3:
3742  //
3743  // -- The argument list of the specialization shall not be identical
3744  // to the implicit argument list of the primary template.
3745  Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
3746  << /*variable template*/ 1
3747  << /*is definition*/(SC != SC_Extern && !CurContext->isRecord())
3748  << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
3749  // FIXME: Recover from this by treating the declaration as a redeclaration
3750  // of the primary template.
3751  return true;
3752  }
3753  }
3754 
3755  void *InsertPos = nullptr;
3756  VarTemplateSpecializationDecl *PrevDecl = nullptr;
3757 
3758  if (IsPartialSpecialization)
3759  // FIXME: Template parameter list matters too
3760  PrevDecl = VarTemplate->findPartialSpecialization(Converted, InsertPos);
3761  else
3762  PrevDecl = VarTemplate->findSpecialization(Converted, InsertPos);
3763 
3764  VarTemplateSpecializationDecl *Specialization = nullptr;
3765 
3766  // Check whether we can declare a variable template specialization in
3767  // the current scope.
3768  if (CheckTemplateSpecializationScope(*this, VarTemplate, PrevDecl,
3769  TemplateNameLoc,
3770  IsPartialSpecialization))
3771  return true;
3772 
3773  if (PrevDecl && PrevDecl->getSpecializationKind() == TSK_Undeclared) {
3774  // Since the only prior variable template specialization with these
3775  // arguments was referenced but not declared, reuse that
3776  // declaration node as our own, updating its source location and
3777  // the list of outer template parameters to reflect our new declaration.
3778  Specialization = PrevDecl;
3779  Specialization->setLocation(TemplateNameLoc);
3780  PrevDecl = nullptr;
3781  } else if (IsPartialSpecialization) {
3782  // Create a new class template partial specialization declaration node.
3784  cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
3787  Context, VarTemplate->getDeclContext(), TemplateKWLoc,
3788  TemplateNameLoc, TemplateParams, VarTemplate, DI->getType(), DI, SC,
3789  Converted, TemplateArgs);
3790 
3791  if (!PrevPartial)
3792  VarTemplate->AddPartialSpecialization(Partial, InsertPos);
3793  Specialization = Partial;
3794 
3795  // If we are providing an explicit specialization of a member variable
3796  // template specialization, make a note of that.
3797  if (PrevPartial && PrevPartial->getInstantiatedFromMember())
3798  PrevPartial->setMemberSpecialization();
3799 
3800  CheckTemplatePartialSpecialization(Partial);
3801  } else {
3802  // Create a new class template specialization declaration node for
3803  // this explicit specialization or friend declaration.
3804  Specialization = VarTemplateSpecializationDecl::Create(
3805  Context, VarTemplate->getDeclContext(), TemplateKWLoc, TemplateNameLoc,
3806  VarTemplate, DI->getType(), DI, SC, Converted);
3807  Specialization->setTemplateArgsInfo(TemplateArgs);
3808 
3809  if (!PrevDecl)
3810  VarTemplate->AddSpecialization(Specialization, InsertPos);
3811  }
3812 
3813  // C++ [temp.expl.spec]p6:
3814  // If a template, a member template or the member of a class template is
3815  // explicitly specialized then that specialization shall be declared
3816  // before the first use of that specialization that would cause an implicit
3817  // instantiation to take place, in every translation unit in which such a
3818  // use occurs; no diagnostic is required.
3819  if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
3820  bool Okay = false;
3821  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
3822  // Is there any previous explicit specialization declaration?
3824  Okay = true;
3825  break;
3826  }
3827  }
3828 
3829  if (!Okay) {
3830  SourceRange Range(TemplateNameLoc, RAngleLoc);
3831  Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
3832  << Name << Range;
3833 
3834  Diag(PrevDecl->getPointOfInstantiation(),
3835  diag::note_instantiation_required_here)
3836  << (PrevDecl->getTemplateSpecializationKind() !=
3838  return true;
3839  }
3840  }
3841 
3842  Specialization->setTemplateKeywordLoc(TemplateKWLoc);
3843  Specialization->setLexicalDeclContext(CurContext);
3844 
3845  // Add the specialization into its lexical context, so that it can
3846  // be seen when iterating through the list of declarations in that
3847  // context. However, specializations are not found by name lookup.
3848  CurContext->addDecl(Specialization);
3849 
3850  // Note that this is an explicit specialization.
3852 
3853  if (PrevDecl) {
3854  // Check that this isn't a redefinition of this specialization,
3855  // merging with previous declarations.
3856  LookupResult PrevSpec(*this, GetNameForDeclarator(D), LookupOrdinaryName,
3857  forRedeclarationInCurContext());
3858  PrevSpec.addDecl(PrevDecl);
3859  D.setRedeclaration(CheckVariableDeclaration(Specialization, PrevSpec));
3860  } else if (Specialization->isStaticDataMember() &&
3861  Specialization->isOutOfLine()) {
3862  Specialization->setAccess(VarTemplate->getAccess());
3863  }
3864 
3865  // Link instantiations of static data members back to the template from
3866  // which they were instantiated.
3867  if (Specialization->isStaticDataMember())
3868  Specialization->setInstantiationOfStaticDataMember(
3869  VarTemplate->getTemplatedDecl(),
3870  Specialization->getSpecializationKind());
3871 
3872  return Specialization;
3873 }
3874 
3875 namespace {
3876 /// A partial specialization whose template arguments have matched
3877 /// a given template-id.
3878 struct PartialSpecMatchResult {
3880  TemplateArgumentList *Args;
3881 };
3882 } // end anonymous namespace
3883 
3884 DeclResult
3886  SourceLocation TemplateNameLoc,
3887  const TemplateArgumentListInfo &TemplateArgs) {
3888  assert(Template && "A variable template id without template?");
3889 
3890  // Check that the template argument list is well-formed for this template.
3892  if (CheckTemplateArgumentList(
3893  Template, TemplateNameLoc,
3894  const_cast<TemplateArgumentListInfo &>(TemplateArgs), false,
3895  Converted))
3896  return true;
3897 
3898  // Find the variable template specialization declaration that
3899  // corresponds to these arguments.
3900  void *InsertPos = nullptr;
3901  if (VarTemplateSpecializationDecl *Spec = Template->findSpecialization(
3902  Converted, InsertPos)) {
3903  checkSpecializationVisibility(TemplateNameLoc, Spec);
3904  // If we already have a variable template specialization, return it.
3905  return Spec;
3906  }
3907 
3908  // This is the first time we have referenced this variable template
3909  // specialization. Create the canonical declaration and add it to
3910  // the set of specializations, based on the closest partial specialization
3911  // that it represents. That is,
3912  VarDecl *InstantiationPattern = Template->getTemplatedDecl();
3914  Converted);
3915  TemplateArgumentList *InstantiationArgs = &TemplateArgList;
3916  bool AmbiguousPartialSpec = false;
3917  typedef PartialSpecMatchResult MatchResult;
3919  SourceLocation PointOfInstantiation = TemplateNameLoc;
3920  TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation,
3921  /*ForTakingAddress=*/false);
3922 
3923  // 1. Attempt to find the closest partial specialization that this
3924  // specializes, if any.
3925  // If any of the template arguments is dependent, then this is probably
3926  // a placeholder for an incomplete declarative context; which must be
3927  // complete by instantiation time. Thus, do not search through the partial
3928  // specializations yet.
3929  // TODO: Unify with InstantiateClassTemplateSpecialization()?
3930  // Perhaps better after unification of DeduceTemplateArguments() and
3931  // getMoreSpecializedPartialSpecialization().
3932  bool InstantiationDependent = false;
3934  TemplateArgs, InstantiationDependent)) {
3935 
3937  Template->getPartialSpecializations(PartialSpecs);
3938 
3939  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
3940  VarTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
3941  TemplateDeductionInfo Info(FailedCandidates.getLocation());
3942 
3943  if (TemplateDeductionResult Result =
3944  DeduceTemplateArguments(Partial, TemplateArgList, Info)) {
3945  // Store the failed-deduction information for use in diagnostics, later.
3946  // TODO: Actually use the failed-deduction info?
3947  FailedCandidates.addCandidate().set(
3948  DeclAccessPair::make(Template, AS_public), Partial,
3949  MakeDeductionFailureInfo(Context, Result, Info));
3950  (void)Result;
3951  } else {
3952  Matched.push_back(PartialSpecMatchResult());
3953  Matched.back().Partial = Partial;
3954  Matched.back().Args = Info.take();
3955  }
3956  }
3957 
3958  if (Matched.size() >= 1) {
3959  SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
3960  if (Matched.size() == 1) {
3961  // -- If exactly one matching specialization is found, the
3962  // instantiation is generated from that specialization.
3963  // We don't need to do anything for this.
3964  } else {
3965  // -- If more than one matching specialization is found, the
3966  // partial order rules (14.5.4.2) are used to determine
3967  // whether one of the specializations is more specialized
3968  // than the others. If none of the specializations is more
3969  // specialized than all of the other matching
3970  // specializations, then the use of the variable template is
3971  // ambiguous and the program is ill-formed.
3972  for (SmallVector<MatchResult, 4>::iterator P = Best + 1,
3973  PEnd = Matched.end();
3974  P != PEnd; ++P) {
3975  if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
3976  PointOfInstantiation) ==
3977  P->Partial)
3978  Best = P;
3979  }
3980 
3981  // Determine if the best partial specialization is more specialized than
3982  // the others.
3983  for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
3984  PEnd = Matched.end();
3985  P != PEnd; ++P) {
3986  if (P != Best && getMoreSpecializedPartialSpecialization(
3987  P->Partial, Best->Partial,
3988  PointOfInstantiation) != Best->Partial) {
3989  AmbiguousPartialSpec = true;
3990  break;
3991  }
3992  }
3993  }
3994 
3995  // Instantiate using the best variable template partial specialization.
3996  InstantiationPattern = Best->Partial;
3997  InstantiationArgs = Best->Args;
3998  } else {
3999  // -- If no match is found, the instantiation is generated
4000  // from the primary template.
4001  // InstantiationPattern = Template->getTemplatedDecl();
4002  }
4003  }
4004 
4005  // 2. Create the canonical declaration.
4006  // Note that we do not instantiate a definition until we see an odr-use
4007  // in DoMarkVarDeclReferenced().
4008  // FIXME: LateAttrs et al.?
4009  VarTemplateSpecializationDecl *Decl = BuildVarTemplateInstantiation(
4010  Template, InstantiationPattern, *InstantiationArgs, TemplateArgs,
4011  Converted, TemplateNameLoc, InsertPos /*, LateAttrs, StartingScope*/);
4012  if (!Decl)
4013  return true;
4014 
4015  if (AmbiguousPartialSpec) {
4016  // Partial ordering did not produce a clear winner. Complain.
4017  Decl->setInvalidDecl();
4018  Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
4019  << Decl;
4020 
4021  // Print the matching partial specializations.
4022  for (MatchResult P : Matched)
4023  Diag(P.Partial->getLocation(), diag::note_partial_spec_match)
4024  << getTemplateArgumentBindingsText(P.Partial->getTemplateParameters(),
4025  *P.Args);
4026  return true;
4027  }
4028 
4030  dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
4031  Decl->setInstantiationOf(D, InstantiationArgs);
4032 
4033  checkSpecializationVisibility(TemplateNameLoc, Decl);
4034 
4035  assert(Decl && "No variable template specialization?");
4036  return Decl;
4037 }
4038 
4039 ExprResult
4041  const DeclarationNameInfo &NameInfo,
4042  VarTemplateDecl *Template, SourceLocation TemplateLoc,
4043  const TemplateArgumentListInfo *TemplateArgs) {
4044 
4045  DeclResult Decl = CheckVarTemplateId(Template, TemplateLoc, NameInfo.getLoc(),
4046  *TemplateArgs);
4047  if (Decl.isInvalid())
4048  return ExprError();
4049 
4050  VarDecl *Var = cast<VarDecl>(Decl.get());
4051  if (!Var->getTemplateSpecializationKind())
4053  NameInfo.getLoc());
4054 
4055  // Build an ordinary singleton decl ref.
4056  return BuildDeclarationNameExpr(SS, NameInfo, Var,
4057  /*FoundD=*/nullptr, TemplateArgs);
4058 }
4059 
4061  SourceLocation Loc) {
4062  Diag(Loc, diag::err_template_missing_args)
4063  << (int)getTemplateNameKindForDiagnostics(Name) << Name;
4064  if (TemplateDecl *TD = Name.getAsTemplateDecl()) {
4065  Diag(TD->getLocation(), diag::note_template_decl_here)
4066  << TD->getTemplateParameters()->getSourceRange();
4067  }
4068 }
4069 
4071  SourceLocation TemplateKWLoc,
4072  LookupResult &R,
4073  bool RequiresADL,
4074  const TemplateArgumentListInfo *TemplateArgs) {
4075  // FIXME: Can we do any checking at this point? I guess we could check the
4076  // template arguments that we have against the template name, if the template
4077  // name refers to a single template. That's not a terribly common case,
4078  // though.
4079  // foo<int> could identify a single function unambiguously
4080  // This approach does NOT work, since f<int>(1);
4081  // gets resolved prior to resorting to overload resolution
4082  // i.e., template<class T> void f(double);
4083  // vs template<class T, class U> void f(U);
4084 
4085  // These should be filtered out by our callers.
4086  assert(!R.empty() && "empty lookup results when building templateid");
4087  assert(!R.isAmbiguous() && "ambiguous lookup when building templateid");
4088 
4089  // Non-function templates require a template argument list.
4090  if (auto *TD = R.getAsSingle<TemplateDecl>()) {
4091  if (!TemplateArgs && !isa<FunctionTemplateDecl>(TD)) {
4092  diagnoseMissingTemplateArguments(TemplateName(TD), R.getNameLoc());
4093  return ExprError();
4094  }
4095  }
4096 
4097  auto AnyDependentArguments = [&]() -> bool {
4098  bool InstantiationDependent;
4099  return TemplateArgs &&
4101  *TemplateArgs, InstantiationDependent);
4102  };
4103 
4104  // In C++1y, check variable template ids.
4105  if (R.getAsSingle<VarTemplateDecl>() && !AnyDependentArguments()) {
4106  return CheckVarTemplateId(SS, R.getLookupNameInfo(),
4108  TemplateKWLoc, TemplateArgs);
4109  }
4110 
4111  // We don't want lookup warnings at this point.
4112  R.suppressDiagnostics();
4113 
4116  SS.getWithLocInContext(Context),
4117  TemplateKWLoc,
4118  R.getLookupNameInfo(),
4119  RequiresADL, TemplateArgs,
4120  R.begin(), R.end());
4121 
4122  return ULE;
4123 }
4124 
4125 // We actually only call this from template instantiation.
4126 ExprResult
4128  SourceLocation TemplateKWLoc,
4129  const DeclarationNameInfo &NameInfo,
4130  const TemplateArgumentListInfo *TemplateArgs) {
4131 
4132  assert(TemplateArgs || TemplateKWLoc.isValid());
4133  DeclContext *DC;
4134  if (!(DC = computeDeclContext(SS, false)) ||
4135  DC->isDependentContext() ||
4136  RequireCompleteDeclContext(SS, DC))
4137  return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
4138 
4139  bool MemberOfUnknownSpecialization;
4140  LookupResult R(*this, NameInfo, LookupOrdinaryName);
4141  if (LookupTemplateName(R, (Scope *)nullptr, SS, QualType(),
4142  /*Entering*/false, MemberOfUnknownSpecialization,
4143  TemplateKWLoc))
4144  return ExprError();
4145 
4146  if (R.isAmbiguous())
4147  return ExprError();
4148 
4149  if (R.empty()) {
4150  Diag(NameInfo.getLoc(), diag::err_no_member)
4151  << NameInfo.getName() << DC << SS.getRange();
4152  return ExprError();
4153  }
4154 
4155  if (ClassTemplateDecl *Temp = R.getAsSingle<ClassTemplateDecl>()) {
4156  Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_class_template)
4157  << SS.getScopeRep()
4158  << NameInfo.getName().getAsString() << SS.getRange();
4159  Diag(Temp->getLocation(), diag::note_referenced_class_template);
4160  return ExprError();
4161  }
4162 
4163  return BuildTemplateIdExpr(SS, TemplateKWLoc, R, /*ADL*/ false, TemplateArgs);
4164 }
4165 
4166 /// Form a dependent template name.
4167 ///
4168 /// This action forms a dependent template name given the template
4169 /// name and its (presumably dependent) scope specifier. For
4170 /// example, given "MetaFun::template apply", the scope specifier \p
4171 /// SS will be "MetaFun::", \p TemplateKWLoc contains the location
4172 /// of the "template" keyword, and "apply" is the \p Name.
4174  CXXScopeSpec &SS,
4175  SourceLocation TemplateKWLoc,
4176  const UnqualifiedId &Name,
4177  ParsedType ObjectType,
4178  bool EnteringContext,
4179  TemplateTy &Result,
4180  bool AllowInjectedClassName) {
4181  if (TemplateKWLoc.isValid() && S && !S->getTemplateParamParent())
4182  Diag(TemplateKWLoc,
4183  getLangOpts().CPlusPlus11 ?
4184  diag::warn_cxx98_compat_template_outside_of_template :
4185  diag::ext_template_outside_of_template)
4186  << FixItHint::CreateRemoval(TemplateKWLoc);
4187 
4188  DeclContext *LookupCtx = nullptr;
4189  if (SS.isSet())
4190  LookupCtx = computeDeclContext(SS, EnteringContext);
4191  if (!LookupCtx && ObjectType)
4192  LookupCtx = computeDeclContext(ObjectType.get());
4193  if (LookupCtx) {
4194  // C++0x [temp.names]p5:
4195  // If a name prefixed by the keyword template is not the name of
4196  // a template, the program is ill-formed. [Note: the keyword
4197  // template may not be applied to non-template members of class
4198  // templates. -end note ] [ Note: as is the case with the
4199  // typename prefix, the template prefix is allowed in cases
4200  // where it is not strictly necessary; i.e., when the
4201  // nested-name-specifier or the expression on the left of the ->
4202  // or . is not dependent on a template-parameter, or the use
4203  // does not appear in the scope of a template. -end note]
4204  //
4205  // Note: C++03 was more strict here, because it banned the use of
4206  // the "template" keyword prior to a template-name that was not a
4207  // dependent name. C++ DR468 relaxed this requirement (the
4208  // "template" keyword is now permitted). We follow the C++0x
4209  // rules, even in C++03 mode with a warning, retroactively applying the DR.
4210  bool MemberOfUnknownSpecialization;
4211  TemplateNameKind TNK = isTemplateName(S, SS, TemplateKWLoc.isValid(), Name,
4212  ObjectType, EnteringContext, Result,
4213  MemberOfUnknownSpecialization);
4214  if (TNK == TNK_Non_template && MemberOfUnknownSpecialization) {
4215  // This is a dependent template. Handle it below.
4216  } else if (TNK == TNK_Non_template) {
4217  // Do the lookup again to determine if this is a "nothing found" case or
4218  // a "not a template" case. FIXME: Refactor isTemplateName so we don't
4219  // need to do this.
4220  DeclarationNameInfo DNI = GetNameFromUnqualifiedId(Name);
4221  LookupResult R(*this, DNI.getName(), Name.getLocStart(),
4222  LookupOrdinaryName);
4223  bool MOUS;
4224  if (!LookupTemplateName(R, S, SS, ObjectType.get(), EnteringContext,
4225  MOUS, TemplateKWLoc))
4226  Diag(Name.getLocStart(), diag::err_no_member)
4227  << DNI.getName() << LookupCtx << SS.getRange();
4228  return TNK_Non_template;
4229  } else {
4230  // We found something; return it.
4231  auto *LookupRD = dyn_cast<CXXRecordDecl>(LookupCtx);
4232  if (!AllowInjectedClassName && SS.isSet() && LookupRD &&
4234  Name.Identifier && LookupRD->getIdentifier() == Name.Identifier) {
4235  // C++14 [class.qual]p2:
4236  // In a lookup in which function names are not ignored and the
4237  // nested-name-specifier nominates a class C, if the name specified
4238  // [...] is the injected-class-name of C, [...] the name is instead
4239  // considered to name the constructor
4240  //
4241  // We don't get here if naming the constructor would be valid, so we
4242  // just reject immediately and recover by treating the
4243  // injected-class-name as naming the template.
4244  Diag(Name.getLocStart(),
4245  diag::ext_out_of_line_qualified_id_type_names_constructor)
4246  << Name.Identifier << 0 /*injected-class-name used as template name*/
4247  << 1 /*'template' keyword was used*/;
4248  }
4249  return TNK;
4250  }
4251  }
4252 
4253  NestedNameSpecifier *Qualifier = SS.getScopeRep();
4254 
4255  switch (Name.getKind()) {
4257  Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
4258  Name.Identifier));
4260 
4262  Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
4264  return TNK_Function_template;
4265 
4267  llvm_unreachable("literal operator id cannot have a dependent scope");
4268 
4269  default:
4270  break;
4271  }
4272 
4273  Diag(Name.getLocStart(),
4274  diag::err_template_kw_refers_to_non_template)
4275  << GetNameFromUnqualifiedId(Name).getName()
4276  << Name.getSourceRange()
4277  << TemplateKWLoc;
4278  return TNK_Non_template;
4279 }
4280 
4282  TemplateArgumentLoc &AL,
4283  SmallVectorImpl<TemplateArgument> &Converted) {
4284  const TemplateArgument &Arg = AL.getArgument();
4285  QualType ArgType;
4286  TypeSourceInfo *TSI = nullptr;
4287 
4288  // Check template type parameter.
4289  switch(Arg.getKind()) {
4291  // C++ [temp.arg.type]p1:
4292  // A template-argument for a template-parameter which is a
4293  // type shall be a type-id.
4294  ArgType = Arg.getAsType();
4295  TSI = AL.getTypeSourceInfo();
4296  break;
4299  // We have a template type parameter but the template argument
4300  // is a template without any arguments.
4301  SourceRange SR = AL.getSourceRange();
4303  diagnoseMissingTemplateArguments(Name, SR.getEnd());
4304  return true;
4305  }
4307  // We have a template type parameter but the template argument is an
4308  // expression; see if maybe it is missing the "typename" keyword.
4309  CXXScopeSpec SS;
4310  DeclarationNameInfo NameInfo;
4311 
4312  if (DeclRefExpr *ArgExpr = dyn_cast<DeclRefExpr>(Arg.getAsExpr())) {
4313  SS.Adopt(ArgExpr->getQualifierLoc());
4314  NameInfo = ArgExpr->getNameInfo();
4315  } else if (DependentScopeDeclRefExpr *ArgExpr =
4316  dyn_cast<DependentScopeDeclRefExpr>(Arg.getAsExpr())) {
4317  SS.Adopt(ArgExpr->getQualifierLoc());
4318  NameInfo = ArgExpr->getNameInfo();
4319  } else if (CXXDependentScopeMemberExpr *ArgExpr =
4320  dyn_cast<CXXDependentScopeMemberExpr>(Arg.getAsExpr())) {
4321  if (ArgExpr->isImplicitAccess()) {
4322  SS.Adopt(ArgExpr->getQualifierLoc());
4323  NameInfo = ArgExpr->getMemberNameInfo();
4324  }
4325  }
4326 
4327  if (auto *II = NameInfo.getName().getAsIdentifierInfo()) {
4328  LookupResult Result(*this, NameInfo, LookupOrdinaryName);
4329  LookupParsedName(Result, CurScope, &SS);
4330 
4331  if (Result.getAsSingle<TypeDecl>() ||
4332  Result.getResultKind() ==
4334  // Suggest that the user add 'typename' before the NNS.
4335  SourceLocation Loc = AL.getSourceRange().getBegin();
4336  Diag(Loc, getLangOpts().MSVCCompat
4337  ? diag::ext_ms_template_type_arg_missing_typename
4338  : diag::err_template_arg_must_be_type_suggest)
4339  << FixItHint::CreateInsertion(Loc, "typename ");
4340  Diag(Param->getLocation(), diag::note_template_param_here);
4341 
4342  // Recover by synthesizing a type using the location information that we
4343  // already have.
4344  ArgType =
4345  Context.getDependentNameType(ETK_Typename, SS.getScopeRep(), II);
4346  TypeLocBuilder TLB;
4347  DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(ArgType);
4348  TL.setElaboratedKeywordLoc(SourceLocation(/*synthesized*/));
4349  TL.setQualifierLoc(SS.getWithLocInContext(Context));
4350  TL.setNameLoc(NameInfo.getLoc());
4351  TSI = TLB.getTypeSourceInfo(Context, ArgType);
4352 
4353  // Overwrite our input TemplateArgumentLoc so that we can recover
4354  // properly.
4355  AL = TemplateArgumentLoc(TemplateArgument(ArgType),
4357 
4358  break;
4359  }
4360  }
4361  // fallthrough
4362  LLVM_FALLTHROUGH;
4363  }
4364  default: {
4365  // We have a template type parameter but the template argument
4366  // is not a type.
4367  SourceRange SR = AL.getSourceRange();
4368  Diag(SR.getBegin(), diag::err_template_arg_must_be_type) << SR;
4369  Diag(Param->getLocation(), diag::note_template_param_here);
4370 
4371  return true;
4372  }
4373  }
4374 
4375  if (CheckTemplateArgument(Param, TSI))
4376  return true;
4377 
4378  // Add the converted template type argument.
4379  ArgType = Context.getCanonicalType(ArgType);
4380 
4381  // Objective-C ARC:
4382  // If an explicitly-specified template argument type is a lifetime type
4383  // with no lifetime qualifier, the __strong lifetime qualifier is inferred.
4384  if (getLangOpts().ObjCAutoRefCount &&
4385  ArgType->isObjCLifetimeType() &&
4386  !ArgType.getObjCLifetime()) {
4387  Qualifiers Qs;
4389  ArgType = Context.getQualifiedType(ArgType, Qs);
4390  }
4391 
4392  Converted.push_back(TemplateArgument(ArgType));
4393  return false;
4394 }
4395 
4396 /// Substitute template arguments into the default template argument for
4397 /// the given template type parameter.
4398 ///
4399 /// \param SemaRef the semantic analysis object for which we are performing
4400 /// the substitution.
4401 ///
4402 /// \param Template the template that we are synthesizing template arguments
4403 /// for.
4404 ///
4405 /// \param TemplateLoc the location of the template name that started the
4406 /// template-id we are checking.
4407 ///
4408 /// \param RAngleLoc the location of the right angle bracket ('>') that
4409 /// terminates the template-id.
4410 ///
4411 /// \param Param the template template parameter whose default we are
4412 /// substituting into.
4413 ///
4414 /// \param Converted the list of template arguments provided for template
4415 /// parameters that precede \p Param in the template parameter list.
4416 /// \returns the substituted template argument, or NULL if an error occurred.
4417 static TypeSourceInfo *
4419  TemplateDecl *Template,
4420  SourceLocation TemplateLoc,
4421  SourceLocation RAngleLoc,
4422  TemplateTypeParmDecl *Param,
4423  SmallVectorImpl<TemplateArgument> &Converted) {
4424  TypeSourceInfo *ArgType = Param->getDefaultArgumentInfo();
4425 
4426  // If the argument type is dependent, instantiate it now based
4427  // on the previously-computed template arguments.
4428  if (ArgType->getType()->isDependentType()) {
4429  Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
4430  Param, Template, Converted,
4431  SourceRange(TemplateLoc, RAngleLoc));
4432  if (Inst.isInvalid())
4433  return nullptr;
4434 
4435  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
4436 
4437  // Only substitute for the innermost template argument list.
4438  MultiLevelTemplateArgumentList TemplateArgLists;
4439  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
4440  for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
4441  TemplateArgLists.addOuterTemplateArguments(None);
4442 
4443  Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
4444  ArgType =
4445  SemaRef.SubstType(ArgType, TemplateArgLists,
4446  Param->getDefaultArgumentLoc(), Param->getDeclName());
4447  }
4448 
4449  return ArgType;
4450 }
4451 
4452 /// Substitute template arguments into the default template argument for
4453 /// the given non-type template parameter.
4454 ///
4455 /// \param SemaRef the semantic analysis object for which we are performing
4456 /// the substitution.
4457 ///
4458 /// \param Template the template that we are synthesizing template arguments
4459 /// for.
4460 ///
4461 /// \param TemplateLoc the location of the template name that started the
4462 /// template-id we are checking.
4463 ///
4464 /// \param RAngleLoc the location of the right angle bracket ('>') that
4465 /// terminates the template-id.
4466 ///
4467 /// \param Param the non-type template parameter whose default we are
4468 /// substituting into.
4469 ///
4470 /// \param Converted the list of template arguments provided for template
4471 /// parameters that precede \p Param in the template parameter list.
4472 ///
4473 /// \returns the substituted template argument, or NULL if an error occurred.
4474 static ExprResult
4476  TemplateDecl *Template,
4477  SourceLocation TemplateLoc,
4478  SourceLocation RAngleLoc,
4479  NonTypeTemplateParmDecl *Param,
4480  SmallVectorImpl<TemplateArgument> &Converted) {
4481  Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
4482  Param, Template, Converted,
4483  SourceRange(TemplateLoc, RAngleLoc));
4484  if (Inst.isInvalid())
4485  return ExprError();
4486 
4487  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
4488 
4489  // Only substitute for the innermost template argument list.
4490  MultiLevelTemplateArgumentList TemplateArgLists;
4491  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
4492  for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
4493  TemplateArgLists.addOuterTemplateArguments(None);
4494 
4495  EnterExpressionEvaluationContext ConstantEvaluated(
4497  return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists);
4498 }
4499 
4500 /// Substitute template arguments into the default template argument for
4501 /// the given template template parameter.
4502 ///
4503 /// \param SemaRef the semantic analysis object for which we are performing
4504 /// the substitution.
4505 ///
4506 /// \param Template the template that we are synthesizing template arguments
4507 /// for.
4508 ///
4509 /// \param TemplateLoc the location of the template name that started the
4510 /// template-id we are checking.
4511 ///
4512 /// \param RAngleLoc the location of the right angle bracket ('>') that
4513 /// terminates the template-id.
4514 ///
4515 /// \param Param the template template parameter whose default we are
4516 /// substituting into.
4517 ///
4518 /// \param Converted the list of template arguments provided for template
4519 /// parameters that precede \p Param in the template parameter list.
4520 ///
4521 /// \param QualifierLoc Will be set to the nested-name-specifier (with
4522 /// source-location information) that precedes the template name.
4523 ///
4524 /// \returns the substituted template argument, or NULL if an error occurred.
4525 static TemplateName
4527  TemplateDecl *Template,
4528  SourceLocation TemplateLoc,
4529  SourceLocation RAngleLoc,
4530  TemplateTemplateParmDecl *Param,
4532  NestedNameSpecifierLoc &QualifierLoc) {
4534  SemaRef, TemplateLoc, TemplateParameter(Param), Template, Converted,
4535  SourceRange(TemplateLoc, RAngleLoc));
4536  if (Inst.isInvalid())
4537  return TemplateName();
4538 
4539  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
4540 
4541  // Only substitute for the innermost template argument list.
4542  MultiLevelTemplateArgumentList TemplateArgLists;
4543  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
4544  for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
4545  TemplateArgLists.addOuterTemplateArguments(None);
4546 
4547  Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
4548  // Substitute into the nested-name-specifier first,
4549  QualifierLoc = Param->getDefaultArgument().getTemplateQualifierLoc();
4550  if (QualifierLoc) {
4551  QualifierLoc =
4552  SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgLists);
4553  if (!QualifierLoc)
4554  return TemplateName();
4555  }
4556 
4557  return SemaRef.SubstTemplateName(
4558  QualifierLoc,
4561  TemplateArgLists);
4562 }
4563 
4564 /// If the given template parameter has a default template
4565 /// argument, substitute into that default template argument and
4566 /// return the corresponding template argument.
4569  SourceLocation TemplateLoc,
4570  SourceLocation RAngleLoc,
4571  Decl *Param,
4573  &Converted,
4574  bool &HasDefaultArg) {
4575  HasDefaultArg = false;
4576 
4577  if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) {
4578  if (!hasVisibleDefaultArgument(TypeParm))
4579  return TemplateArgumentLoc();
4580 
4581  HasDefaultArg = true;
4582  TypeSourceInfo *DI = SubstDefaultTemplateArgument(*this, Template,
4583  TemplateLoc,
4584  RAngleLoc,
4585  TypeParm,
4586  Converted);
4587  if (DI)
4588  return TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
4589 
4590  return TemplateArgumentLoc();
4591  }
4592 
4593  if (NonTypeTemplateParmDecl *NonTypeParm
4594  = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4595  if (!hasVisibleDefaultArgument(NonTypeParm))
4596  return TemplateArgumentLoc();
4597 
4598  HasDefaultArg = true;
4599  ExprResult Arg = SubstDefaultTemplateArgument(*this, Template,
4600  TemplateLoc,
4601  RAngleLoc,
4602  NonTypeParm,
4603  Converted);
4604  if (Arg.isInvalid())
4605  return TemplateArgumentLoc();
4606 
4607  Expr *ArgE = Arg.getAs<Expr>();
4608  return TemplateArgumentLoc(TemplateArgument(ArgE), ArgE);
4609  }
4610 
4611  TemplateTemplateParmDecl *TempTempParm
4612  = cast<TemplateTemplateParmDecl>(Param);
4613  if (!hasVisibleDefaultArgument(TempTempParm))
4614  return TemplateArgumentLoc();
4615 
4616  HasDefaultArg = true;
4617  NestedNameSpecifierLoc QualifierLoc;
4618  TemplateName TName = SubstDefaultTemplateArgument(*this, Template,
4619  TemplateLoc,
4620  RAngleLoc,
4621  TempTempParm,
4622  Converted,
4623  QualifierLoc);
4624  if (TName.isNull())
4625  return TemplateArgumentLoc();
4626 
4627  return TemplateArgumentLoc(TemplateArgument(TName),
4628  TempTempParm->getDefaultArgument().getTemplateQualifierLoc(),
4629  TempTempParm->getDefaultArgument().getTemplateNameLoc());
4630 }
4631 
4632 /// Convert a template-argument that we parsed as a type into a template, if
4633 /// possible. C++ permits injected-class-names to perform dual service as
4634 /// template template arguments and as template type arguments.
4636  // Extract and step over any surrounding nested-name-specifier.
4637  NestedNameSpecifierLoc QualLoc;
4638  if (auto ETLoc = TLoc.getAs<ElaboratedTypeLoc>()) {
4639  if (ETLoc.getTypePtr()->getKeyword() != ETK_None)
4640  return TemplateArgumentLoc();
4641 
4642  QualLoc = ETLoc.getQualifierLoc();
4643  TLoc = ETLoc.getNamedTypeLoc();
4644  }
4645 
4646  // If this type was written as an injected-class-name, it can be used as a
4647  // template template argument.
4648  if (auto InjLoc = TLoc.getAs<InjectedClassNameTypeLoc>())
4649  return TemplateArgumentLoc(InjLoc.getTypePtr()->getTemplateName(),
4650  QualLoc, InjLoc.getNameLoc());
4651 
4652  // If this type was written as an injected-class-name, it may have been
4653  // converted to a RecordType during instantiation. If the RecordType is
4654  // *not* wrapped in a TemplateSpecializationType and denotes a class
4655  // template specialization, it must have come from an injected-class-name.
4656  if (auto RecLoc = TLoc.getAs<RecordTypeLoc>())
4657  if (auto *CTSD =
4658  dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))
4659  return TemplateArgumentLoc(TemplateName(CTSD->getSpecializedTemplate()),
4660  QualLoc, RecLoc.getNameLoc());
4661 
4662  return TemplateArgumentLoc();
4663 }
4664 
4665 /// Check that the given template argument corresponds to the given
4666 /// template parameter.
4667 ///
4668 /// \param Param The template parameter against which the argument will be
4669 /// checked.
4670 ///
4671 /// \param Arg The template argument, which may be updated due to conversions.
4672 ///
4673 /// \param Template The template in which the template argument resides.
4674 ///
4675 /// \param TemplateLoc The location of the template name for the template
4676 /// whose argument list we're matching.
4677 ///
4678 /// \param RAngleLoc The location of the right angle bracket ('>') that closes
4679 /// the template argument list.
4680 ///
4681 /// \param ArgumentPackIndex The index into the argument pack where this
4682 /// argument will be placed. Only valid if the parameter is a parameter pack.
4683 ///
4684 /// \param Converted The checked, converted argument will be added to the
4685 /// end of this small vector.
4686 ///
4687 /// \param CTAK Describes how we arrived at this particular template argument:
4688 /// explicitly written, deduced, etc.
4689 ///
4690 /// \returns true on error, false otherwise.
4692  TemplateArgumentLoc &Arg,
4693  NamedDecl *Template,
4694  SourceLocation TemplateLoc,
4695  SourceLocation RAngleLoc,
4696  unsigned ArgumentPackIndex,
4699  // Check template type parameters.
4700  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
4701  return CheckTemplateTypeArgument(TTP, Arg, Converted);
4702 
4703  // Check non-type template parameters.
4704  if (NonTypeTemplateParmDecl *NTTP =dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4705  // Do substitution on the type of the non-type template parameter
4706  // with the template arguments we've seen thus far. But if the
4707  // template has a dependent context then we cannot substitute yet.
4708  QualType NTTPType = NTTP->getType();
4709  if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
4710  NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
4711 
4712  // FIXME: Do we need to substitute into parameters here if they're
4713  // instantiation-dependent but not dependent?
4714  if (NTTPType->isDependentType() &&
4715  !isa<TemplateTemplateParmDecl>(Template) &&
4716  !Template->getDeclContext()->isDependentContext()) {
4717  // Do substitution on the type of the non-type template parameter.
4718  InstantiatingTemplate Inst(*this, TemplateLoc, Template,
4719  NTTP, Converted,
4720  SourceRange(TemplateLoc, RAngleLoc));
4721  if (Inst.isInvalid())
4722  return true;
4723 
4725  Converted);
4726  NTTPType = SubstType(NTTPType,
4727  MultiLevelTemplateArgumentList(TemplateArgs),
4728  NTTP->getLocation(),
4729  NTTP->getDeclName());
4730  // If that worked, check the non-type template parameter type
4731  // for validity.
4732  if (!NTTPType.isNull())
4733  NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
4734  NTTP->getLocation());
4735  if (NTTPType.isNull())
4736  return true;
4737  }
4738 
4739  switch (Arg.getArgument().getKind()) {
4741  llvm_unreachable("Should never see a NULL template argument here");
4742 
4744  TemplateArgument Result;
4745  unsigned CurSFINAEErrors = NumSFINAEErrors;
4746  ExprResult Res =
4747  CheckTemplateArgument(NTTP, NTTPType, Arg.getArgument().getAsExpr(),
4748  Result, CTAK);
4749  if (Res.isInvalid())
4750  return true;
4751  // If the current template argument causes an error, give up now.
4752  if (CurSFINAEErrors < NumSFINAEErrors)
4753  return true;
4754 
4755  // If the resulting expression is new, then use it in place of the
4756  // old expression in the template argument.
4757  if (Res.get() != Arg.getArgument().getAsExpr()) {
4758  TemplateArgument TA(Res.get());
4759  Arg = TemplateArgumentLoc(TA, Res.get());
4760  }
4761 
4762  Converted.push_back(Result);
4763  break;
4764  }
4765 
4769  // We've already checked this template argument, so just copy
4770  // it to the list of converted arguments.
4771  Converted.push_back(Arg.getArgument());
4772  break;
4773 
4776  // We were given a template template argument. It may not be ill-formed;
4777  // see below.
4778  if (DependentTemplateName *DTN
4781  // We have a template argument such as \c T::template X, which we
4782  // parsed as a template template argument. However, since we now
4783  // know that we need a non-type template argument, convert this
4784  // template name into an expression.
4785 
4786  DeclarationNameInfo NameInfo(DTN->getIdentifier(),
4787  Arg.getTemplateNameLoc());
4788 
4789  CXXScopeSpec SS;
4790  SS.Adopt(Arg.getTemplateQualifierLoc());
4791  // FIXME: the template-template arg was a DependentTemplateName,
4792  // so it was provided with a template keyword. However, its source
4793  // location is not stored in the template argument structure.
4794  SourceLocation TemplateKWLoc;
4796  Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
4797  nullptr);
4798 
4799  // If we parsed the template argument as a pack expansion, create a
4800  // pack expansion expression.
4802  E = ActOnPackExpansion(E.get(), Arg.getTemplateEllipsisLoc());
4803  if (E.isInvalid())
4804  return true;
4805  }
4806 
4807  TemplateArgument Result;
4808  E = CheckTemplateArgument(NTTP, NTTPType, E.get(), Result);
4809  if (E.isInvalid())
4810  return true;
4811 
4812  Converted.push_back(Result);
4813  break;
4814  }
4815 
4816  // We have a template argument that actually does refer to a class
4817  // template, alias template, or template template parameter, and
4818  // therefore cannot be a non-type template argument.
4819  Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr)
4820  << Arg.getSourceRange();
4821 
4822  Diag(Param->getLocation(), diag::note_template_param_here);
4823  return true;
4824 
4825  case TemplateArgument::Type: {
4826  // We have a non-type template parameter but the template
4827  // argument is a type.
4828 
4829  // C++ [temp.arg]p2:
4830  // In a template-argument, an ambiguity between a type-id and
4831  // an expression is resolved to a type-id, regardless of the
4832  // form of the corresponding template-parameter.
4833  //
4834  // We warn specifically about this case, since it can be rather
4835  // confusing for users.
4836  QualType T = Arg.getArgument().getAsType();
4837  SourceRange SR = Arg.getSourceRange();
4838  if (T->isFunctionType())
4839  Diag(SR.getBegin(), diag::err_template_arg_nontype_ambig) << SR << T;
4840  else
4841  Diag(SR.getBegin(), diag::err_template_arg_must_be_expr) << SR;
4842  Diag(Param->getLocation(), diag::note_template_param_here);
4843  return true;
4844  }
4845 
4847  llvm_unreachable("Caller must expand template argument packs");
4848  }
4849 
4850  return false;
4851  }
4852 
4853 
4854  // Check template template parameters.
4855  TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(Param);
4856 
4857  TemplateParameterList *Params = TempParm->getTemplateParameters();
4858  if (TempParm->isExpandedParameterPack())
4859  Params = TempParm->getExpansionTemplateParameters(ArgumentPackIndex);
4860 
4861  // Substitute into the template parameter list of the template
4862  // template parameter, since previously-supplied template arguments
4863  // may appear within the template template parameter.
4864  //
4865  // FIXME: Skip this if the parameters aren't instantiation-dependent.
4866  {
4867  // Set up a template instantiation context.
4869  InstantiatingTemplate Inst(*this, TemplateLoc, Template,
4870  TempParm, Converted,
4871  SourceRange(TemplateLoc, RAngleLoc));
4872  if (Inst.isInvalid())
4873  return true;
4874 
4875  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
4876  Params = SubstTemplateParams(Params, CurContext,
4877  MultiLevelTemplateArgumentList(TemplateArgs));
4878  if (!Params)
4879  return true;
4880  }
4881 
4882  // C++1z [temp.local]p1: (DR1004)
4883  // When [the injected-class-name] is used [...] as a template-argument for
4884  // a template template-parameter [...] it refers to the class template
4885  // itself.
4886  if (Arg.getArgument().getKind() == TemplateArgument::Type) {
4888  Arg.getTypeSourceInfo()->getTypeLoc());
4889  if (!ConvertedArg.getArgument().isNull())
4890  Arg = ConvertedArg;
4891  }
4892 
4893  switch (Arg.getArgument().getKind()) {
4895  llvm_unreachable("Should never see a NULL template argument here");
4896 
4899  if (CheckTemplateTemplateArgument(Params, Arg))
4900  return true;
4901 
4902  Converted.push_back(Arg.getArgument());
4903  break;
4904 
4907  // We have a template template parameter but the template
4908  // argument does not refer to a template.
4909  Diag(Arg.getLocation(), diag::err_template_arg_must_be_template)
4910  << getLangOpts().CPlusPlus11;
4911  return true;
4912 
4914  llvm_unreachable("Declaration argument with template template parameter");
4916  llvm_unreachable("Integral argument with template template parameter");
4918  llvm_unreachable("Null pointer argument with template template parameter");
4919 
4921  llvm_unreachable("Caller must expand template argument packs");
4922  }
4923 
4924  return false;
4925 }
4926 
4927 /// Check whether the template parameter is a pack expansion, and if so,
4928 /// determine the number of parameters produced by that expansion. For instance:
4929 ///
4930 /// \code
4931 /// template<typename ...Ts> struct A {
4932 /// template<Ts ...NTs, template<Ts> class ...TTs, typename ...Us> struct B;
4933 /// };
4934 /// \endcode
4935 ///
4936 /// In \c A<int,int>::B, \c NTs and \c TTs have expanded pack size 2, and \c Us
4937 /// is not a pack expansion, so returns an empty Optional.
4939  if (NonTypeTemplateParmDecl *NTTP
4940  = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4941  if (NTTP->isExpandedParameterPack())
4942  return NTTP->getNumExpansionTypes();
4943  }
4944 
4945  if (TemplateTemplateParmDecl *TTP
4946  = dyn_cast<TemplateTemplateParmDecl>(Param)) {
4947  if (TTP->isExpandedParameterPack())
4948  return TTP->getNumExpansionTemplateParameters();
4949  }
4950 
4951  return None;
4952 }
4953 
4954 /// Diagnose a missing template argument.
4955 template<typename TemplateParmDecl>
4957  TemplateDecl *TD,
4958  const TemplateParmDecl *D,
4959  TemplateArgumentListInfo &Args) {
4960  // Dig out the most recent declaration of the template parameter; there may be
4961  // declarations of the template that are more recent than TD.
4962  D = cast<TemplateParmDecl>(cast<TemplateDecl>(TD->getMostRecentDecl())
4963  ->getTemplateParameters()
4964  ->getParam(D->getIndex()));
4965 
4966  // If there's a default argument that's not visible, diagnose that we're
4967  // missing a module import.
4969  if (D->hasDefaultArgument() && !S.hasVisibleDefaultArgument(D, &Modules)) {
4970  S.diagnoseMissingImport(Loc, cast<NamedDecl>(TD),
4971  D->getDefaultArgumentLoc(), Modules,
4973  /*Recover*/true);
4974  return true;
4975  }
4976 
4977  // FIXME: If there's a more recent default argument that *is* visible,
4978  // diagnose that it was declared too late.
4979 
4981 
4982  S.Diag(Loc, diag::err_template_arg_list_different_arity)
4983  << /*not enough args*/0
4985  << TD;
4986  S.Diag(TD->getLocation(), diag::note_template_decl_here)
4987  << Params->getSourceRange();
4988  return true;
4989 }
4990 
4991 /// Check that the given template argument list is well-formed
4992 /// for specializing the given template.
4994  TemplateDecl *Template, SourceLocation TemplateLoc,
4995  TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs,
4997  bool UpdateArgsWithConversions) {
4998  // Make a copy of the template arguments for processing. Only make the
4999  // changes at the end when successful in matching the arguments to the
5000  // template.
5001  TemplateArgumentListInfo NewArgs = TemplateArgs;
5002 
5003  // Make sure we get the template parameter list from the most
5004  // recentdeclaration, since that is the only one that has is guaranteed to
5005  // have all the default template argument information.
5006  TemplateParameterList *Params =
5007  cast<TemplateDecl>(Template->getMostRecentDecl())
5008  ->getTemplateParameters();
5009 
5010  SourceLocation RAngleLoc = NewArgs.getRAngleLoc();
5011 
5012  // C++ [temp.arg]p1:
5013  // [...] The type and form of each template-argument specified in
5014  // a template-id shall match the type and form specified for the
5015  // corresponding parameter declared by the template in its
5016  // template-parameter-list.
5017  bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
5018  SmallVector<TemplateArgument, 2> ArgumentPack;
5019  unsigned ArgIdx = 0, NumArgs = NewArgs.size();
5020  LocalInstantiationScope InstScope(*this, true);
5021  for (TemplateParameterList::iterator Param = Params->begin(),
5022  ParamEnd = Params->end();
5023  Param != ParamEnd; /* increment in loop */) {
5024  // If we have an expanded parameter pack, make sure we don't have too
5025  // many arguments.
5026  if (Optional<unsigned> Expansions = getExpandedPackSize(*Param)) {
5027  if (*Expansions == ArgumentPack.size()) {
5028  // We're done with this parameter pack. Pack up its arguments and add
5029  // them to the list.
5030  Converted.push_back(
5031  TemplateArgument::CreatePackCopy(Context, ArgumentPack));
5032  ArgumentPack.clear();
5033 
5034  // This argument is assigned to the next parameter.
5035  ++Param;
5036  continue;
5037  } else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
5038  // Not enough arguments for this parameter pack.
5039  Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5040  << /*not enough args*/0
5041  << (int)getTemplateNameKindForDiagnostics(TemplateName(Template))
5042  << Template;
5043  Diag(Template->getLocation(), diag::note_template_decl_here)
5044  << Params->getSourceRange();
5045  return true;
5046  }
5047  }
5048 
5049  if (ArgIdx < NumArgs) {
5050  // Check the template argument we were given.
5051  if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template,
5052  TemplateLoc, RAngleLoc,
5053  ArgumentPack.size(), Converted))
5054  return true;
5055 
5056  bool PackExpansionIntoNonPack =
5057  NewArgs[ArgIdx].getArgument().isPackExpansion() &&
5058  (!(*Param)->isTemplateParameterPack() || getExpandedPackSize(*Param));
5059  if (PackExpansionIntoNonPack && isa<TypeAliasTemplateDecl>(Template)) {
5060  // Core issue 1430: we have a pack expansion as an argument to an
5061  // alias template, and it's not part of a parameter pack. This
5062  // can't be canonicalized, so reject it now.
5063  Diag(NewArgs[ArgIdx].getLocation(),
5064  diag::err_alias_template_expansion_into_fixed_list)
5065  << NewArgs[ArgIdx].getSourceRange();
5066  Diag((*Param)->getLocation(), diag::note_template_param_here);
5067  return true;
5068  }
5069 
5070  // We're now done with this argument.
5071  ++ArgIdx;
5072 
5073  if ((*Param)->isTemplateParameterPack()) {
5074  // The template parameter was a template parameter pack, so take the
5075  // deduced argument and place it on the argument pack. Note that we
5076  // stay on the same template parameter so that we can deduce more
5077  // arguments.
5078  ArgumentPack.push_back(Converted.pop_back_val());
5079  } else {
5080  // Move to the next template parameter.
5081  ++Param;
5082  }
5083 
5084  // If we just saw a pack expansion into a non-pack, then directly convert
5085  // the remaining arguments, because we don't know what parameters they'll
5086  // match up with.
5087  if (PackExpansionIntoNonPack) {
5088  if (!ArgumentPack.empty()) {
5089  // If we were part way through filling in an expanded parameter pack,
5090  // fall back to just producing individual arguments.
5091  Converted.insert(Converted.end(),
5092  ArgumentPack.begin(), ArgumentPack.end());
5093  ArgumentPack.clear();
5094  }
5095 
5096  while (ArgIdx < NumArgs) {
5097  Converted.push_back(NewArgs[ArgIdx].getArgument());
5098  ++ArgIdx;
5099  }
5100 
5101  return false;
5102  }
5103 
5104  continue;
5105  }
5106 
5107  // If we're checking a partial template argument list, we're done.
5108  if (PartialTemplateArgs) {
5109  if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
5110  Converted.push_back(
5111  TemplateArgument::CreatePackCopy(Context, ArgumentPack));
5112 
5113  return false;
5114  }
5115 
5116  // If we have a template parameter pack with no more corresponding
5117  // arguments, just break out now and we'll fill in the argument pack below.
5118  if ((*Param)->isTemplateParameterPack()) {
5119  assert(!getExpandedPackSize(*Param) &&
5120  "Should have dealt with this already");
5121 
5122  // A non-expanded parameter pack before the end of the parameter list
5123  // only occurs for an ill-formed template parameter list, unless we've
5124  // got a partial argument list for a function template, so just bail out.
5125  if (Param + 1 != ParamEnd)
5126  return true;
5127 
5128  Converted.push_back(
5129  TemplateArgument::CreatePackCopy(Context, ArgumentPack));
5130  ArgumentPack.clear();
5131 
5132  ++Param;
5133  continue;
5134  }
5135 
5136  // Check whether we have a default argument.
5137  TemplateArgumentLoc Arg;
5138 
5139  // Retrieve the default template argument from the template
5140  // parameter. For each kind of template parameter, we substitute the
5141  // template arguments provided thus far and any "outer" template arguments
5142  // (when the template parameter was part of a nested template) into
5143  // the default argument.
5144  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
5145  if (!hasVisibleDefaultArgument(TTP))
5146  return diagnoseMissingArgument(*this, TemplateLoc, Template, TTP,
5147  NewArgs);
5148 
5150  Template,
5151  TemplateLoc,
5152  RAngleLoc,
5153  TTP,
5154  Converted);
5155  if (!ArgType)
5156  return true;
5157 
5158  Arg = TemplateArgumentLoc(TemplateArgument(ArgType->getType()),
5159  ArgType);
5160  } else if (NonTypeTemplateParmDecl *NTTP
5161  = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
5162  if (!hasVisibleDefaultArgument(NTTP))
5163  return diagnoseMissingArgument(*this, TemplateLoc, Template, NTTP,
5164  NewArgs);
5165 
5166  ExprResult E = SubstDefaultTemplateArgument(*this, Template,
5167  TemplateLoc,
5168  RAngleLoc,
5169  NTTP,
5170  Converted);
5171  if (E.isInvalid())
5172  return true;
5173 
5174  Expr *Ex = E.getAs<Expr>();
5175  Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex);
5176  } else {
5177  TemplateTemplateParmDecl *TempParm
5178  = cast<TemplateTemplateParmDecl>(*Param);
5179 
5180  if (!hasVisibleDefaultArgument(TempParm))
5181  return diagnoseMissingArgument(*this, TemplateLoc, Template, TempParm,
5182  NewArgs);
5183 
5184  NestedNameSpecifierLoc QualifierLoc;
5185  TemplateName Name = SubstDefaultTemplateArgument(*this, Template,
5186  TemplateLoc,
5187  RAngleLoc,
5188  TempParm,
5189  Converted,
5190  QualifierLoc);
5191  if (Name.isNull())
5192  return true;
5193 
5194  Arg = TemplateArgumentLoc(TemplateArgument(Name), QualifierLoc,
5195  TempParm->getDefaultArgument().getTemplateNameLoc());
5196  }
5197 
5198  // Introduce an instantiation record that describes where we are using
5199  // the default template argument. We're not actually instantiating a
5200  // template here, we just create this object to put a note into the
5201  // context stack.
5202  InstantiatingTemplate Inst(*this, RAngleLoc, Template, *Param, Converted,
5203  SourceRange(TemplateLoc, RAngleLoc));
5204  if (Inst.isInvalid())
5205  return true;
5206 
5207  // Check the default template argument.
5208  if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc,
5209  RAngleLoc, 0, Converted))
5210  return true;
5211 
5212  // Core issue 150 (assumed resolution): if this is a template template
5213  // parameter, keep track of the default template arguments from the
5214  // template definition.
5215  if (isTemplateTemplateParameter)
5216  NewArgs.addArgument(Arg);
5217 
5218  // Move to the next template parameter and argument.
5219  ++Param;
5220  ++ArgIdx;
5221  }
5222 
5223  // If we're performing a partial argument substitution, allow any trailing
5224  // pack expansions; they might be empty. This can happen even if
5225  // PartialTemplateArgs is false (the list of arguments is complete but
5226  // still dependent).
5227  if (ArgIdx < NumArgs && CurrentInstantiationScope &&
5228  CurrentInstantiationScope->getPartiallySubstitutedPack()) {
5229  while (ArgIdx < NumArgs && NewArgs[ArgIdx].getArgument().isPackExpansion())
5230  Converted.push_back(NewArgs[ArgIdx++].getArgument());
5231  }
5232 
5233  // If we have any leftover arguments, then there were too many arguments.
5234  // Complain and fail.
5235  if (ArgIdx < NumArgs) {
5236  Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5237  << /*too many args*/1
5238  << (int)getTemplateNameKindForDiagnostics(TemplateName(Template))
5239  << Template
5240  << SourceRange(NewArgs[ArgIdx].getLocation(), NewArgs.getRAngleLoc());
5241  Diag(Template->getLocation(), diag::note_template_decl_here)
5242  << Params->getSourceRange();
5243  return true;
5244  }
5245 
5246  // No problems found with the new argument list, propagate changes back
5247  // to caller.
5248  if (UpdateArgsWithConversions)
5249  TemplateArgs = std::move(NewArgs);
5250 
5251  return false;
5252 }
5253 
5254 namespace {
5255  class UnnamedLocalNoLinkageFinder
5256  : public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
5257  {
5258  Sema &S;
5259  SourceRange SR;
5260 
5262 
5263  public:
5264  UnnamedLocalNoLinkageFinder(Sema &S, SourceRange SR) : S(S), SR(SR) { }
5265 
5266  bool Visit(QualType T) {
5267  return T.isNull() ? false : inherited::Visit(T.getTypePtr());
5268  }
5269 
5270 #define TYPE(Class, Parent) \
5271  bool Visit##Class##Type(const Class##Type *);
5272 #define ABSTRACT_TYPE(Class, Parent) \
5273  bool Visit##Class##Type(const Class##Type *) { return false; }
5274 #define NON_CANONICAL_TYPE(Class, Parent) \
5275  bool Visit##Class##Type(const Class##Type *) { return false; }
5276 #include "clang/AST/TypeNodes.def"
5277 
5278  bool VisitTagDecl(const TagDecl *Tag);
5279  bool VisitNestedNameSpecifier(NestedNameSpecifier *NNS);
5280  };
5281 } // end anonymous namespace
5282 
5283 bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(const BuiltinType*) {
5284  return false;
5285 }
5286 
5287 bool UnnamedLocalNoLinkageFinder::VisitComplexType(const ComplexType* T) {
5288  return Visit(T->getElementType());
5289 }
5290 
5291 bool UnnamedLocalNoLinkageFinder::VisitPointerType(const PointerType* T) {
5292  return Visit(T->getPointeeType());
5293 }
5294 
5295 bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
5296  const BlockPointerType* T) {
5297  return Visit(T->getPointeeType());
5298 }
5299 
5300 bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
5301  const LValueReferenceType* T) {
5302  return Visit(T->getPointeeType());
5303 }
5304 
5305 bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
5306  const RValueReferenceType* T) {
5307  return Visit(T->getPointeeType());
5308 }
5309 
5310 bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
5311  const MemberPointerType* T) {
5312  return Visit(T->getPointeeType()) || Visit(QualType(T->getClass(), 0));
5313 }
5314 
5315 bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
5316  const ConstantArrayType* T) {
5317  return Visit(T->getElementType());
5318 }
5319 
5320 bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
5321  const IncompleteArrayType* T) {
5322  return Visit(T->getElementType());
5323 }
5324 
5325 bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
5326  const VariableArrayType* T) {
5327  return Visit(T->getElementType());
5328 }
5329 
5330 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
5331  const DependentSizedArrayType* T) {
5332  return Visit(T->getElementType());
5333 }
5334 
5335 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
5336  const DependentSizedExtVectorType* T) {
5337  return Visit(T->getElementType());
5338 }
5339 
5340 bool UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(
5341  const DependentAddressSpaceType *T) {
5342  return Visit(T->getPointeeType());
5343 }
5344 
5345 bool UnnamedLocalNoLinkageFinder::VisitVectorType(const VectorType* T) {
5346  return Visit(T->getElementType());
5347 }
5348 
5349 bool UnnamedLocalNoLinkageFinder::VisitDependentVectorType(
5350  const DependentVectorType *T) {
5351  return Visit(T->getElementType());
5352 }
5353 
5354 bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(const ExtVectorType* T) {
5355  return Visit(T->getElementType());
5356 }
5357 
5358 bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
5359  const FunctionProtoType* T) {
5360  for (const auto &A : T->param_types()) {
5361  if (Visit(A))
5362  return true;
5363  }
5364 
5365  return Visit(T->getReturnType());
5366 }
5367 
5368 bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
5369  const FunctionNoProtoType* T) {
5370  return Visit(T->getReturnType());
5371 }
5372 
5373 bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
5374  const UnresolvedUsingType*) {
5375  return false;
5376 }
5377 
5378 bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(const TypeOfExprType*) {
5379  return false;
5380 }
5381 
5382 bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(const TypeOfType* T) {
5383  return Visit(T->getUnderlyingType());
5384 }
5385 
5386 bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType*) {
5387  return false;
5388 }
5389 
5390 bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
5391  const UnaryTransformType*) {
5392  return false;
5393 }
5394 
5395 bool UnnamedLocalNoLinkageFinder::VisitAutoType(const AutoType *T) {
5396  return Visit(T->getDeducedType());
5397 }
5398 
5399 bool UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(
5401  return Visit(T->getDeducedType());
5402 }
5403 
5404 bool UnnamedLocalNoLinkageFinder::VisitRecordType(const RecordType* T) {
5405  return VisitTagDecl(T->getDecl());
5406 }
5407 
5408 bool UnnamedLocalNoLinkageFinder::VisitEnumType(const EnumType* T) {
5409  return VisitTagDecl(T->getDecl());
5410 }
5411 
5412 bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
5413  const TemplateTypeParmType*) {
5414  return false;
5415 }
5416 
5417 bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
5419  return false;
5420 }
5421 
5422 bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
5423  const TemplateSpecializationType*) {
5424  return false;
5425 }
5426 
5427 bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
5428  const InjectedClassNameType* T) {
5429  return VisitTagDecl(T->getDecl());
5430 }
5431 
5432 bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
5433  const DependentNameType* T) {
5434  return VisitNestedNameSpecifier(T->getQualifier());
5435 }
5436 
5437 bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
5439  return VisitNestedNameSpecifier(T->getQualifier());
5440 }
5441 
5442 bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
5443  const PackExpansionType* T) {
5444  return Visit(T->getPattern());
5445 }
5446 
5447 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType *) {
5448  return false;
5449 }
5450 
5451 bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
5452  const ObjCInterfaceType *) {
5453  return false;
5454 }
5455 
5456 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
5457  const ObjCObjectPointerType *) {
5458  return false;
5459 }
5460 
5461 bool UnnamedLocalNoLinkageFinder::VisitAtomicType(const AtomicType* T) {
5462  return Visit(T->getValueType());
5463 }
5464 
5465 bool UnnamedLocalNoLinkageFinder::VisitPipeType(const PipeType* T) {
5466  return false;
5467 }
5468 
5469 bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl *Tag) {
5470  if (Tag->getDeclContext()->isFunctionOrMethod()) {
5471  S.Diag(SR.getBegin(),
5472  S.getLangOpts().CPlusPlus11 ?
5473  diag::warn_cxx98_compat_template_arg_local_type :
5474  diag::ext_template_arg_local_type)
5475  << S.Context.getTypeDeclType(Tag) << SR;
5476  return true;
5477  }
5478 
5479  if (!Tag->hasNameForLinkage()) {
5480  S.Diag(SR.getBegin(),
5481  S.getLangOpts().CPlusPlus11 ?
5482  diag::warn_cxx98_compat_template_arg_unnamed_type :
5483  diag::ext_template_arg_unnamed_type) << SR;
5484  S.Diag(Tag->getLocation(), diag::note_template_unnamed_type_here);
5485  return true;
5486  }
5487 
5488  return false;
5489 }
5490 
5491 bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
5492  NestedNameSpecifier *NNS) {
5493  if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix()))
5494  return true;
5495 
5496  switch (NNS->getKind()) {
5502  return false;
5503 
5506  return Visit(QualType(NNS->getAsType(), 0));
5507  }
5508  llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
5509 }
5510 
5511 /// Check a template argument against its corresponding
5512 /// template type parameter.
5513 ///
5514 /// This routine implements the semantics of C++ [temp.arg.type]. It
5515 /// returns true if an error occurred, and false otherwise.
5517  TypeSourceInfo *ArgInfo) {
5518  assert(ArgInfo && "invalid TypeSourceInfo");
5519  QualType Arg = ArgInfo->getType();
5520  SourceRange SR = ArgInfo->getTypeLoc().getSourceRange();
5521 
5522  if (Arg->isVariablyModifiedType()) {
5523  return Diag(SR.getBegin(), diag::err_variably_modified_template_arg) << Arg;
5524  } else if (Context.hasSameUnqualifiedType(Arg, Context.OverloadTy)) {
5525  return Diag(SR.getBegin(), diag::err_template_arg_overload_type) << SR;
5526  }
5527 
5528  // C++03 [temp.arg.type]p2:
5529  // A local type, a type with no linkage, an unnamed type or a type
5530  // compounded from any of these types shall not be used as a
5531  // template-argument for a template type-parameter.
5532  //
5533  // C++11 allows these, and even in C++03 we allow them as an extension with
5534  // a warning.
5535  if (LangOpts.CPlusPlus11 || Arg->hasUnnamedOrLocalType()) {
5536  UnnamedLocalNoLinkageFinder Finder(*this, SR);
5537  (void)Finder.Visit(Context.getCanonicalType(Arg));
5538  }
5539 
5540  return false;
5541 }
5542 
5547 };
5548 
5549 /// Determine whether the given template argument is a null pointer
5550 /// value of the appropriate type.
5551 static NullPointerValueKind
5553  QualType ParamType, Expr *Arg,
5554  Decl *Entity = nullptr) {
5555  if (Arg->isValueDependent() || Arg->isTypeDependent())
5556  return NPV_NotNullPointer;
5557 
5558  // dllimport'd entities aren't constant but are available inside of template
5559  // arguments.
5560  if (Entity && Entity->hasAttr<DLLImportAttr>())
5561  return NPV_NotNullPointer;
5562 
5563  if (!S.isCompleteType(Arg->getExprLoc(), ParamType))
5564  llvm_unreachable(
5565  "Incomplete parameter type in isNullPointerValueTemplateArgument!");
5566 
5567  if (!S.getLangOpts().CPlusPlus11)
5568  return NPV_NotNullPointer;
5569 
5570  // Determine whether we have a constant expression.
5572  if (ArgRV.isInvalid())
5573  return NPV_Error;
5574  Arg = ArgRV.get();
5575 
5576  Expr::EvalResult EvalResult;
5578  EvalResult.Diag = &Notes;
5579  if (!Arg->EvaluateAsRValue(EvalResult, S.Context) ||
5580  EvalResult.HasSideEffects) {
5581  SourceLocation DiagLoc = Arg->getExprLoc();
5582 
5583  // If our only note is the usual "invalid subexpression" note, just point
5584  // the caret at its location rather than producing an essentially
5585  // redundant note.
5586  if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
5587  diag::note_invalid_subexpr_in_const_expr) {
5588  DiagLoc = Notes[0].first;
5589  Notes.clear();
5590  }
5591 
5592  S.Diag(DiagLoc, diag::err_template_arg_not_address_constant)
5593  << Arg->getType() << Arg->getSourceRange();
5594  for (unsigned I = 0, N = Notes.size(); I != N; ++I)
5595  S.Diag(Notes[I].first, Notes[I].second);
5596 
5597  S.Diag(Param->getLocation(), diag::note_template_param_here);
5598  return NPV_Error;
5599  }
5600 
5601  // C++11 [temp.arg.nontype]p1:
5602  // - an address constant expression of type std::nullptr_t
5603  if (Arg->getType()->isNullPtrType())
5604  return NPV_NullPointer;
5605 
5606  // - a constant expression that evaluates to a null pointer value (4.10); or
5607  // - a constant expression that evaluates to a null member pointer value
5608  // (4.11); or
5609  if ((EvalResult.Val.isLValue() && !EvalResult.Val.getLValueBase()) ||
5610  (EvalResult.Val.isMemberPointer() &&
5611  !EvalResult.Val.getMemberPointerDecl())) {
5612  // If our expression has an appropriate type, we've succeeded.
5613  bool ObjCLifetimeConversion;
5614  if (S.Context.hasSameUnqualifiedType(Arg->getType(), ParamType) ||
5615  S.IsQualificationConversion(Arg->getType(), ParamType, false,
5616  ObjCLifetimeConversion))
5617  return NPV_NullPointer;
5618 
5619  // The types didn't match, but we know we got a null pointer; complain,
5620  // then recover as if the types were correct.
5621  S.Diag(Arg->getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
5622  << Arg->getType() << ParamType << Arg->getSourceRange();
5623  S.Diag(Param->getLocation(), diag::note_template_param_here);
5624  return NPV_NullPointer;
5625  }
5626 
5627  // If we don't have a null pointer value, but we do have a NULL pointer
5628  // constant, suggest a cast to the appropriate type.
5630  std::string Code = "static_cast<" + ParamType.getAsString() + ">(";
5631  S.Diag(Arg->getExprLoc(), diag::err_template_arg_untyped_null_constant)
5632  << ParamType << FixItHint::CreateInsertion(Arg->getLocStart(), Code)
5634  ")");
5635  S.Diag(Param->getLocation(), diag::note_template_param_here);
5636  return NPV_NullPointer;
5637  }
5638 
5639  // FIXME: If we ever want to support general, address-constant expressions
5640  // as non-type template arguments, we should return the ExprResult here to
5641  // be interpreted by the caller.
5642  return NPV_NotNullPointer;
5643 }
5644 
5645 /// Checks whether the given template argument is compatible with its
5646 /// template parameter.
5648  Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
5649  Expr *Arg, QualType ArgType) {
5650  bool ObjCLifetimeConversion;
5651  if (ParamType->isPointerType() &&
5652  !ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType() &&
5653  S.IsQualificationConversion(ArgType, ParamType, false,
5654  ObjCLifetimeConversion)) {
5655  // For pointer-to-object types, qualification conversions are
5656  // permitted.
5657  } else {
5658  if (const ReferenceType *ParamRef = ParamType->getAs<ReferenceType>()) {
5659  if (!ParamRef->getPointeeType()->isFunctionType()) {
5660  // C++ [temp.arg.nontype]p5b3:
5661  // For a non-type template-parameter of type reference to
5662  // object, no conversions apply. The type referred to by the
5663  // reference may be more cv-qualified than the (otherwise
5664  // identical) type of the template- argument. The
5665  // template-parameter is bound directly to the
5666  // template-argument, which shall be an lvalue.
5667 
5668  // FIXME: Other qualifiers?
5669  unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
5670  unsigned ArgQuals = ArgType.getCVRQualifiers();
5671 
5672  if ((ParamQuals | ArgQuals) != ParamQuals) {
5673  S.Diag(Arg->getLocStart(),
5674  diag::err_template_arg_ref_bind_ignores_quals)
5675  << ParamType << Arg->getType() << Arg->getSourceRange();
5676  S.Diag(Param->getLocation(), diag::note_template_param_here);
5677  return true;
5678  }
5679  }
5680  }
5681 
5682  // At this point, the template argument refers to an object or
5683  // function with external linkage. We now need to check whether the
5684  // argument and parameter types are compatible.
5685  if (!S.Context.hasSameUnqualifiedType(ArgType,
5686  ParamType.getNonReferenceType())) {
5687  // We can't perform this conversion or binding.
5688  if (ParamType->isReferenceType())
5689  S.Diag(Arg->getLocStart(), diag::err_template_arg_no_ref_bind)
5690  << ParamType << ArgIn->getType() << Arg->getSourceRange();
5691  else
5692  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_convertible)
5693  << ArgIn->getType() << ParamType << Arg->getSourceRange();
5694  S.Diag(Param->getLocation(), diag::note_template_param_here);
5695  return true;
5696  }
5697  }
5698 
5699  return false;
5700 }
5701 
5702 /// Checks whether the given template argument is the address
5703 /// of an object or function according to C++ [temp.arg.nontype]p1.
5704 static bool
5706  NonTypeTemplateParmDecl *Param,
5707  QualType ParamType,
5708  Expr *ArgIn,
5709  TemplateArgument &Converted) {
5710  bool Invalid = false;
5711  Expr *Arg = ArgIn;
5712  QualType ArgType = Arg->getType();
5713 
5714  bool AddressTaken = false;
5715  SourceLocation AddrOpLoc;
5716  if (S.getLangOpts().MicrosoftExt) {
5717  // Microsoft Visual C++ strips all casts, allows an arbitrary number of
5718  // dereference and address-of operators.
5719  Arg = Arg->IgnoreParenCasts();
5720 
5721  bool ExtWarnMSTemplateArg = false;
5722  UnaryOperatorKind FirstOpKind;
5723  SourceLocation FirstOpLoc;
5724  while (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
5725  UnaryOperatorKind UnOpKind = UnOp->getOpcode();
5726  if (UnOpKind == UO_Deref)
5727  ExtWarnMSTemplateArg = true;
5728  if (UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {
5729  Arg = UnOp->getSubExpr()->IgnoreParenCasts();
5730  if (!AddrOpLoc.isValid()) {
5731  FirstOpKind = UnOpKind;
5732  FirstOpLoc = UnOp->getOperatorLoc();
5733  }
5734  } else
5735  break;
5736  }
5737  if (FirstOpLoc.isValid()) {
5738  if (ExtWarnMSTemplateArg)
5739  S.Diag(ArgIn->getLocStart(), diag::ext_ms_deref_template_argument)
5740  << ArgIn->getSourceRange();
5741 
5742  if (FirstOpKind == UO_AddrOf)
5743  AddressTaken = true;
5744  else if (Arg->getType()->isPointerType()) {
5745  // We cannot let pointers get dereferenced here, that is obviously not a
5746  // constant expression.
5747  assert(FirstOpKind == UO_Deref);
5748  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
5749  << Arg->getSourceRange();
5750  }
5751  }
5752  } else {
5753  // See through any implicit casts we added to fix the type.
5754  Arg = Arg->IgnoreImpCasts();
5755 
5756  // C++ [temp.arg.nontype]p1:
5757  //
5758  // A template-argument for a non-type, non-template
5759  // template-parameter shall be one of: [...]
5760  //
5761  // -- the address of an object or function with external
5762  // linkage, including function templates and function
5763  // template-ids but excluding non-static class members,
5764  // expressed as & id-expression where the & is optional if
5765  // the name refers to a function or array, or if the
5766  // corresponding template-parameter is a reference; or
5767 
5768  // In C++98/03 mode, give an extension warning on any extra parentheses.
5769  // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
5770  bool ExtraParens = false;
5771  while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
5772  if (!Invalid && !ExtraParens) {
5773  S.Diag(Arg->getLocStart(),
5774  S.getLangOpts().CPlusPlus11
5775  ? diag::warn_cxx98_compat_template_arg_extra_parens
5776  : diag::ext_template_arg_extra_parens)
5777  << Arg->getSourceRange();
5778  ExtraParens = true;
5779  }
5780 
5781  Arg = Parens->getSubExpr();
5782  }
5783 
5784  while (SubstNonTypeTemplateParmExpr *subst =
5785  dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
5786  Arg = subst->getReplacement()->IgnoreImpCasts();
5787 
5788  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
5789  if (UnOp->getOpcode() == UO_AddrOf) {
5790  Arg = UnOp->getSubExpr();
5791  AddressTaken = true;
5792  AddrOpLoc = UnOp->getOperatorLoc();
5793  }
5794  }
5795 
5796  while (SubstNonTypeTemplateParmExpr *subst =
5797  dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
5798  Arg = subst->getReplacement()->IgnoreImpCasts();
5799  }
5800 
5801  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg);
5802  ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;
5803 
5804  // If our parameter has pointer type, check for a null template value.
5805  if (ParamType->isPointerType() || ParamType->isNullPtrType()) {
5806  switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ArgIn,
5807  Entity)) {
5808  case NPV_NullPointer:
5809  S.Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
5810  Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
5811  /*isNullPtr=*/true);
5812  return false;
5813 
5814  case NPV_Error:
5815  return true;
5816 
5817  case NPV_NotNullPointer:
5818  break;
5819  }
5820  }
5821 
5822  // Stop checking the precise nature of the argument if it is value dependent,
5823  // it should be checked when instantiated.
5824  if (Arg->isValueDependent()) {
5825  Converted = TemplateArgument(ArgIn);
5826  return false;
5827  }
5828 
5829  if (isa<CXXUuidofExpr>(Arg)) {
5830  if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType,
5831  ArgIn, Arg, ArgType))
5832  return true;
5833 
5834  Converted = TemplateArgument(ArgIn);
5835  return false;
5836  }
5837 
5838  if (!DRE) {
5839  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
5840  << Arg->getSourceRange();
5841  S.Diag(Param->getLocation(), diag::note_template_param_here);
5842  return true;
5843  }
5844 
5845  // Cannot refer to non-static data members
5846  if (isa<FieldDecl>(Entity) || isa<IndirectFieldDecl>(Entity)) {
5847  S.Diag(Arg->getLocStart(), diag::err_template_arg_field)
5848  << Entity << Arg->getSourceRange();
5849  S.Diag(Param->getLocation(), diag::note_template_param_here);
5850  return true;
5851  }
5852 
5853  // Cannot refer to non-static member functions
5854  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) {
5855  if (!Method->isStatic()) {
5856  S.Diag(Arg->getLocStart(), diag::err_template_arg_method)
5857  << Method << Arg->getSourceRange();
5858  S.Diag(Param->getLocation(), diag::note_template_param_here);
5859  return true;
5860  }
5861  }
5862 
5863  FunctionDecl *Func = dyn_cast<FunctionDecl>(Entity);
5864  VarDecl *Var = dyn_cast<VarDecl>(Entity);
5865 
5866  // A non-type template argument must refer to an object or function.
5867  if (!Func && !Var) {
5868  // We found something, but we don't know specifically what it is.
5869  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_object_or_func)
5870  << Arg->getSourceRange();
5871  S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
5872  return true;
5873  }
5874 
5875  // Address / reference template args must have external linkage in C++98.
5876  if (Entity->getFormalLinkage() == InternalLinkage) {
5877  S.Diag(Arg->getLocStart(), S.getLangOpts().CPlusPlus11 ?
5878  diag::warn_cxx98_compat_template_arg_object_internal :
5879  diag::ext_template_arg_object_internal)
5880  << !Func << Entity << Arg->getSourceRange();
5881  S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
5882  << !Func;
5883  } else if (!Entity->hasLinkage()) {
5884  S.Diag(Arg->getLocStart(), diag::err_template_arg_object_no_linkage)
5885  << !Func << Entity << Arg->getSourceRange();
5886  S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
5887  << !Func;
5888  return true;
5889  }
5890 
5891  if (Func) {
5892  // If the template parameter has pointer type, the function decays.
5893  if (ParamType->isPointerType() && !AddressTaken)
5894  ArgType = S.Context.getPointerType(Func->getType());
5895  else if (AddressTaken && ParamType->isReferenceType()) {
5896  // If we originally had an address-of operator, but the
5897  // parameter has reference type, complain and (if things look
5898  // like they will work) drop the address-of operator.
5899  if (!S.Context.hasSameUnqualifiedType(Func->getType(),
5900  ParamType.getNonReferenceType())) {
5901  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5902  << ParamType;
5903  S.Diag(Param->getLocation(), diag::note_template_param_here);
5904  return true;
5905  }
5906 
5907  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5908  << ParamType
5909  << FixItHint::CreateRemoval(AddrOpLoc);
5910  S.Diag(Param->getLocation(), diag::note_template_param_here);
5911 
5912  ArgType = Func->getType();
5913  }
5914  } else {
5915  // A value of reference type is not an object.
5916  if (Var->getType()->isReferenceType()) {
5917  S.Diag(Arg->getLocStart(),
5918  diag::err_template_arg_reference_var)
5919  << Var->getType() << Arg->getSourceRange();
5920  S.Diag(Param->getLocation(), diag::note_template_param_here);
5921  return true;
5922  }
5923 
5924  // A template argument must have static storage duration.
5925  if (Var->getTLSKind()) {
5926  S.Diag(Arg->getLocStart(), diag::err_template_arg_thread_local)
5927  << Arg->getSourceRange();
5928  S.Diag(Var->getLocation(), diag::note_template_arg_refers_here);
5929  return true;
5930  }
5931 
5932  // If the template parameter has pointer type, we must have taken
5933  // the address of this object.
5934  if (ParamType->isReferenceType()) {
5935  if (AddressTaken) {
5936  // If we originally had an address-of operator, but the
5937  // parameter has reference type, complain and (if things look
5938  // like they will work) drop the address-of operator.
5939  if (!S.Context.hasSameUnqualifiedType(Var->getType(),
5940  ParamType.getNonReferenceType())) {
5941  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5942  << ParamType;
5943  S.Diag(Param->getLocation(), diag::note_template_param_here);
5944  return true;
5945  }
5946 
5947  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5948  << ParamType
5949  << FixItHint::CreateRemoval(AddrOpLoc);
5950  S.Diag(Param->getLocation(), diag::note_template_param_here);
5951 
5952  ArgType = Var->getType();
5953  }
5954  } else if (!AddressTaken && ParamType->isPointerType()) {
5955  if (Var->getType()->isArrayType()) {
5956  // Array-to-pointer decay.
5957  ArgType = S.Context.getArrayDecayedType(Var->getType());
5958  } else {
5959  // If the template parameter has pointer type but the address of
5960  // this object was not taken, complain and (possibly) recover by
5961  // taking the address of the entity.
5962  ArgType = S.Context.getPointerType(Var->getType());
5963  if (!S.Context.hasSameUnqualifiedType(ArgType, ParamType)) {
5964  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
5965  << ParamType;
5966  S.Diag(Param->getLocation(), diag::note_template_param_here);
5967  return true;
5968  }
5969 
5970  S.Diag(Arg->getLocStart(), diag::err_template_arg_not_address_of)
5971  << ParamType
5972  << FixItHint::CreateInsertion(Arg->getLocStart(), "&");
5973 
5974  S.Diag(Param->getLocation(), diag::note_template_param_here);
5975  }
5976  }
5977  }
5978 
5979  if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType, ArgIn,
5980  Arg, ArgType))
5981  return true;
5982 
5983  // Create the template argument.
5984  Converted =
5985  TemplateArgument(cast<ValueDecl>(Entity->getCanonicalDecl()), ParamType);
5986  S.MarkAnyDeclReferenced(Arg->getLocStart(), Entity, false);
5987  return false;
5988 }
5989 
5990 /// Checks whether the given template argument is a pointer to
5991 /// member constant according to C++ [temp.arg.nontype]p1.
5993  NonTypeTemplateParmDecl *Param,
5994  QualType ParamType,
5995  Expr *&ResultArg,
5996  TemplateArgument &Converted) {
5997  bool Invalid = false;
5998 
5999  Expr *Arg = ResultArg;
6000  bool ObjCLifetimeConversion;
6001 
6002  // C++ [temp.arg.nontype]p1:
6003  //
6004  // A template-argument for a non-type, non-template
6005  // template-parameter shall be one of: [...]
6006  //
6007  // -- a pointer to member expressed as described in 5.3.1.
6008  DeclRefExpr *DRE = nullptr;
6009 
6010  // In C++98/03 mode, give an extension warning on any extra parentheses.
6011  // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
6012  bool ExtraParens = false;
6013  while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
6014  if (!Invalid && !ExtraParens) {
6015  S.Diag(Arg->getLocStart(),
6016  S.getLangOpts().CPlusPlus11 ?
6017  diag::warn_cxx98_compat_template_arg_extra_parens :
6018  diag::ext_template_arg_extra_parens)
6019  << Arg->getSourceRange();
6020  ExtraParens = true;
6021  }
6022 
6023  Arg = Parens->getSubExpr();
6024  }
6025 
6026  while (SubstNonTypeTemplateParmExpr *subst =
6027  dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
6028  Arg = subst->getReplacement()->IgnoreImpCasts();
6029 
6030  // A pointer-to-member constant written &Class::member.
6031  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
6032  if (UnOp->getOpcode() == UO_AddrOf) {
6033  DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
6034  if (DRE && !DRE->getQualifier())
6035  DRE = nullptr;
6036  }
6037  }
6038  // A constant of pointer-to-member type.
6039  else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
6040  ValueDecl *VD = DRE->getDecl();
6041  if (VD->getType()->isMemberPointerType()) {
6042  if (isa<NonTypeTemplateParmDecl>(VD)) {
6043  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
6044  Converted = TemplateArgument(Arg);
6045  } else {
6046  VD = cast<ValueDecl>(VD->getCanonicalDecl());
6047  Converted = TemplateArgument(VD, ParamType);
6048  }
6049  return Invalid;
6050  }
6051  }
6052 
6053  DRE = nullptr;
6054  }
6055 
6056  ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;
6057 
6058  // Check for a null pointer value.
6059  switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ResultArg,
6060  Entity)) {
6061  case NPV_Error:
6062  return true;
6063  case NPV_NullPointer:
6064  S.Diag(ResultArg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
6065  Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
6066  /*isNullPtr*/true);
6067  return false;
6068  case NPV_NotNullPointer:
6069  break;
6070  }
6071 
6072  if (S.IsQualificationConversion(ResultArg->getType(),
6073  ParamType.getNonReferenceType(), false,
6074  ObjCLifetimeConversion)) {
6075  ResultArg = S.ImpCastExprToType(ResultArg, ParamType, CK_NoOp,
6076  ResultArg->getValueKind())
6077  .get();
6078  } else if (!S.Context.hasSameUnqualifiedType(
6079  ResultArg->getType(), ParamType.getNonReferenceType())) {
6080  // We can't perform this conversion.
6081  S.Diag(ResultArg->getLocStart(), diag::err_template_arg_not_convertible)
6082  << ResultArg->getType() << ParamType << ResultArg->getSourceRange();
6083  S.Diag(Param->getLocation(), diag::note_template_param_here);
6084  return true;
6085  }
6086 
6087  if (!DRE)
6088  return S.Diag(Arg->getLocStart(),
6089  diag::err_template_arg_not_pointer_to_member_form)
6090  << Arg->getSourceRange();
6091 
6092  if (isa<FieldDecl>(DRE->getDecl()) ||
6093  isa<IndirectFieldDecl>(DRE->getDecl()) ||
6094  isa<CXXMethodDecl>(DRE->getDecl())) {
6095  assert((isa<FieldDecl>(DRE->getDecl()) ||
6096  isa<IndirectFieldDecl>(DRE->getDecl()) ||
6097  !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&
6098  "Only non-static member pointers can make it here");
6099 
6100  // Okay: this is the address of a non-static member, and therefore
6101  // a member pointer constant.
6102  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
6103  Converted = TemplateArgument(Arg);
6104  } else {
6105  ValueDecl *D = cast<ValueDecl>(DRE->getDecl()->getCanonicalDecl());
6106  Converted = TemplateArgument(D, ParamType);
6107  }
6108  return Invalid;
6109  }
6110 
6111  // We found something else, but we don't know specifically what it is.
6112  S.Diag(Arg->getLocStart(),
6113  diag::err_template_arg_not_pointer_to_member_form)
6114  << Arg->getSourceRange();
6115  S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
6116  return true;
6117 }
6118 
6119 /// Check a template argument against its corresponding
6120 /// non-type template parameter.
6121 ///
6122 /// This routine implements the semantics of C++ [temp.arg.nontype].
6123 /// If an error occurred, it returns ExprError(); otherwise, it
6124 /// returns the converted template argument. \p ParamType is the
6125 /// type of the non-type template parameter after it has been instantiated.
6127  QualType ParamType, Expr *Arg,
6128  TemplateArgument &Converted,
6130  SourceLocation StartLoc = Arg->getLocStart();
6131 
6132  // If the parameter type somehow involves auto, deduce the type now.
6133  if (getLangOpts().CPlusPlus17 && ParamType->isUndeducedType()) {
6134  // During template argument deduction, we allow 'decltype(auto)' to
6135  // match an arbitrary dependent argument.
6136  // FIXME: The language rules don't say what happens in this case.
6137  // FIXME: We get an opaque dependent type out of decltype(auto) if the
6138  // expression is merely instantiation-dependent; is this enough?
6139  if (CTAK == CTAK_Deduced && Arg->isTypeDependent()) {
6140  auto *AT = dyn_cast<AutoType>(ParamType);
6141  if (AT && AT->isDecltypeAuto()) {
6142  Converted = TemplateArgument(Arg);
6143  return Arg;
6144  }
6145  }
6146 
6147  // When checking a deduced template argument, deduce from its type even if
6148  // the type is dependent, in order to check the types of non-type template
6149  // arguments line up properly in partial ordering.
6151  if (CTAK != CTAK_Specified)
6152  Depth = Param->getDepth() + 1;
6153  if (DeduceAutoType(
6154  Context.getTrivialTypeSourceInfo(ParamType, Param->getLocation()),
6155  Arg, ParamType, Depth) == DAR_Failed) {
6156  Diag(Arg->getExprLoc(),
6157  diag::err_non_type_template_parm_type_deduction_failure)
6158  << Param->getDeclName() << Param->getType() << Arg->getType()
6159  << Arg->getSourceRange();
6160  Diag(Param->getLocation(), diag::note_template_param_here);
6161  return ExprError();
6162  }
6163  // CheckNonTypeTemplateParameterType will produce a diagnostic if there's
6164  // an error. The error message normally references the parameter
6165  // declaration, but here we'll pass the argument location because that's
6166  // where the parameter type is deduced.
6167  ParamType = CheckNonTypeTemplateParameterType(ParamType, Arg->getExprLoc());
6168  if (ParamType.isNull()) {
6169  Diag(Param->getLocation(), diag::note_template_param_here);
6170  return ExprError();
6171  }
6172  }
6173 
6174  // We should have already dropped all cv-qualifiers by now.
6175  assert(!ParamType.hasQualifiers() &&
6176  "non-type template parameter type cannot be qualified");
6177 
6178  if (CTAK == CTAK_Deduced &&
6179  !Context.hasSameType(ParamType.getNonLValueExprType(Context),
6180  Arg->getType())) {
6181  // FIXME: If either type is dependent, we skip the check. This isn't
6182  // correct, since during deduction we're supposed to have replaced each
6183  // template parameter with some unique (non-dependent) placeholder.
6184  // FIXME: If the argument type contains 'auto', we carry on and fail the
6185  // type check in order to force specific types to be more specialized than
6186  // 'auto'. It's not clear how partial ordering with 'auto' is supposed to
6187  // work.
6188  if ((ParamType->isDependentType() || Arg->isTypeDependent()) &&
6189  !Arg->getType()->getContainedAutoType()) {
6190  Converted = TemplateArgument(Arg);
6191  return Arg;
6192  }
6193  // FIXME: This attempts to implement C++ [temp.deduct.type]p17. Per DR1770,
6194  // we should actually be checking the type of the template argument in P,
6195  // not the type of the template argument deduced from A, against the
6196  // template parameter type.
6197  Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
6198  << Arg->getType()
6199  << ParamType.getUnqualifiedType();
6200  Diag(Param->getLocation(), diag::note_template_param_here);
6201  return ExprError();
6202  }
6203 
6204  // If either the parameter has a dependent type or the argument is
6205  // type-dependent, there's nothing we can check now.
6206  if (ParamType->isDependentType() || Arg->isTypeDependent()) {
6207  // FIXME: Produce a cloned, canonical expression?
6208  Converted = TemplateArgument(Arg);
6209  return Arg;
6210  }
6211 
6212  // The initialization of the parameter from the argument is
6213  // a constant-evaluated context.
6214  EnterExpressionEvaluationContext ConstantEvaluated(
6216 
6217  if (getLangOpts().CPlusPlus17) {
6218  // C++17 [temp.arg.nontype]p1:
6219  // A template-argument for a non-type template parameter shall be
6220  // a converted constant expression of the type of the template-parameter.
6221  APValue Value;
6223  Arg, ParamType, Value, CCEK_TemplateArg);
6224  if (ArgResult.isInvalid())
6225  return ExprError();
6226 
6227  // For a value-dependent argument, CheckConvertedConstantExpression is
6228  // permitted (and expected) to be unable to determine a value.
6229  if (ArgResult.get()->isValueDependent()) {
6230  Converted = TemplateArgument(ArgResult.get());
6231  return ArgResult;
6232  }
6233 
6234  QualType CanonParamType = Context.getCanonicalType(ParamType);
6235 
6236  // Convert the APValue to a TemplateArgument.
6237  switch (Value.getKind()) {
6239  assert(ParamType->isNullPtrType());
6240  Converted = TemplateArgument(CanonParamType, /*isNullPtr*/true);
6241  break;
6242  case APValue::Int:
6243  assert(ParamType->isIntegralOrEnumerationType());
6244  Converted = TemplateArgument(Context, Value.getInt(), CanonParamType);
6245  break;
6246  case APValue::MemberPointer: {
6247  assert(ParamType->isMemberPointerType());
6248 
6249  // FIXME: We need TemplateArgument representation and mangling for these.
6250  if (!Value.getMemberPointerPath().empty()) {
6251  Diag(Arg->getLocStart(),
6252  diag::err_template_arg_member_ptr_base_derived_not_supported)
6253  << Value.getMemberPointerDecl() << ParamType
6254  << Arg->getSourceRange();
6255  return ExprError();
6256  }
6257 
6258  auto *VD = const_cast<ValueDecl*>(Value.getMemberPointerDecl());
6259  Converted = VD ? TemplateArgument(VD, CanonParamType)
6260  : TemplateArgument(CanonParamType, /*isNullPtr*/true);
6261  break;
6262  }
6263  case APValue::LValue: {
6264  // For a non-type template-parameter of pointer or reference type,
6265  // the value of the constant expression shall not refer to
6266  assert(ParamType->isPointerType() || ParamType->isReferenceType() ||
6267  ParamType->isNullPtrType());
6268  // -- a temporary object
6269  // -- a string literal
6270  // -- the result of a typeid expression, or
6271  // -- a predefined __func__ variable
6272  if (auto *E = Value.getLValueBase().dyn_cast<const Expr*>()) {
6273  if (isa<CXXUuidofExpr>(E)) {
6274  Converted = TemplateArgument(ArgResult.get());
6275  break;
6276  }
6277  Diag(Arg->getLocStart(), diag::err_template_arg_not_decl_ref)
6278  << Arg->getSourceRange();
6279  return ExprError();
6280  }
6281  auto *VD = const_cast<ValueDecl *>(
6282  Value.getLValueBase().dyn_cast<const ValueDecl *>());
6283  // -- a subobject
6284  if (Value.hasLValuePath() && Value.getLValuePath().size() == 1 &&
6285  VD && VD->getType()->isArrayType() &&
6286  Value.getLValuePath()[0].ArrayIndex == 0 &&
6287  !Value.isLValueOnePastTheEnd() && ParamType->isPointerType()) {
6288  // Per defect report (no number yet):
6289  // ... other than a pointer to the first element of a complete array
6290  // object.
6291  } else if (!Value.hasLValuePath() || Value.getLValuePath().size() ||
6292  Value.isLValueOnePastTheEnd()) {
6293  Diag(StartLoc, diag::err_non_type_template_arg_subobject)
6294  << Value.getAsString(Context, ParamType);
6295  return ExprError();
6296  }
6297  assert((VD || !ParamType->isReferenceType()) &&
6298  "null reference should not be a constant expression");
6299  assert((!VD || !ParamType->isNullPtrType()) &&
6300  "non-null value of type nullptr_t?");
6301  Converted = VD ? TemplateArgument(VD, CanonParamType)
6302  : TemplateArgument(CanonParamType, /*isNullPtr*/true);
6303  break;
6304  }
6306  return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
6307  case APValue::Float:
6308  case APValue::ComplexInt:
6309  case APValue::ComplexFloat:
6310  case APValue::Vector:
6311  case APValue::Array:
6312  case APValue::Struct:
6313  case APValue::Union:
6314  llvm_unreachable("invalid kind for template argument");
6315  }
6316 
6317  return ArgResult.get();
6318  }
6319 
6320  // C++ [temp.arg.nontype]p5:
6321  // The following conversions are performed on each expression used
6322  // as a non-type template-argument. If a non-type
6323  // template-argument cannot be converted to the type of the
6324  // corresponding template-parameter then the program is
6325  // ill-formed.
6326  if (ParamType->isIntegralOrEnumerationType()) {
6327  // C++11:
6328  // -- for a non-type template-parameter of integral or
6329  // enumeration type, conversions permitted in a converted
6330  // constant expression are applied.
6331  //
6332  // C++98:
6333  // -- for a non-type template-parameter of integral or
6334  // enumeration type, integral promotions (4.5) and integral
6335  // conversions (4.7) are applied.
6336 
6337  if (getLangOpts().CPlusPlus11) {
6338  // C++ [temp.arg.nontype]p1:
6339  // A template-argument for a non-type, non-template template-parameter
6340  // shall be one of:
6341  //
6342  // -- for a non-type template-parameter of integral or enumeration
6343  // type, a converted constant expression of the type of the
6344  // template-parameter; or
6345  llvm::APSInt Value;
6346  ExprResult ArgResult =
6347  CheckConvertedConstantExpression(Arg, ParamType, Value,
6348  CCEK_TemplateArg);
6349  if (ArgResult.isInvalid())
6350  return ExprError();
6351 
6352  // We can't check arbitrary value-dependent arguments.
6353  if (ArgResult.get()->isValueDependent()) {
6354  Converted = TemplateArgument(ArgResult.get());
6355  return ArgResult;
6356  }
6357 
6358  // Widen the argument value to sizeof(parameter type). This is almost
6359  // always a no-op, except when the parameter type is bool. In
6360  // that case, this may extend the argument from 1 bit to 8 bits.
6361  QualType IntegerType = ParamType;
6362  if (const EnumType *Enum = IntegerType->getAs<EnumType>())
6363  IntegerType = Enum->getDecl()->getIntegerType();
6364  Value = Value.extOrTrunc(Context.getTypeSize(IntegerType));
6365 
6366  Converted = TemplateArgument(Context, Value,
6367  Context.getCanonicalType(ParamType));
6368  return ArgResult;
6369  }
6370 
6371  ExprResult ArgResult = DefaultLvalueConversion(Arg);
6372  if (ArgResult.isInvalid())
6373  return ExprError();
6374  Arg = ArgResult.get();
6375 
6376  QualType ArgType = Arg->getType();
6377 
6378  // C++ [temp.arg.nontype]p1:
6379  // A template-argument for a non-type, non-template
6380  // template-parameter shall be one of:
6381  //
6382  // -- an integral constant-expression of integral or enumeration
6383  // type; or
6384  // -- the name of a non-type template-parameter; or
6385  llvm::APSInt Value;
6386  if (!ArgType->isIntegralOrEnumerationType()) {
6387  Diag(Arg->getLocStart(),
6388  diag::err_template_arg_not_integral_or_enumeral)
6389  << ArgType << Arg->getSourceRange();
6390  Diag(Param->getLocation(), diag::note_template_param_here);
6391  return ExprError();
6392  } else if (!Arg->isValueDependent()) {
6393  class TmplArgICEDiagnoser : public VerifyICEDiagnoser {
6394  QualType T;
6395 
6396  public:
6397  TmplArgICEDiagnoser(QualType T) : T(T) { }
6398 
6399  void diagnoseNotICE(Sema &S, SourceLocation Loc,
6400  SourceRange SR) override {
6401  S.Diag(Loc, diag::err_template_arg_not_ice) << T << SR;
6402  }
6403  } Diagnoser(ArgType);
6404 
6405  Arg = VerifyIntegerConstantExpression(Arg, &Value, Diagnoser,
6406  false).get();
6407  if (!Arg)
6408  return ExprError();
6409  }
6410 
6411  // From here on out, all we care about is the unqualified form
6412  // of the argument type.
6413  ArgType = ArgType.getUnqualifiedType();
6414 
6415  // Try to convert the argument to the parameter's type.
6416  if (Context.hasSameType(ParamType, ArgType)) {
6417  // Okay: no conversion necessary
6418  } else if (ParamType->isBooleanType()) {
6419  // This is an integral-to-boolean conversion.
6420  Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralToBoolean).get();
6421  } else if (IsIntegralPromotion(Arg, ArgType, ParamType) ||
6422  !ParamType->isEnumeralType()) {
6423  // This is an integral promotion or conversion.
6424  Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralCast).get();
6425  } else {
6426  // We can't perform this conversion.
6427  Diag(Arg->getLocStart(),
6428  diag::err_template_arg_not_convertible)
6429  << Arg->getType() << ParamType << Arg->getSourceRange();
6430  Diag(Param->getLocation(), diag::note_template_param_here);
6431  return ExprError();
6432  }
6433 
6434  // Add the value of this argument to the list of converted
6435  // arguments. We use the bitwidth and signedness of the template
6436  // parameter.
6437  if (Arg->isValueDependent()) {
6438  // The argument is value-dependent. Create a new
6439  // TemplateArgument with the converted expression.
6440  Converted = TemplateArgument(Arg);
6441  return Arg;
6442  }
6443 
6444  QualType IntegerType = Context.getCanonicalType(ParamType);
6445  if (const EnumType *Enum = IntegerType->getAs<EnumType>())
6446  IntegerType = Context.getCanonicalType(Enum->getDecl()->getIntegerType());
6447 
6448  if (ParamType->isBooleanType()) {
6449  // Value must be zero or one.
6450  Value = Value != 0;
6451  unsigned AllowedBits = Context.getTypeSize(IntegerType);
6452  if (Value.getBitWidth() != AllowedBits)
6453  Value = Value.extOrTrunc(AllowedBits);
6454  Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
6455  } else {
6456  llvm::APSInt OldValue = Value;
6457 
6458  // Coerce the template argument's value to the value it will have
6459  // based on the template parameter's type.
6460  unsigned AllowedBits = Context.getTypeSize(IntegerType);
6461  if (Value.getBitWidth() != AllowedBits)
6462  Value = Value.extOrTrunc(AllowedBits);
6463  Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
6464 
6465  // Complain if an unsigned parameter received a negative value.
6466  if (IntegerType->isUnsignedIntegerOrEnumerationType()
6467  && (OldValue.isSigned() && OldValue.isNegative())) {
6468  Diag(Arg->getLocStart(), diag::warn_template_arg_negative)
6469  << OldValue.toString(10) << Value.toString(10) << Param->getType()
6470  << Arg->getSourceRange();
6471  Diag(Param->getLocation(), diag::note_template_param_here);
6472  }
6473 
6474  // Complain if we overflowed the template parameter's type.
6475  unsigned RequiredBits;
6476  if (IntegerType->isUnsignedIntegerOrEnumerationType())
6477  RequiredBits = OldValue.getActiveBits();
6478  else if (OldValue.isUnsigned())
6479  RequiredBits = OldValue.getActiveBits() + 1;
6480  else
6481  RequiredBits = OldValue.getMinSignedBits();
6482  if (RequiredBits > AllowedBits) {
6483  Diag(Arg->getLocStart(),
6484  diag::warn_template_arg_too_large)
6485  << OldValue.toString(10) << Value.toString(10) << Param->getType()
6486  << Arg->getSourceRange();
6487  Diag(Param->getLocation(), diag::note_template_param_here);
6488  }
6489  }
6490 
6491  Converted = TemplateArgument(Context, Value,
6492  ParamType->isEnumeralType()
6493  ? Context.getCanonicalType(ParamType)
6494  : IntegerType);
6495  return Arg;
6496  }
6497 
6498  QualType ArgType = Arg->getType();
6499  DeclAccessPair FoundResult; // temporary for ResolveOverloadedFunction
6500 
6501  // Handle pointer-to-function, reference-to-function, and
6502  // pointer-to-member-function all in (roughly) the same way.
6503  if (// -- For a non-type template-parameter of type pointer to
6504  // function, only the function-to-pointer conversion (4.3) is
6505  // applied. If the template-argument represents a set of
6506  // overloaded functions (or a pointer to such), the matching
6507  // function is selected from the set (13.4).
6508  (ParamType->isPointerType() &&
6509  ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType()) ||
6510  // -- For a non-type template-parameter of type reference to
6511  // function, no conversions apply. If the template-argument
6512  // represents a set of overloaded functions, the matching
6513  // function is selected from the set (13.4).
6514  (ParamType->isReferenceType() &&
6515  ParamType->getAs<ReferenceType>()->getPointeeType()->isFunctionType()) ||
6516  // -- For a non-type template-parameter of type pointer to
6517  // member function, no conversions apply. If the
6518  // template-argument represents a set of overloaded member
6519  // functions, the matching member function is selected from
6520  // the set (13.4).
6521  (ParamType->isMemberPointerType() &&
6522  ParamType->getAs<MemberPointerType>()->getPointeeType()
6523  ->isFunctionType())) {
6524 
6525  if (Arg->getType() == Context.OverloadTy) {
6526  if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType,
6527  true,
6528  FoundResult)) {
6529  if (DiagnoseUseOfDecl(Fn, Arg->getLocStart()))
6530  return ExprError();
6531 
6532  Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
6533  ArgType = Arg->getType();
6534  } else
6535  return ExprError();
6536  }
6537 
6538  if (!ParamType->isMemberPointerType()) {
6540  ParamType,
6541  Arg, Converted))
6542  return ExprError();
6543  return Arg;
6544  }
6545 
6546  if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
6547  Converted))
6548  return ExprError();
6549  return Arg;
6550  }
6551 
6552  if (ParamType->isPointerType()) {
6553  // -- for a non-type template-parameter of type pointer to
6554  // object, qualification conversions (4.4) and the
6555  // array-to-pointer conversion (4.2) are applied.
6556  // C++0x also allows a value of std::nullptr_t.
6557  assert(ParamType->getPointeeType()->isIncompleteOrObjectType() &&
6558  "Only object pointers allowed here");
6559 
6561  ParamType,
6562  Arg, Converted))
6563  return ExprError();
6564  return Arg;
6565  }
6566 
6567  if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
6568  // -- For a non-type template-parameter of type reference to
6569  // object, no conversions apply. The type referred to by the
6570  // reference may be more cv-qualified than the (otherwise
6571  // identical) type of the template-argument. The
6572  // template-parameter is bound directly to the
6573  // template-argument, which must be an lvalue.
6574  assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&
6575  "Only object references allowed here");
6576 
6577  if (Arg->getType() == Context.OverloadTy) {
6578  if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg,
6579  ParamRefType->getPointeeType(),
6580  true,
6581  FoundResult)) {
6582  if (DiagnoseUseOfDecl(Fn, Arg->getLocStart()))
6583  return ExprError();
6584 
6585  Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
6586  ArgType = Arg->getType();
6587  } else
6588  return ExprError();
6589  }
6590 
6592  ParamType,
6593  Arg, Converted))
6594  return ExprError();
6595  return Arg;
6596  }
6597 
6598  // Deal with parameters of type std::nullptr_t.
6599  if (ParamType->isNullPtrType()) {
6600  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
6601  Converted = TemplateArgument(Arg);
6602  return Arg;
6603  }
6604 
6605  switch (isNullPointerValueTemplateArgument(*this, Param, ParamType, Arg)) {
6606  case NPV_NotNullPointer:
6607  Diag(Arg->getExprLoc(), diag::err_template_arg_not_convertible)
6608  << Arg->getType() << ParamType;
6609  Diag(Param->getLocation(), diag::note_template_param_here);
6610  return ExprError();
6611 
6612  case NPV_Error:
6613  return ExprError();
6614 
6615  case NPV_NullPointer:
6616  Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
6617  Converted = TemplateArgument(Context.getCanonicalType(ParamType),
6618  /*isNullPtr*/true);
6619  return Arg;
6620  }
6621  }
6622 
6623  // -- For a non-type template-parameter of type pointer to data
6624  // member, qualification conversions (4.4) are applied.
6625  assert(ParamType->isMemberPointerType() && "Only pointers to members remain");
6626 
6627  if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
6628  Converted))
6629  return ExprError();
6630  return Arg;
6631 }
6632 
6636 
6637 /// Check a template argument against its corresponding
6638 /// template template parameter.
6639 ///
6640 /// This routine implements the semantics of C++ [temp.arg.template].
6641 /// It returns true if an error occurred, and false otherwise.
6643  TemplateArgumentLoc &Arg) {
6645  TemplateDecl *Template = Name.getAsTemplateDecl();
6646  if (!Template) {
6647  // Any dependent template name is fine.
6648  assert(Name.isDependent() && "Non-dependent template isn't a declaration?");
6649  return false;
6650  }
6651 
6652  if (Template->isInvalidDecl())
6653  return true;
6654 
6655  // C++0x [temp.arg.template]p1:
6656  // A template-argument for a template template-parameter shall be
6657  // the name of a class template or an alias template, expressed as an
6658  // id-expression. When the template-argument names a class template, only
6659  // primary class templates are considered when matching the
6660  // template template argument with the corresponding parameter;
6661  // partial specializations are not considered even if their
6662  // parameter lists match that of the template template parameter.
6663  //
6664  // Note that we also allow template template parameters here, which
6665  // will happen when we are dealing with, e.g., class template
6666  // partial specializations.
6667  if (!isa<ClassTemplateDecl>(Template) &&
6668  !isa<TemplateTemplateParmDecl>(Template) &&
6669  !isa<TypeAliasTemplateDecl>(Template) &&
6670  !isa<BuiltinTemplateDecl>(Template)) {
6671  assert(isa<FunctionTemplateDecl>(Template) &&
6672  "Only function templates are possible here");
6673  Diag(Arg.getLocation(), diag::err_template_arg_not_valid_template);
6674  Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
6675  << Template;
6676  }
6677 
6678  // C++1z [temp.arg.template]p3: (DR 150)
6679  // A template-argument matches a template template-parameter P when P
6680  // is at least as specialized as the template-argument A.
6681  if (getLangOpts().RelaxedTemplateTemplateArgs) {
6682  // Quick check for the common case:
6683  // If P contains a parameter pack, then A [...] matches P if each of A's
6684  // template parameters matches the corresponding template parameter in
6685  // the template-parameter-list of P.
6686  if (TemplateParameterListsAreEqual(
6687  Template->getTemplateParameters(), Params, false,
6688  TPL_TemplateTemplateArgumentMatch, Arg.getLocation()))
6689  return false;
6690 
6691  if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template,
6692  Arg.getLocation()))
6693  return false;
6694  // FIXME: Produce better diagnostics for deduction failures.
6695  }
6696 
6697  return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),
6698  Params,
6699  true,
6700  TPL_TemplateTemplateArgumentMatch,
6701  Arg.getLocation());
6702 }
6703 
6704 /// Given a non-type template argument that refers to a
6705 /// declaration and the type of its corresponding non-type template
6706 /// parameter, produce an expression that properly refers to that
6707 /// declaration.
6708 ExprResult
6710  QualType ParamType,
6711  SourceLocation Loc) {
6712  // C++ [temp.param]p8:
6713  //
6714  // A non-type template-parameter of type "array of T" or
6715  // "function returning T" is adjusted to be of type "pointer to
6716  // T" or "pointer to function returning T", respectively.
6717  if (ParamType->isArrayType())
6718  ParamType = Context.getArrayDecayedType(ParamType);
6719  else if (ParamType->isFunctionType())
6720  ParamType = Context.getPointerType(ParamType);
6721 
6722  // For a NULL non-type template argument, return nullptr casted to the
6723  // parameter's type.
6724  if (Arg.getKind() == TemplateArgument::NullPtr) {
6725  return ImpCastExprToType(
6726  new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc),
6727  ParamType,
6728  ParamType->getAs<MemberPointerType>()
6729  ? CK_NullToMemberPointer
6730  : CK_NullToPointer);
6731  }
6732  assert(Arg.getKind() == TemplateArgument::Declaration &&
6733  "Only declaration template arguments permitted here");
6734 
6735  ValueDecl *VD = Arg.getAsDecl();
6736 
6737  if (VD->getDeclContext()->isRecord() &&
6738  (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||
6739  isa<IndirectFieldDecl>(VD))) {
6740  // If the value is a class member, we might have a pointer-to-member.
6741  // Determine whether the non-type template template parameter is of
6742  // pointer-to-member type. If so, we need to build an appropriate
6743  // expression for a pointer-to-member, since a "normal" DeclRefExpr
6744  // would refer to the member itself.
6745  if (ParamType->isMemberPointerType()) {
6746  QualType ClassType
6747  = Context.getTypeDeclType(cast<RecordDecl>(VD->getDeclContext()));
6748  NestedNameSpecifier *Qualifier
6749  = NestedNameSpecifier::Create(Context, nullptr, false,
6750  ClassType.getTypePtr());
6751  CXXScopeSpec SS;
6752  SS.MakeTrivial(Context, Qualifier, Loc);
6753 
6754  // The actual value-ness of this is unimportant, but for
6755  // internal consistency's sake, references to instance methods
6756  // are r-values.
6757  ExprValueKind VK = VK_LValue;
6758  if (isa<CXXMethodDecl>(VD) && cast<CXXMethodDecl>(VD)->isInstance())
6759  VK = VK_RValue;
6760 
6761  ExprResult RefExpr = BuildDeclRefExpr(VD,
6762  VD->getType().getNonReferenceType(),
6763  VK,
6764  Loc,
6765  &SS);
6766  if (RefExpr.isInvalid())
6767  return ExprError();
6768 
6769  RefExpr = CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
6770 
6771  // We might need to perform a trailing qualification conversion, since
6772  // the element type on the parameter could be more qualified than the
6773  // element type in the expression we constructed.
6774  bool ObjCLifetimeConversion;
6775  if (IsQualificationConversion(((Expr*) RefExpr.get())->getType(),
6776  ParamType.getUnqualifiedType(), false,
6777  ObjCLifetimeConversion))
6778  RefExpr = ImpCastExprToType(RefExpr.get(), ParamType.getUnqualifiedType(), CK_NoOp);
6779 
6780  assert(!RefExpr.isInvalid() &&
6781  Context.hasSameType(((Expr*) RefExpr.get())->getType(),
6782  ParamType.getUnqualifiedType()));
6783  return RefExpr;
6784  }
6785  }
6786 
6787  QualType T = VD->getType().getNonReferenceType();
6788 
6789  if (ParamType->isPointerType()) {
6790  // When the non-type template parameter is a pointer, take the
6791  // address of the declaration.
6792  ExprResult RefExpr = BuildDeclRefExpr(VD, T, VK_LValue, Loc);
6793  if (RefExpr.isInvalid())
6794  return ExprError();
6795 
6796  if (!Context.hasSameUnqualifiedType(ParamType->getPointeeType(), T) &&
6797  (T->isFunctionType() || T->isArrayType())) {
6798  // Decay functions and arrays unless we're forming a pointer to array.
6799  RefExpr = DefaultFunctionArrayConversion(RefExpr.get());
6800  if (RefExpr.isInvalid())
6801  return ExprError();
6802 
6803  return RefExpr;
6804  }
6805 
6806  // Take the address of everything else
6807  return CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
6808  }
6809 
6810  ExprValueKind VK = VK_RValue;
6811 
6812  // If the non-type template parameter has reference type, qualify the
6813  // resulting declaration reference with the extra qualifiers on the
6814  // type that the reference refers to.
6815  if (const ReferenceType *TargetRef = ParamType->getAs<ReferenceType>()) {
6816  VK = VK_LValue;
6817  T = Context.getQualifiedType(T,
6818  TargetRef->getPointeeType().getQualifiers());
6819  } else if (isa<FunctionDecl>(VD)) {
6820  // References to functions are always lvalues.
6821  VK = VK_LValue;
6822  }
6823 
6824  return BuildDeclRefExpr(VD, T, VK, Loc);
6825 }
6826 
6827 /// Construct a new expression that refers to the given
6828 /// integral template argument with the given source-location
6829 /// information.
6830 ///
6831 /// This routine takes care of the mapping from an integral template
6832 /// argument (which may have any integral type) to the appropriate
6833 /// literal value.
6834 ExprResult
6836  SourceLocation Loc) {
6837  assert(Arg.getKind() == TemplateArgument::Integral &&
6838  "Operation is only valid for integral template arguments");
6839  QualType OrigT = Arg.getIntegralType();
6840 
6841  // If this is an enum type that we're instantiating, we need to use an integer
6842  // type the same size as the enumerator. We don't want to build an
6843  // IntegerLiteral with enum type. The integer type of an enum type can be of
6844  // any integral type with C++11 enum classes, make sure we create the right
6845  // type of literal for it.
6846  QualType T = OrigT;
6847  if (const EnumType *ET = OrigT->getAs<EnumType>())
6848  T = ET->getDecl()->getIntegerType();
6849 
6850  Expr *E;
6851  if (T->isAnyCharacterType()) {
6853  if (T->isWideCharType())
6854  Kind = CharacterLiteral::Wide;
6855  else if (T->isChar8Type() && getLangOpts().Char8)
6856  Kind = CharacterLiteral::UTF8;
6857  else if (T->isChar16Type())
6858  Kind = CharacterLiteral::UTF16;
6859  else if (T->isChar32Type())
6860  Kind = CharacterLiteral::UTF32;
6861  else
6862  Kind = CharacterLiteral::Ascii;
6863 
6864  E = new (Context) CharacterLiteral(Arg.getAsIntegral().getZExtValue(),
6865  Kind, T, Loc);
6866  } else if (T->isBooleanType()) {
6867  E = new (Context) CXXBoolLiteralExpr(Arg.getAsIntegral().getBoolValue(),
6868  T, Loc);
6869  } else if (T->isNullPtrType()) {
6870  E = new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
6871  } else {
6872  E = IntegerLiteral::Create(Context, Arg.getAsIntegral(), T, Loc);
6873  }
6874 
6875  if (OrigT->isEnumeralType()) {
6876  // FIXME: This is a hack. We need a better way to handle substituted
6877  // non-type template parameters.
6878  E = CStyleCastExpr::Create(Context, OrigT, VK_RValue, CK_IntegralCast, E,
6879  nullptr,
6880  Context.getTrivialTypeSourceInfo(OrigT, Loc),
6881  Loc, Loc);
6882  }
6883 
6884  return E;
6885 }
6886 
6887 /// Match two template parameters within template parameter lists.
6889  bool Complain,
6891  SourceLocation TemplateArgLoc) {
6892  // Check the actual kind (type, non-type, template).
6893  if (Old->getKind() != New->getKind()) {
6894  if (Complain) {
6895  unsigned NextDiag = diag::err_template_param_different_kind;
6896  if (TemplateArgLoc.isValid()) {
6897  S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
6898  NextDiag = diag::note_template_param_different_kind;
6899  }
6900  S.Diag(New->getLocation(), NextDiag)
6901  << (Kind != Sema::TPL_TemplateMatch);
6902  S.Diag(Old->getLocation(), diag::note_template_prev_declaration)
6903  << (Kind != Sema::TPL_TemplateMatch);
6904  }
6905 
6906  return false;
6907  }
6908 
6909  // Check that both are parameter packs or neither are parameter packs.
6910  // However, if we are matching a template template argument to a
6911  // template template parameter, the template template parameter can have
6912  // a parameter pack where the template template argument does not.
6913  if (Old->isTemplateParameterPack() != New->isTemplateParameterPack() &&
6915  Old->isTemplateParameterPack())) {
6916  if (Complain) {
6917  unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
6918  if (TemplateArgLoc.isValid()) {
6919  S.Diag(TemplateArgLoc,
6920  diag::err_template_arg_template_params_mismatch);
6921  NextDiag = diag::note_template_parameter_pack_non_pack;
6922  }
6923 
6924  unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
6925  : isa<NonTypeTemplateParmDecl>(New)? 1
6926  : 2;
6927  S.Diag(New->getLocation(), NextDiag)
6928  << ParamKind << New->isParameterPack();
6929  S.Diag(Old->getLocation(), diag::note_template_parameter_pack_here)
6930  << ParamKind << Old->isParameterPack();
6931  }
6932 
6933  return false;
6934  }
6935 
6936  // For non-type template parameters, check the type of the parameter.
6937  if (NonTypeTemplateParmDecl *OldNTTP
6938  = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
6939  NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);
6940 
6941  // If we are matching a template template argument to a template
6942  // template parameter and one of the non-type template parameter types
6943  // is dependent, then we must wait until template instantiation time
6944  // to actually compare the arguments.
6946  (OldNTTP->getType()->isDependentType() ||
6947  NewNTTP->getType()->isDependentType()))
6948  return true;
6949 
6950  if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
6951  if (Complain) {
6952  unsigned NextDiag = diag::err_template_nontype_parm_different_type;
6953  if (TemplateArgLoc.isValid()) {
6954  S.Diag(TemplateArgLoc,
6955  diag::err_template_arg_template_params_mismatch);
6956  NextDiag = diag::note_template_nontype_parm_different_type;
6957  }
6958  S.Diag(NewNTTP->getLocation(), NextDiag)
6959  << NewNTTP->getType()
6960  << (Kind != Sema::TPL_TemplateMatch);
6961  S.Diag(OldNTTP->getLocation(),
6962  diag::note_template_nontype_parm_prev_declaration)
6963  << OldNTTP->getType();
6964  }
6965 
6966  return false;
6967  }
6968 
6969  return true;
6970  }
6971 
6972  // For template template parameters, check the template parameter types.
6973  // The template parameter lists of template template
6974  // parameters must agree.
6975  if (TemplateTemplateParmDecl *OldTTP
6976  = dyn_cast<TemplateTemplateParmDecl>(Old)) {
6977  TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
6979  OldTTP->getTemplateParameters(),
6980  Complain,
6981  (Kind == Sema::TPL_TemplateMatch
6983  : Kind),
6984  TemplateArgLoc);
6985  }
6986 
6987  return true;
6988 }
6989 
6990 /// Diagnose a known arity mismatch when comparing template argument
6991 /// lists.
6992 static
6994  TemplateParameterList *New,
6995  TemplateParameterList *Old,
6997  SourceLocation TemplateArgLoc) {
6998  unsigned NextDiag = diag::err_template_param_list_different_arity;
6999  if (TemplateArgLoc.isValid()) {
7000  S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
7001  NextDiag = diag::note_template_param_list_different_arity;
7002  }
7003  S.Diag(New->getTemplateLoc(), NextDiag)
7004  << (New->size() > Old->size())
7005  << (Kind != Sema::TPL_TemplateMatch)
7006  << SourceRange(New->getTemplateLoc(), New->getRAngleLoc());
7007  S.Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration)
7008  << (Kind != Sema::TPL_TemplateMatch)
7009  << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc());
7010 }
7011 
7012 /// Determine whether the given template parameter lists are
7013 /// equivalent.
7014 ///
7015 /// \param New The new template parameter list, typically written in the
7016 /// source code as part of a new template declaration.
7017 ///
7018 /// \param Old The old template parameter list, typically found via
7019 /// name lookup of the template declared with this template parameter
7020 /// list.
7021 ///
7022 /// \param Complain If true, this routine will produce a diagnostic if
7023 /// the template parameter lists are not equivalent.
7024 ///
7025 /// \param Kind describes how we are to match the template parameter lists.
7026 ///
7027 /// \param TemplateArgLoc If this source location is valid, then we
7028 /// are actually checking the template parameter list of a template
7029 /// argument (New) against the template parameter list of its
7030 /// corresponding template template parameter (Old). We produce
7031 /// slightly different diagnostics in this scenario.
7032 ///
7033 /// \returns True if the template parameter lists are equal, false
7034 /// otherwise.
7035 bool
7037  TemplateParameterList *Old,
7038  bool Complain,
7040  SourceLocation TemplateArgLoc) {
7041  if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) {
7042  if (Complain)
7043  DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
7044  TemplateArgLoc);
7045 
7046  return false;
7047  }
7048 
7049  // C++0x [temp.arg.template]p3:
7050  // A template-argument matches a template template-parameter (call it P)
7051  // when each of the template parameters in the template-parameter-list of
7052  // the template-argument's corresponding class template or alias template
7053  // (call it A) matches the corresponding template parameter in the
7054  // template-parameter-list of P. [...]
7055  TemplateParameterList::iterator NewParm = New->begin();
7056  TemplateParameterList::iterator NewParmEnd = New->end();
7057  for (TemplateParameterList::iterator OldParm = Old->begin(),
7058  OldParmEnd = Old->end();
7059  OldParm != OldParmEnd; ++OldParm) {
7060  if (Kind != TPL_TemplateTemplateArgumentMatch ||
7061  !(*OldParm)->isTemplateParameterPack()) {
7062  if (NewParm == NewParmEnd) {
7063  if (Complain)
7064  DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
7065  TemplateArgLoc);
7066 
7067  return false;
7068  }
7069 
7070  if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
7071  Kind, TemplateArgLoc))
7072  return false;
7073 
7074  ++NewParm;
7075  continue;
7076  }
7077 
7078  // C++0x [temp.arg.template]p3:
7079  // [...] When P's template- parameter-list contains a template parameter
7080  // pack (14.5.3), the template parameter pack will match zero or more
7081  // template parameters or template parameter packs in the
7082  // template-parameter-list of A with the same type and form as the
7083  // template parameter pack in P (ignoring whether those template
7084  // parameters are template parameter packs).
7085  for (; NewParm != NewParmEnd; ++NewParm) {
7086  if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
7087  Kind, TemplateArgLoc))
7088  return false;
7089  }
7090  }
7091 
7092  // Make sure we exhausted all of the arguments.
7093  if (NewParm != NewParmEnd) {
7094  if (Complain)
7095  DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
7096  TemplateArgLoc);
7097 
7098  return false;
7099  }
7100 
7101  return true;
7102 }
7103 
7104 /// Check whether a template can be declared within this scope.
7105 ///
7106 /// If the template declaration is valid in this scope, returns
7107 /// false. Otherwise, issues a diagnostic and returns true.
7108 bool
7110  if (!S)
7111  return false;
7112 
7113  // Find the nearest enclosing declaration scope.
7114  while ((S->getFlags() & Scope::DeclScope) == 0 ||
7115  (S->getFlags() & Scope::TemplateParamScope) != 0)
7116  S = S->getParent();
7117 
7118  // C++ [temp]p4:
7119  // A template [...] shall not have C linkage.
7120  DeclContext *Ctx = S->getEntity();
7121  if (Ctx && Ctx->isExternCContext()) {
7122  Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
7123  << TemplateParams->getSourceRange();
7124  if (const LinkageSpecDecl *LSD = Ctx->getExternCContext())
7125  Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
7126  return true;
7127  }
7128  Ctx = Ctx->getRedeclContext();
7129 
7130  // C++ [temp]p2:
7131  // A template-declaration can appear only as a namespace scope or
7132  // class scope declaration.
7133  if (Ctx) {
7134  if (Ctx->isFileContext())
7135  return false;
7136  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Ctx)) {
7137  // C++ [temp.mem]p2:
7138  // A local class shall not have member templates.
7139  if (RD->isLocalClass())
7140  return Diag(TemplateParams->getTemplateLoc(),
7141  diag::err_template_inside_local_class)
7142  << TemplateParams->getSourceRange();
7143  else
7144  return false;
7145  }
7146  }
7147 
7148  return Diag(TemplateParams->getTemplateLoc(),
7149  diag::err_template_outside_namespace_or_class_scope)
7150  << TemplateParams->getSourceRange();
7151 }
7152 
7153 /// Determine what kind of template specialization the given declaration
7154 /// is.
7156  if (!D)
7157  return TSK_Undeclared;
7158 
7159  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D))
7160  return Record->getTemplateSpecializationKind();
7161  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D))
7162  return Function->getTemplateSpecializationKind();
7163  if (VarDecl *Var = dyn_cast<VarDecl>(D))
7164  return Var->getTemplateSpecializationKind();
7165 
7166  return TSK_Undeclared;
7167 }
7168 
7169 /// Check whether a specialization is well-formed in the current
7170 /// context.
7171 ///
7172 /// This routine determines whether a template specialization can be declared
7173 /// in the current context (C++ [temp.expl.spec]p2).
7174 ///
7175 /// \param S the semantic analysis object for which this check is being
7176 /// performed.
7177 ///
7178 /// \param Specialized the entity being specialized or instantiated, which
7179 /// may be a kind of template (class template, function template, etc.) or
7180 /// a member of a class template (member function, static data member,
7181 /// member class).
7182 ///
7183 /// \param PrevDecl the previous declaration of this entity, if any.
7184 ///
7185 /// \param Loc the location of the explicit specialization or instantiation of
7186 /// this entity.
7187 ///
7188 /// \param IsPartialSpecialization whether this is a partial specialization of
7189 /// a class template.
7190 ///
7191 /// \returns true if there was an error that we cannot recover from, false
7192 /// otherwise.
7194  NamedDecl *Specialized,
7195  NamedDecl *PrevDecl,
7196  SourceLocation Loc,
7197  bool IsPartialSpecialization) {
7198  // Keep these "kind" numbers in sync with the %select statements in the
7199  // various diagnostics emitted by this routine.
7200  int EntityKind = 0;
7201  if (isa<ClassTemplateDecl>(Specialized))
7202  EntityKind = IsPartialSpecialization? 1 : 0;
7203  else if (isa<VarTemplateDecl>(Specialized))
7204  EntityKind = IsPartialSpecialization ? 3 : 2;
7205  else if (isa<FunctionTemplateDecl>(Specialized))
7206  EntityKind = 4;
7207  else if (isa<CXXMethodDecl>(Specialized))
7208  EntityKind = 5;
7209  else if (isa<VarDecl>(Specialized))
7210  EntityKind = 6;
7211  else if (isa<RecordDecl>(Specialized))
7212  EntityKind = 7;
7213  else if (isa<EnumDecl>(Specialized) && S.getLangOpts().CPlusPlus11)
7214  EntityKind = 8;
7215  else {
7216  S.Diag(Loc, diag::err_template_spec_unknown_kind)
7217  << S.getLangOpts().CPlusPlus11;
7218  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
7219  return true;
7220  }
7221 
7222  // C++ [temp.expl.spec]p2:
7223  // An explicit specialization may be declared in any scope in which
7224  // the corresponding primary template may be defined.
7226  S.Diag(Loc, diag::err_template_spec_decl_function_scope)
7227  << Specialized;
7228  return true;
7229  }
7230 
7231  // C++ [temp.class.spec]p6:
7232  // A class template partial specialization may be declared in any
7233  // scope in which the primary template may be defined.
7234  DeclContext *SpecializedContext =
7235  Specialized->getDeclContext()->getRedeclContext();
7237 
7238  // Make sure that this redeclaration (or definition) occurs in the same
7239  // scope or an enclosing namespace.
7240  if (!(DC->isFileContext() ? DC->Encloses(SpecializedContext)
7241  : DC->Equals(SpecializedContext))) {
7242  if (isa<TranslationUnitDecl>(SpecializedContext))
7243  S.Diag(Loc, diag::err_template_spec_redecl_global_scope)
7244  << EntityKind << Specialized;
7245  else {
7246  auto *ND = cast<NamedDecl>(SpecializedContext);
7247  int Diag = diag::err_template_spec_redecl_out_of_scope;
7248  if (S.getLangOpts().MicrosoftExt && !DC->isRecord())
7249  Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
7250  S.Diag(Loc, Diag) << EntityKind << Specialized
7251  << ND << isa<CXXRecordDecl>(ND);
7252  }
7253 
7254  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
7255 
7256  // Don't allow specializing in the wrong class during error recovery.
7257  // Otherwise, things can go horribly wrong.
7258  if (DC->isRecord())
7259  return true;
7260  }
7261 
7262  return false;
7263 }
7264 
7266  if (!E->isTypeDependent())
7267  return SourceLocation();
7268  DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
7269  Checker.TraverseStmt(E);
7270  if (Checker.MatchLoc.isInvalid())
7271  return E->getSourceRange();
7272  return Checker.MatchLoc;
7273 }
7274 
7276  if (!TL.getType()->isDependentType())
7277  return SourceLocation();
7278  DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
7279  Checker.TraverseTypeLoc(TL);
7280  if (Checker.MatchLoc.isInvalid())
7281  return TL.getSourceRange();
7282  return Checker.MatchLoc;
7283 }
7284 
7285 /// Subroutine of Sema::CheckTemplatePartialSpecializationArgs
7286 /// that checks non-type template partial specialization arguments.
7288  Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param,
7289  const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument) {
7290  for (unsigned I = 0; I != NumArgs; ++I) {
7291  if (Args[I].getKind() == TemplateArgument::Pack) {
7293  S, TemplateNameLoc, Param, Args[I].pack_begin(),
7294  Args[I].pack_size(), IsDefaultArgument))
7295  return true;
7296 
7297  continue;
7298  }
7299 
7300  if (Args[I].getKind() != TemplateArgument::Expression)
7301  continue;
7302 
7303  Expr *ArgExpr = Args[I].getAsExpr();
7304 
7305  // We can have a pack expansion of any of the bullets below.
7306  if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(ArgExpr))
7307  ArgExpr = Expansion->getPattern();
7308 
7309  // Strip off any implicit casts we added as part of type checking.
7310  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
7311  ArgExpr = ICE->getSubExpr();
7312 
7313  // C++ [temp.class.spec]p8:
7314  // A non-type argument is non-specialized if it is the name of a
7315  // non-type parameter. All other non-type arguments are
7316  // specialized.
7317  //
7318  // Below, we check the two conditions that only apply to
7319  // specialized non-type arguments, so skip any non-specialized
7320  // arguments.
7321  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
7322  if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
7323  continue;
7324 
7325  // C++ [temp.class.spec]p9:
7326  // Within the argument list of a class template partial
7327  // specialization, the following restrictions apply:
7328  // -- A partially specialized non-type argument expression
7329  // shall not involve a template parameter of the partial
7330  // specialization except when the argument expression is a
7331  // simple identifier.
7332  // -- The type of a template parameter corresponding to a
7333  // specialized non-type argument shall not be dependent on a
7334  // parameter of the specialization.
7335  // DR1315 removes the first bullet, leaving an incoherent set of rules.
7336  // We implement a compromise between the original rules and DR1315:
7337  // -- A specialized non-type template argument shall not be
7338  // type-dependent and the corresponding template parameter
7339  // shall have a non-dependent type.
7340  SourceRange ParamUseRange =
7341  findTemplateParameterInType(Param->getDepth(), ArgExpr);
7342  if (ParamUseRange.isValid()) {
7343  if (IsDefaultArgument) {
7344  S.Diag(TemplateNameLoc,
7345  diag::err_dependent_non_type_arg_in_partial_spec);
7346  S.Diag(ParamUseRange.getBegin(),
7347  diag::note_dependent_non_type_default_arg_in_partial_spec)
7348  << ParamUseRange;
7349  } else {
7350  S.Diag(ParamUseRange.getBegin(),
7351  diag::err_dependent_non_type_arg_in_partial_spec)
7352  << ParamUseRange;
7353  }
7354  return true;
7355  }
7356 
7357  ParamUseRange = findTemplateParameter(
7358  Param->getDepth(), Param->getTypeSourceInfo()->getTypeLoc());
7359  if (ParamUseRange.isValid()) {
7360  S.Diag(IsDefaultArgument ? TemplateNameLoc : ArgExpr->getLocStart(),
7361  diag::err_dependent_typed_non_type_arg_in_partial_spec)
7362  << Param->getType();
7363  S.Diag(Param->getLocation(), diag::note_template_param_here)
7364  << (IsDefaultArgument ? ParamUseRange : SourceRange())
7365  << ParamUseRange;
7366  return true;
7367  }
7368  }
7369 
7370  return false;
7371 }
7372 
7373 /// Check the non-type template arguments of a class template
7374 /// partial specialization according to C++ [temp.class.spec]p9.
7375 ///
7376 /// \param TemplateNameLoc the location of the template name.
7377 /// \param PrimaryTemplate the template parameters of the primary class
7378 /// template.
7379 /// \param NumExplicit the number of explicitly-specified template arguments.
7380 /// \param TemplateArgs the template arguments of the class template
7381 /// partial specialization.
7382 ///
7383 /// \returns \c true if there was an error, \c false otherwise.
7385  SourceLocation TemplateNameLoc, TemplateDecl *PrimaryTemplate,
7386  unsigned NumExplicit, ArrayRef<TemplateArgument> TemplateArgs) {
7387  // We have to be conservative when checking a template in a dependent
7388  // context.
7389  if (PrimaryTemplate->getDeclContext()->isDependentContext())
7390  return false;
7391 
7392  TemplateParameterList *TemplateParams =
7393  PrimaryTemplate->getTemplateParameters();
7394  for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
7396  = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I));
7397  if (!Param)
7398  continue;
7399 
7400  if (CheckNonTypeTemplatePartialSpecializationArgs(*this, TemplateNameLoc,
7401  Param, &TemplateArgs[I],
7402  1, I >= NumExplicit))
7403  return true;
7404  }
7405 
7406  return false;
7407 }
7408 
7410  Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
7411  SourceLocation ModulePrivateLoc, TemplateIdAnnotation &TemplateId,
7412  const ParsedAttributesView &Attr,
7413  MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody) {
7414  assert(TUK != TUK_Reference && "References are not specializations");
7415 
7416  CXXScopeSpec &SS = TemplateId.SS;
7417 
7418  // NOTE: KWLoc is the location of the tag keyword. This will instead
7419  // store the location of the outermost template keyword in the declaration.
7420  SourceLocation TemplateKWLoc = TemplateParameterLists.size() > 0
7421  ? TemplateParameterLists[0]->getTemplateLoc() : KWLoc;
7422  SourceLocation TemplateNameLoc = TemplateId.TemplateNameLoc;
7423  SourceLocation LAngleLoc = TemplateId.LAngleLoc;
7424  SourceLocation RAngleLoc = TemplateId.RAngleLoc;
7425 
7426  // Find the class template we're specializing
7427  TemplateName Name = TemplateId.Template.get();
7428  ClassTemplateDecl *ClassTemplate
7429  = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());
7430 
7431  if (!ClassTemplate) {
7432  Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
7433  << (Name.getAsTemplateDecl() &&
7434  isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
7435  return true;
7436  }
7437 
7438  bool isMemberSpecialization = false;
7439  bool isPartialSpecialization = false;
7440 
7441  // Check the validity of the template headers that introduce this
7442  // template.
7443  // FIXME: We probably shouldn't complain about these headers for
7444  // friend declarations.
7445  bool Invalid = false;
7446  TemplateParameterList *TemplateParams =
7447  MatchTemplateParametersToScopeSpecifier(
7448  KWLoc, TemplateNameLoc, SS, &TemplateId,
7449  TemplateParameterLists, TUK == TUK_Friend, isMemberSpecialization,
7450  Invalid);
7451  if (Invalid)
7452  return true;
7453 
7454  if (TemplateParams && TemplateParams->size() > 0) {
7455  isPartialSpecialization = true;
7456 
7457  if (TUK == TUK_Friend) {
7458  Diag(KWLoc, diag::err_partial_specialization_friend)
7459  << SourceRange(LAngleLoc, RAngleLoc);
7460  return true;
7461  }
7462 
7463  // C++ [temp.class.spec]p10:
7464  // The template parameter list of a specialization shall not
7465  // contain default template argument values.
7466  for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
7467  Decl *Param = TemplateParams->getParam(I);
7468  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
7469  if (TTP->hasDefaultArgument()) {
7470  Diag(TTP->getDefaultArgumentLoc(),
7471  diag::err_default_arg_in_partial_spec);
7472  TTP->removeDefaultArgument();
7473  }
7474  } else if (NonTypeTemplateParmDecl *NTTP
7475  = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
7476  if (Expr *DefArg = NTTP->getDefaultArgument()) {
7477  Diag(NTTP->getDefaultArgumentLoc(),
7478  diag::err_default_arg_in_partial_spec)
7479  << DefArg->getSourceRange();
7480  NTTP->removeDefaultArgument();
7481  }
7482  } else {
7483  TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param);
7484  if (TTP->hasDefaultArgument()) {
7486  diag::err_default_arg_in_partial_spec)
7487  << TTP->getDefaultArgument().getSourceRange();
7488  TTP->removeDefaultArgument();
7489  }
7490  }
7491  }
7492  } else if (TemplateParams) {
7493  if (TUK == TUK_Friend)
7494  Diag(KWLoc, diag::err_template_spec_friend)
7496  SourceRange(TemplateParams->getTemplateLoc(),
7497  TemplateParams->getRAngleLoc()))
7498  << SourceRange(LAngleLoc, RAngleLoc);
7499  } else {
7500  assert(TUK == TUK_Friend && "should have a 'template<>' for this decl");
7501  }
7502 
7503  // Check that the specialization uses the same tag kind as the
7504  // original template.
7506  assert(Kind != TTK_Enum && "Invalid enum tag in class template spec!");
7507  if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
7508  Kind, TUK == TUK_Definition, KWLoc,
7509  ClassTemplate->getIdentifier())) {
7510  Diag(KWLoc, diag::err_use_with_wrong_tag)
7511  << ClassTemplate
7513  ClassTemplate->getTemplatedDecl()->getKindName());
7514  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
7515  diag::note_previous_use);
7516  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
7517  }
7518 
7519  // Translate the parser's template argument list in our AST format.
7520  TemplateArgumentListInfo TemplateArgs =
7521  makeTemplateArgumentListInfo(*this, TemplateId);
7522 
7523  // Check for unexpanded parameter packs in any of the template arguments.
7524  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
7525  if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
7526  UPPC_PartialSpecialization))
7527  return true;
7528 
7529  // Check that the template argument list is well-formed for this
7530  // template.
7532  if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
7533  TemplateArgs, false, Converted))
7534  return true;
7535 
7536  // Find the class template (partial) specialization declaration that
7537  // corresponds to these arguments.
7538  if (isPartialSpecialization) {
7539  if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, ClassTemplate,
7540  TemplateArgs.size(), Converted))
7541  return true;
7542 
7543  // FIXME: Move this to CheckTemplatePartialSpecializationArgs so we
7544  // also do it during instantiation.
7545  bool InstantiationDependent;
7546  if (!Name.isDependent() &&
7548  TemplateArgs.arguments(), InstantiationDependent)) {
7549  Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
7550  << ClassTemplate->getDeclName();
7551  isPartialSpecialization = false;
7552  }
7553  }
7554 
7555  void *InsertPos = nullptr;
7556  ClassTemplateSpecializationDecl *PrevDecl = nullptr;
7557 
7558  if (isPartialSpecialization)
7559  // FIXME: Template parameter list matters, too
7560  PrevDecl = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
7561  else
7562  PrevDecl = ClassTemplate->findSpecialization(Converted, InsertPos);
7563 
7564  ClassTemplateSpecializationDecl *Specialization = nullptr;
7565 
7566  // Check whether we can declare a class template specialization in
7567  // the current scope.
7568  if (TUK != TUK_Friend &&
7569  CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl,
7570  TemplateNameLoc,
7571  isPartialSpecialization))
7572  return true;
7573 
7574  // The canonical type
7575  QualType CanonType;
7576  if (isPartialSpecialization) {
7577  // Build the canonical type that describes the converted template
7578  // arguments of the class template partial specialization.
7579  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
7580  CanonType = Context.getTemplateSpecializationType(CanonTemplate,
7581  Converted);
7582 
7583  if (Context.hasSameType(CanonType,
7584  ClassTemplate->getInjectedClassNameSpecialization())) {
7585  // C++ [temp.class.spec]p9b3:
7586  //
7587  // -- The argument list of the specialization shall not be identical
7588  // to the implicit argument list of the primary template.
7589  //
7590  // This rule has since been removed, because it's redundant given DR1495,
7591  // but we keep it because it produces better diagnostics and recovery.
7592  Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
7593  << /*class template*/0 << (TUK == TUK_Definition)
7594  << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
7595  return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
7596  ClassTemplate->getIdentifier(),
7597  TemplateNameLoc,
7598  Attr,
7599  TemplateParams,
7600  AS_none, /*ModulePrivateLoc=*/SourceLocation(),
7601  /*FriendLoc*/SourceLocation(),
7602  TemplateParameterLists.size() - 1,
7603  TemplateParameterLists.data());
7604  }
7605 
7606  // Create a new class template partial specialization declaration node.
7608  = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
7611  ClassTemplate->getDeclContext(),
7612  KWLoc, TemplateNameLoc,
7613  TemplateParams,
7614  ClassTemplate,
7615  Converted,
7616  TemplateArgs,
7617  CanonType,
7618  PrevPartial);
7619  SetNestedNameSpecifier(Partial, SS);
7620  if (TemplateParameterLists.size() > 1 && SS.isSet()) {
7621  Partial->setTemplateParameterListsInfo(
7622  Context, TemplateParameterLists.drop_back(1));
7623  }
7624 
7625  if (!PrevPartial)
7626  ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
7627  Specialization = Partial;
7628 
7629  // If we are providing an explicit specialization of a member class
7630  // template specialization, make a note of that.
7631  if (PrevPartial && PrevPartial->getInstantiatedFromMember())
7632  PrevPartial->setMemberSpecialization();
7633 
7634  CheckTemplatePartialSpecialization(Partial);
7635  } else {
7636  // Create a new class template specialization declaration node for
7637  // this explicit specialization or friend declaration.
7638  Specialization
7640  ClassTemplate->getDeclContext(),
7641  KWLoc, TemplateNameLoc,
7642  ClassTemplate,
7643  Converted,
7644  PrevDecl);
7645  SetNestedNameSpecifier(Specialization, SS);
7646  if (TemplateParameterLists.size() > 0) {
7647  Specialization->setTemplateParameterListsInfo(Context,
7648  TemplateParameterLists);
7649  }
7650 
7651  if (!PrevDecl)
7652  ClassTemplate->AddSpecialization(Specialization, InsertPos);
7653 
7654  if (CurContext->isDependentContext()) {
7655  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
7656  CanonType = Context.getTemplateSpecializationType(
7657  CanonTemplate, Converted);
7658  } else {
7659  CanonType = Context.getTypeDeclType(Specialization);
7660  }
7661  }
7662 
7663  // C++ [temp.expl.spec]p6:
7664  // If a template, a member template or the member of a class template is
7665  // explicitly specialized then that specialization shall be declared
7666  // before the first use of that specialization that would cause an implicit
7667  // instantiation to take place, in every translation unit in which such a
7668  // use occurs; no diagnostic is required.
7669  if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
7670  bool Okay = false;
7671  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
7672  // Is there any previous explicit specialization declaration?
7674  Okay = true;
7675  break;
7676  }
7677  }
7678 
7679  if (!Okay) {
7680  SourceRange Range(TemplateNameLoc, RAngleLoc);
7681  Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
7682  << Context.getTypeDeclType(Specialization) << Range;
7683 
7684  Diag(PrevDecl->getPointOfInstantiation(),
7685  diag::note_instantiation_required_here)
7686  << (PrevDecl->getTemplateSpecializationKind()
7688  return true;
7689  }
7690  }
7691 
7692  // If this is not a friend, note that this is an explicit specialization.
7693  if (TUK != TUK_Friend)
7695 
7696  // Check that this isn't a redefinition of this specialization.
7697  if (TUK == TUK_Definition) {
7698  RecordDecl *Def = Specialization->getDefinition();
7699  NamedDecl *Hidden = nullptr;
7700  if (Def && SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
7701  SkipBody->ShouldSkip = true;
7702  makeMergedDefinitionVisible(Hidden);
7703  // From here on out, treat this as just a redeclaration.
7704  TUK = TUK_Declaration;
7705  } else if (Def) {
7706  SourceRange Range(TemplateNameLoc, RAngleLoc);
7707  Diag(TemplateNameLoc, diag::err_redefinition) << Specialization << Range;
7708  Diag(Def->getLocation(), diag::note_previous_definition);
7709  Specialization->setInvalidDecl();
7710  return true;
7711  }
7712  }
7713 
7714  ProcessDeclAttributeList(S, Specialization, Attr);
7715 
7716  // Add alignment attributes if necessary; these attributes are checked when
7717  // the ASTContext lays out the structure.
7718  if (TUK == TUK_Definition) {
7719  AddAlignmentAttributesForRecord(Specialization);
7720  AddMsStructLayoutForRecord(Specialization);
7721  }
7722 
7723  if (ModulePrivateLoc.isValid())
7724  Diag(Specialization->getLocation(), diag::err_module_private_specialization)
7725  << (isPartialSpecialization? 1 : 0)
7726  << FixItHint::CreateRemoval(ModulePrivateLoc);
7727 
7728  // Build the fully-sugared type for this class template
7729  // specialization as the user wrote in the specialization
7730  // itself. This means that we'll pretty-print the type retrieved
7731  // from the specialization's declaration the way that the user
7732  // actually wrote the specialization, rather than formatting the
7733  // name based on the "canonical" representation used to store the
7734  // template arguments in the specialization.
7735  TypeSourceInfo *WrittenTy
7736  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
7737  TemplateArgs, CanonType);
7738  if (TUK != TUK_Friend) {
7739  Specialization->setTypeAsWritten(WrittenTy);
7740  Specialization->setTemplateKeywordLoc(TemplateKWLoc);
7741  }
7742 
7743  // C++ [temp.expl.spec]p9:
7744  // A template explicit specialization is in the scope of the
7745  // namespace in which the template was defined.
7746  //
7747  // We actually implement this paragraph where we set the semantic
7748  // context (in the creation of the ClassTemplateSpecializationDecl),
7749  // but we also maintain the lexical context where the actual
7750  // definition occurs.
7751  Specialization->setLexicalDeclContext(CurContext);
7752 
7753  // We may be starting the definition of this specialization.
7754  if (TUK == TUK_Definition)
7755  Specialization->startDefinition();
7756 
7757  if (TUK == TUK_Friend) {
7758  FriendDecl *Friend = FriendDecl::Create(Context, CurContext,
7759  TemplateNameLoc,
7760  WrittenTy,
7761  /*FIXME:*/KWLoc);
7762  Friend->setAccess(AS_public);
7763  CurContext->addDecl(Friend);
7764  } else {
7765  // Add the specialization into its lexical context, so that it can
7766  // be seen when iterating through the list of declarations in that
7767  // context. However, specializations are not found by name lookup.
7768  CurContext->addDecl(Specialization);
7769  }
7770  return Specialization;
7771 }
7772 
7774  MultiTemplateParamsArg TemplateParameterLists,
7775  Declarator &D) {
7776  Decl *NewDecl = HandleDeclarator(S, D, TemplateParameterLists);
7777  ActOnDocumentableDecl(NewDecl);
7778  return NewDecl;
7779 }
7780 
7781 /// Strips various properties off an implicit instantiation
7782 /// that has just been explicitly specialized.
7784  D->dropAttr<DLLImportAttr>();
7785  D->dropAttr<DLLExportAttr>();
7786 
7787  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
7788  FD->setInlineSpecified(false);
7789 }
7790 
7791 /// Compute the diagnostic location for an explicit instantiation
7792 // declaration or definition.
7794  NamedDecl* D, SourceLocation PointOfInstantiation) {
7795  // Explicit instantiations following a specialization have no effect and
7796  // hence no PointOfInstantiation. In that case, walk decl backwards
7797  // until a valid name loc is found.
7798  SourceLocation PrevDiagLoc = PointOfInstantiation;
7799  for (Decl *Prev = D; Prev && !PrevDiagLoc.isValid();
7800  Prev = Prev->getPreviousDecl()) {
7801  PrevDiagLoc = Prev->getLocation();
7802  }
7803  assert(PrevDiagLoc.isValid() &&
7804  "Explicit instantiation without point of instantiation?");
7805  return PrevDiagLoc;
7806 }
7807 
7808 /// Diagnose cases where we have an explicit template specialization
7809 /// before/after an explicit template instantiation, producing diagnostics
7810 /// for those cases where they are required and determining whether the
7811 /// new specialization/instantiation will have any effect.
7812 ///
7813 /// \param NewLoc the location of the new explicit specialization or
7814 /// instantiation.
7815 ///
7816 /// \param NewTSK the kind of the new explicit specialization or instantiation.
7817 ///
7818 /// \param PrevDecl the previous declaration of the entity.
7819 ///
7820 /// \param PrevTSK the kind of the old explicit specialization or instantiatin.
7821 ///
7822 /// \param PrevPointOfInstantiation if valid, indicates where the previus
7823 /// declaration was instantiated (either implicitly or explicitly).
7824 ///
7825 /// \param HasNoEffect will be set to true to indicate that the new
7826 /// specialization or instantiation has no effect and should be ignored.
7827 ///
7828 /// \returns true if there was an error that should prevent the introduction of
7829 /// the new declaration into the AST, false otherwise.
7830 bool
7833  NamedDecl *PrevDecl,
7835  SourceLocation PrevPointOfInstantiation,
7836  bool &HasNoEffect) {
7837  HasNoEffect = false;
7838 
7839  switch (NewTSK) {
7840  case TSK_Undeclared:
7842  assert(
7843  (PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) &&
7844  "previous declaration must be implicit!");
7845  return false;
7846 
7848  switch (PrevTSK) {
7849  case TSK_Undeclared:
7851  // Okay, we're just specializing something that is either already
7852  // explicitly specialized or has merely been mentioned without any
7853  // instantiation.
7854  return false;
7855 
7857  if (PrevPointOfInstantiation.isInvalid()) {
7858  // The declaration itself has not actually been instantiated, so it is
7859  // still okay to specialize it.
7860  StripImplicitInstantiation(PrevDecl);
7861  return false;
7862  }
7863  // Fall through
7864  LLVM_FALLTHROUGH;
7865 
7868  assert((PrevTSK == TSK_ImplicitInstantiation ||
7869  PrevPointOfInstantiation.isValid()) &&
7870  "Explicit instantiation without point of instantiation?");
7871 
7872  // C++ [temp.expl.spec]p6:
7873  // If a template, a member template or the member of a class template
7874  // is explicitly specialized then that specialization shall be declared
7875  // before the first use of that specialization that would cause an
7876  // implicit instantiation to take place, in every translation unit in
7877  // which such a use occurs; no diagnostic is required.
7878  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
7879  // Is there any previous explicit specialization declaration?
7881  return false;
7882  }
7883 
7884  Diag(NewLoc, diag::err_specialization_after_instantiation)
7885  << PrevDecl;
7886  Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
7887  << (PrevTSK != TSK_ImplicitInstantiation);
7888 
7889  return true;
7890  }
7891  llvm_unreachable("The switch over PrevTSK must be exhaustive.");
7892 
7894  switch (PrevTSK) {
7896  // This explicit instantiation declaration is redundant (that's okay).
7897  HasNoEffect = true;
7898  return false;
7899 
7900  case TSK_Undeclared:
7902  // We're explicitly instantiating something that may have already been
7903  // implicitly instantiated; that's fine.
7904  return false;
7905 
7907  // C++0x [temp.explicit]p4:
7908  // For a given set of template parameters, if an explicit instantiation
7909  // of a template appears after a declaration of an explicit
7910  // specialization for that template, the explicit instantiation has no
7911  // effect.
7912  HasNoEffect = true;
7913  return false;
7914 
7916  // C++0x [temp.explicit]p10:
7917  // If an entity is the subject of both an explicit instantiation
7918  // declaration and an explicit instantiation definition in the same
7919  // translation unit, the definition shall follow the declaration.
7920  Diag(NewLoc,
7921  diag::err_explicit_instantiation_declaration_after_definition);
7922 
7923  // Explicit instantiations following a specialization have no effect and
7924  // hence no PrevPointOfInstantiation. In that case, walk decl backwards
7925  // until a valid name loc is found.
7926  Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
7927  diag::note_explicit_instantiation_definition_here);
7928  HasNoEffect = true;
7929  return false;
7930  }
7931 
7933  switch (PrevTSK) {
7934  case TSK_Undeclared:
7936  // We're explicitly instantiating something that may have already been
7937  // implicitly instantiated; that's fine.
7938  return false;
7939 
7941  // C++ DR 259, C++0x [temp.explicit]p4:
7942  // For a given set of template parameters, if an explicit
7943  // instantiation of a template appears after a declaration of
7944  // an explicit specialization for that template, the explicit
7945  // instantiation has no effect.
7946  Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
7947  << PrevDecl;
7948  Diag(PrevDecl->getLocation(),
7949  diag::note_previous_template_specialization);
7950  HasNoEffect = true;
7951  return false;
7952 
7954  // We're explicitly instantiating a definition for something for which we
7955  // were previously asked to suppress instantiations. That's fine.
7956 
7957  // C++0x [temp.explicit]p4:
7958  // For a given set of template parameters, if an explicit instantiation
7959  // of a template appears after a declaration of an explicit
7960  // specialization for that template, the explicit instantiation has no
7961  // effect.
7962  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
7963  // Is there any previous explicit specialization declaration?
7965  HasNoEffect = true;
7966  break;
7967  }
7968  }
7969 
7970  return false;
7971 
7973  // C++0x [temp.spec]p5:
7974  // For a given template and a given set of template-arguments,
7975  // - an explicit instantiation definition shall appear at most once
7976  // in a program,
7977 
7978  // MSVCCompat: MSVC silently ignores duplicate explicit instantiations.
7979  Diag(NewLoc, (getLangOpts().MSVCCompat)
7980  ? diag::ext_explicit_instantiation_duplicate
7981  : diag::err_explicit_instantiation_duplicate)
7982  << PrevDecl;
7983  Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
7984  diag::note_previous_explicit_instantiation);
7985  HasNoEffect = true;
7986  return false;
7987  }
7988  }
7989 
7990  llvm_unreachable("Missing specialization/instantiation case?");
7991 }
7992 
7993 /// Perform semantic analysis for the given dependent function
7994 /// template specialization.
7995 ///
7996 /// The only possible way to get a dependent function template specialization
7997 /// is with a friend declaration, like so:
7998 ///
7999 /// \code
8000 /// template <class T> void foo(T);
8001 /// template <class T> class A {
8002 /// friend void foo<>(T);
8003 /// };
8004 /// \endcode
8005 ///
8006 /// There really isn't any useful analysis we can do here, so we
8007 /// just store the information.
8008 bool
8010  const TemplateArgumentListInfo &ExplicitTemplateArgs,
8012  // Remove anything from Previous that isn't a function template in
8013  // the correct context.
8014  DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
8015  LookupResult::Filter F = Previous.makeFilter();
8016  enum DiscardReason { NotAFunctionTemplate, NotAMemberOfEnclosing };
8017  SmallVector<std::pair<DiscardReason, Decl *>, 8> DiscardedCandidates;
8018  while (F.hasNext()) {
8019  NamedDecl *D = F.next()->getUnderlyingDecl();
8020  if (!isa<FunctionTemplateDecl>(D)) {
8021  F.erase();
8022  DiscardedCandidates.push_back(std::make_pair(NotAFunctionTemplate, D));
8023  continue;
8024  }
8025 
8026  if (!FDLookupContext->InEnclosingNamespaceSetOf(
8027  D->getDeclContext()->getRedeclContext())) {
8028  F.erase();
8029  DiscardedCandidates.push_back(std::make_pair(NotAMemberOfEnclosing, D));
8030  continue;
8031  }
8032  }
8033  F.done();
8034 
8035  if (Previous.empty()) {
8036  Diag(FD->getLocation(),
8037  diag::err_dependent_function_template_spec_no_match);
8038  for (auto &P : DiscardedCandidates)
8039  Diag(P.second->getLocation(),
8040  diag::note_dependent_function_template_spec_discard_reason)
8041  << P.first;
8042  return true;
8043  }
8044 
8045  FD->setDependentTemplateSpecialization(Context, Previous.asUnresolvedSet(),
8046  ExplicitTemplateArgs);
8047  return false;
8048 }
8049 
8050 /// Perform semantic analysis for the given function template
8051 /// specialization.
8052 ///
8053 /// This routine performs all of the semantic analysis required for an
8054 /// explicit function template specialization. On successful completion,
8055 /// the function declaration \p FD will become a function template
8056 /// specialization.
8057 ///
8058 /// \param FD the function declaration, which will be updated to become a
8059 /// function template specialization.
8060 ///
8061 /// \param ExplicitTemplateArgs the explicitly-provided template arguments,
8062 /// if any. Note that this may be valid info even when 0 arguments are
8063 /// explicitly provided as in, e.g., \c void sort<>(char*, char*);
8064 /// as it anyway contains info on the angle brackets locations.
8065 ///
8066 /// \param Previous the set of declarations that may be specialized by
8067 /// this function specialization.
8069  FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
8071  // The set of function template specializations that could match this
8072  // explicit function template specialization.
8073  UnresolvedSet<8> Candidates;
8074  TemplateSpecCandidateSet FailedCandidates(FD->getLocation(),
8075  /*ForTakingAddress=*/false);
8076 
8077  llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
8078  ConvertedTemplateArgs;
8079 
8080  DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
8081  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
8082  I != E; ++I) {
8083  NamedDecl *Ovl = (*I)->getUnderlyingDecl();
8084  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) {
8085  // Only consider templates found within the same semantic lookup scope as
8086  // FD.
8087  if (!FDLookupContext->InEnclosingNamespaceSetOf(
8088  Ovl->getDeclContext()->getRedeclContext()))
8089  continue;
8090 
8091  // When matching a constexpr member function template specialization
8092  // against the primary template, we don't yet know whether the
8093  // specialization has an implicit 'const' (because we don't know whether
8094  // it will be a static member function until we know which template it
8095  // specializes), so adjust it now assuming it specializes this template.
8096  QualType FT = FD->getType();
8097  if (FD->isConstexpr()) {
8098  CXXMethodDecl *OldMD =
8099  dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
8100  if (OldMD && OldMD->isConst()) {
8101  const FunctionProtoType *FPT = FT->castAs<FunctionProtoType>();
8104  FT = Context.getFunctionType(FPT->getReturnType(),
8105  FPT->getParamTypes(), EPI);
8106  }
8107  }
8108 
8110  if (ExplicitTemplateArgs)
8111  Args = *ExplicitTemplateArgs;
8112 
8113  // C++ [temp.expl.spec]p11:
8114  // A trailing template-argument can be left unspecified in the
8115  // template-id naming an explicit function template specialization
8116  // provided it can be deduced from the function argument type.
8117  // Perform template argument deduction to determine whether we may be
8118  // specializing this template.
8119  // FIXME: It is somewhat wasteful to build
8120  TemplateDeductionInfo Info(FailedCandidates.getLocation());
8121  FunctionDecl *Specialization = nullptr;
8123  cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
8124  ExplicitTemplateArgs ? &Args : nullptr, FT, Specialization,
8125  Info)) {
8126  // Template argument deduction failed; record why it failed, so
8127  // that we can provide nifty diagnostics.
8128  FailedCandidates.addCandidate().set(
8129  I.getPair(), FunTmpl->getTemplatedDecl(),
8130  MakeDeductionFailureInfo(Context, TDK, Info));
8131  (void)TDK;
8132  continue;
8133  }
8134 
8135  // Target attributes are part of the cuda function signature, so
8136  // the deduced template's cuda target must match that of the
8137  // specialization. Given that C++ template deduction does not
8138  // take target attributes into account, we reject candidates
8139  // here that have a different target.
8140  if (LangOpts.CUDA &&
8141  IdentifyCUDATarget(Specialization,
8142  /* IgnoreImplicitHDAttributes = */ true) !=
8143  IdentifyCUDATarget(FD, /* IgnoreImplicitHDAttributes = */ true)) {
8144  FailedCandidates.addCandidate().set(
8145  I.getPair(), FunTmpl->getTemplatedDecl(),
8146  MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
8147  continue;
8148  }
8149 
8150  // Record this candidate.
8151  if (ExplicitTemplateArgs)
8152  ConvertedTemplateArgs[Specialization] = std::move(Args);
8153  Candidates.addDecl(Specialization, I.getAccess());
8154  }
8155  }
8156 
8157  // Find the most specialized function template.
8158  UnresolvedSetIterator Result = getMostSpecialized(
8159  Candidates.begin(), Candidates.end(), FailedCandidates,
8160  FD->getLocation(),
8161  PDiag(diag::err_function_template_spec_no_match) << FD->getDeclName(),
8162  PDiag(diag::err_function_template_spec_ambiguous)
8163  << FD->getDeclName() << (ExplicitTemplateArgs != nullptr),
8164  PDiag(diag::note_function_template_spec_matched));
8165 
8166  if (Result == Candidates.end())
8167  return true;
8168 
8169  // Ignore access information; it doesn't figure into redeclaration checking.
8170  FunctionDecl *Specialization = cast<FunctionDecl>(*Result);
8171 
8173  = Specialization->getTemplateSpecializationInfo();
8174  assert(SpecInfo && "Function template specialization info missing?");
8175 
8176  // Note: do not overwrite location info if previous template
8177  // specialization kind was explicit.
8179  if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation) {
8180  Specialization->setLocation(FD->getLocation());
8181  Specialization->setLexicalDeclContext(FD->getLexicalDeclContext());
8182  // C++11 [dcl.constexpr]p1: An explicit specialization of a constexpr
8183  // function can differ from the template declaration with respect to
8184  // the constexpr specifier.
8185  // FIXME: We need an update record for this AST mutation.
8186  // FIXME: What if there are multiple such prior declarations (for instance,
8187  // from different modules)?
8188  Specialization->setConstexpr(FD->isConstexpr());
8189  }
8190 
8191  // FIXME: Check if the prior specialization has a point of instantiation.
8192  // If so, we have run afoul of .
8193 
8194  // If this is a friend declaration, then we're not really declaring
8195  // an explicit specialization.
8196  bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None);
8197 
8198  // Check the scope of this explicit specialization.
8199  if (!isFriend &&
8201  Specialization->getPrimaryTemplate(),
8202  Specialization, FD->getLocation(),
8203  false))
8204  return true;
8205 
8206  // C++ [temp.expl.spec]p6:
8207  // If a template, a member template or the member of a class template is
8208  // explicitly specialized then that specialization shall be declared
8209  // before the first use of that specialization that would cause an implicit
8210  // instantiation to take place, in every translation unit in which such a
8211  // use occurs; no diagnostic is required.
8212  bool HasNoEffect = false;
8213  if (!isFriend &&
8214  CheckSpecializationInstantiationRedecl(FD->getLocation(),
8216  Specialization,
8217  SpecInfo->getTemplateSpecializationKind(),
8218  SpecInfo->getPointOfInstantiation(),
8219  HasNoEffect))
8220  return true;
8221 
8222  // Mark the prior declaration as an explicit specialization, so that later
8223  // clients know that this is an explicit specialization.
8224  if (!isFriend) {
8225  // Since explicit specializations do not inherit '=delete' from their
8226  // primary function template - check if the 'specialization' that was
8227  // implicitly generated (during template argument deduction for partial
8228  // ordering) from the most specialized of all the function templates that
8229  // 'FD' could have been specializing, has a 'deleted' definition. If so,
8230  // first check that it was implicitly generated during template argument
8231  // deduction by making sure it wasn't referenced, and then reset the deleted
8232  // flag to not-deleted, so that we can inherit that information from 'FD'.
8233  if (Specialization->isDeleted() && !SpecInfo->isExplicitSpecialization() &&
8234  !Specialization->getCanonicalDecl()->isReferenced()) {
8235  // FIXME: This assert will not hold in the presence of modules.
8236  assert(
8237  Specialization->getCanonicalDecl() == Specialization &&
8238  "This must be the only existing declaration of this specialization");
8239  // FIXME: We need an update record for this AST mutation.
8240  Specialization->setDeletedAsWritten(false);
8241  }
8242  // FIXME: We need an update record for this AST mutation.
8244  MarkUnusedFileScopedDecl(Specialization);
8245  }
8246 
8247  // Turn the given function declaration into a function template
8248  // specialization, with the template arguments from the previous
8249  // specialization.
8250  // Take copies of (semantic and syntactic) template argument lists.
8251  const TemplateArgumentList* TemplArgs = new (Context)
8252  TemplateArgumentList(Specialization->getTemplateSpecializationArgs());
8253  FD->setFunctionTemplateSpecialization(
8254  Specialization->getPrimaryTemplate(), TemplArgs, /*InsertPos=*/nullptr,
8255  SpecInfo->getTemplateSpecializationKind(),
8256  ExplicitTemplateArgs ? &ConvertedTemplateArgs[Specialization] : nullptr);
8257 
8258  // A function template specialization inherits the target attributes
8259  // of its template. (We require the attributes explicitly in the
8260  // code to match, but a template may have implicit attributes by
8261  // virtue e.g. of being constexpr, and it passes these implicit
8262  // attributes on to its specializations.)
8263  if (LangOpts.CUDA)
8264  inheritCUDATargetAttrs(FD, *Specialization->getPrimaryTemplate());
8265 
8266  // The "previous declaration" for this function template specialization is
8267  // the prior function template specialization.
8268  Previous.clear();
8269  Previous.addDecl(Specialization);
8270  return false;
8271 }
8272 
8273 /// Perform semantic analysis for the given non-template member
8274 /// specialization.
8275 ///
8276 /// This routine performs all of the semantic analysis required for an
8277 /// explicit member function specialization. On successful completion,
8278 /// the function declaration \p FD will become a member function
8279 /// specialization.
8280 ///
8281 /// \param Member the member declaration, which will be updated to become a
8282 /// specialization.
8283 ///
8284 /// \param Previous the set of declarations, one of which may be specialized
8285 /// by this function specialization; the set will be modified to contain the
8286 /// redeclared member.
8287 bool
8289  assert(!isa<TemplateDecl>(Member) && "Only for non-template members");
8290 
8291  // Try to find the member we are instantiating.
8292  NamedDecl *FoundInstantiation = nullptr;
8293  NamedDecl *Instantiation = nullptr;
8294  NamedDecl *InstantiatedFrom = nullptr;
8295  MemberSpecializationInfo *MSInfo = nullptr;
8296 
8297  if (Previous.empty()) {
8298  // Nowhere to look anyway.
8299  } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Member)) {
8300  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
8301  I != E; ++I) {
8302  NamedDecl *D = (*I)->getUnderlyingDecl();
8303  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
8304  QualType Adjusted = Function->getType();
8305  if (!hasExplicitCallingConv(Adjusted))
8306  Adjusted = adjustCCAndNoReturn(Adjusted, Method->getType());
8307  if (Context.hasSameType(Adjusted, Method->getType())) {
8308  FoundInstantiation = *I;
8309  Instantiation = Method;
8310  InstantiatedFrom = Method->getInstantiatedFromMemberFunction();
8311  MSInfo = Method->getMemberSpecializationInfo();
8312  break;
8313  }
8314  }
8315  }
8316  } else if (isa<VarDecl>(Member)) {
8317  VarDecl *PrevVar;
8318  if (Previous.isSingleResult() &&
8319  (PrevVar = dyn_cast<VarDecl>(Previous.getFoundDecl())))
8320  if (PrevVar->isStaticDataMember()) {
8321  FoundInstantiation = Previous.getRepresentativeDecl();
8322  Instantiation = PrevVar;
8323  InstantiatedFrom = PrevVar->getInstantiatedFromStaticDataMember();
8324  MSInfo = PrevVar->getMemberSpecializationInfo();
8325  }
8326  } else if (isa<RecordDecl>(Member)) {
8327  CXXRecordDecl *PrevRecord;
8328  if (Previous.isSingleResult() &&
8329  (PrevRecord = dyn_cast<CXXRecordDecl>(Previous.getFoundDecl()))) {
8330  FoundInstantiation = Previous.getRepresentativeDecl();
8331  Instantiation = PrevRecord;
8332  InstantiatedFrom = PrevRecord->getInstantiatedFromMemberClass();
8333  MSInfo = PrevRecord->getMemberSpecializationInfo();
8334  }
8335  } else if (isa<EnumDecl>(Member)) {
8336  EnumDecl *PrevEnum;
8337  if (Previous.isSingleResult() &&
8338  (PrevEnum = dyn_cast<EnumDecl>(Previous.getFoundDecl()))) {
8339  FoundInstantiation = Previous.getRepresentativeDecl();
8340  Instantiation = PrevEnum;
8341  InstantiatedFrom = PrevEnum->getInstantiatedFromMemberEnum();
8342  MSInfo = PrevEnum->getMemberSpecializationInfo();
8343  }
8344  }
8345 
8346  if (!Instantiation) {
8347  // There is no previous declaration that matches. Since member
8348  // specializations are always out-of-line, the caller will complain about
8349  // this mismatch later.
8350  return false;
8351  }
8352 
8353  // A member specialization in a friend declaration isn't really declaring
8354  // an explicit specialization, just identifying a specific (possibly implicit)
8355  // specialization. Don't change the template specialization kind.
8356  //
8357  // FIXME: Is this really valid? Other compilers reject.
8358  if (Member->getFriendObjectKind() != Decl::FOK_None) {
8359  // Preserve instantiation information.
8360  if (InstantiatedFrom && isa<CXXMethodDecl>(Member)) {
8361  cast<CXXMethodDecl>(Member)->setInstantiationOfMemberFunction(
8362  cast<CXXMethodDecl>(InstantiatedFrom),
8363  cast<CXXMethodDecl>(Instantiation)->getTemplateSpecializationKind());
8364  } else if (InstantiatedFrom && isa<CXXRecordDecl>(Member)) {
8365  cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
8366  cast<CXXRecordDecl>(InstantiatedFrom),
8367  cast<CXXRecordDecl>(Instantiation)->getTemplateSpecializationKind());
8368  }
8369 
8370  Previous.clear();
8371  Previous.addDecl(FoundInstantiation);
8372  return false;
8373  }
8374 
8375  // Make sure that this is a specialization of a member.
8376  if (!InstantiatedFrom) {
8377  Diag(Member->getLocation(), diag::err_spec_member_not_instantiated)
8378  << Member;
8379  Diag(Instantiation->getLocation(), diag::note_specialized_decl);
8380  return true;
8381  }
8382 
8383  // C++ [temp.expl.spec]p6:
8384  // If a template, a member template or the member of a class template is
8385  // explicitly specialized then that specialization shall be declared
8386  // before the first use of that specialization that would cause an implicit
8387  // instantiation to take place, in every translation unit in which such a
8388  // use occurs; no diagnostic is required.
8389  assert(MSInfo && "Member specialization info missing?");
8390 
8391  bool HasNoEffect = false;
8392  if (CheckSpecializationInstantiationRedecl(Member->getLocation(),
8394  Instantiation,
8396  MSInfo->getPointOfInstantiation(),
8397  HasNoEffect))
8398  return true;
8399 
8400  // Check the scope of this explicit specialization.
8402  InstantiatedFrom,
8403  Instantiation, Member->getLocation(),
8404  false))
8405  return true;
8406 
8407  // Note that this member specialization is an "instantiation of" the
8408  // corresponding member of the original template.
8409  if (auto *MemberFunction = dyn_cast<FunctionDecl>(Member)) {
8410  FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
8411  if (InstantiationFunction->getTemplateSpecializationKind() ==
8413  // Explicit specializations of member functions of class templates do not
8414  // inherit '=delete' from the member function they are specializing.
8415  if (InstantiationFunction->isDeleted()) {
8416  // FIXME: This assert will not hold in the presence of modules.
8417  assert(InstantiationFunction->getCanonicalDecl() ==
8418  InstantiationFunction);
8419  // FIXME: We need an update record for this AST mutation.
8420  InstantiationFunction->setDeletedAsWritten(false);
8421  }
8422  }
8423 
8424  MemberFunction->setInstantiationOfMemberFunction(
8425  cast<CXXMethodDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
8426  } else if (auto *MemberVar = dyn_cast<VarDecl>(Member)) {
8427  MemberVar->setInstantiationOfStaticDataMember(
8428  cast<VarDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
8429  } else if (auto *MemberClass = dyn_cast<CXXRecordDecl>(Member)) {
8430  MemberClass->setInstantiationOfMemberClass(
8431  cast<CXXRecordDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
8432  } else if (auto *MemberEnum = dyn_cast<EnumDecl>(Member)) {
8433  MemberEnum->setInstantiationOfMemberEnum(
8434  cast<EnumDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
8435  } else {
8436  llvm_unreachable("unknown member specialization kind");
8437  }
8438 
8439  // Save the caller the trouble of having to figure out which declaration
8440  // this specialization matches.
8441  Previous.clear();
8442  Previous.addDecl(FoundInstantiation);
8443  return false;
8444 }
8445 
8446 /// Complete the explicit specialization of a member of a class template by
8447 /// updating the instantiated member to be marked as an explicit specialization.
8448 ///
8449 /// \param OrigD The member declaration instantiated from the template.
8450 /// \param Loc The location of the explicit specialization of the member.
8451 template<typename DeclT>
8452 static void completeMemberSpecializationImpl(Sema &S, DeclT *OrigD,
8453  SourceLocation Loc) {
8454  if (OrigD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
8455  return;
8456 
8457  // FIXME: Inform AST mutation listeners of this AST mutation.
8458  // FIXME: If there are multiple in-class declarations of the member (from
8459  // multiple modules, or a declaration and later definition of a member type),
8460  // should we update all of them?
8461  OrigD->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
8462  OrigD->setLocation(Loc);
8463 }
8464 
8467  NamedDecl *Instantiation = cast<NamedDecl>(Member->getCanonicalDecl());
8468  if (Instantiation == Member)
8469  return;
8470 
8471  if (auto *Function = dyn_cast<CXXMethodDecl>(Instantiation))
8472  completeMemberSpecializationImpl(*this, Function, Member->getLocation());
8473  else if (auto *Var = dyn_cast<VarDecl>(Instantiation))
8474  completeMemberSpecializationImpl(*this, Var, Member->getLocation());
8475  else if (auto *Record = dyn_cast<CXXRecordDecl>(Instantiation))
8476  completeMemberSpecializationImpl(*this, Record, Member->getLocation());
8477  else if (auto *Enum = dyn_cast<EnumDecl>(Instantiation))
8478  completeMemberSpecializationImpl(*this, Enum, Member->getLocation());
8479  else
8480  llvm_unreachable("unknown member specialization kind");
8481 }
8482 
8483 /// Check the scope of an explicit instantiation.
8484 ///
8485 /// \returns true if a serious error occurs, false otherwise.
8487  SourceLocation InstLoc,
8488  bool WasQualifiedName) {
8490  DeclContext *CurContext = S.CurContext->getRedeclContext();
8491 
8492  if (CurContext->isRecord()) {
8493  S.Diag(InstLoc, diag::err_explicit_instantiation_in_class)
8494  << D;
8495  return true;
8496  }
8497 
8498  // C++11 [temp.explicit]p3:
8499  // An explicit instantiation shall appear in an enclosing namespace of its
8500  // template. If the name declared in the explicit instantiation is an
8501  // unqualified name, the explicit instantiation shall appear in the
8502  // namespace where its template is declared or, if that namespace is inline
8503  // (7.3.1), any namespace from its enclosing namespace set.
8504  //
8505  // This is DR275, which we do not retroactively apply to C++98/03.
8506  if (WasQualifiedName) {
8507  if (CurContext->Encloses(OrigContext))
8508  return false;
8509  } else {
8510  if (CurContext->InEnclosingNamespaceSetOf(OrigContext))
8511  return false;
8512  }
8513 
8514  if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
8515  if (WasQualifiedName)
8516  S.Diag(InstLoc,
8517  S.getLangOpts().CPlusPlus11?
8518  diag::err_explicit_instantiation_out_of_scope :
8519  diag::warn_explicit_instantiation_out_of_scope_0x)
8520  << D << NS;
8521  else
8522  S.Diag(InstLoc,
8523  S.getLangOpts().CPlusPlus11?
8524  diag::err_explicit_instantiation_unqualified_wrong_namespace :
8525  diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
8526  << D << NS;
8527  } else
8528  S.Diag(InstLoc,
8529  S.getLangOpts().CPlusPlus11?
8530  diag::err_explicit_instantiation_must_be_global :
8531  diag::warn_explicit_instantiation_must_be_global_0x)
8532  << D;
8533  S.Diag(D->getLocation(), diag::note_explicit_instantiation_here);
8534  return false;
8535 }
8536 
8537 /// Determine whether the given scope specifier has a template-id in it.
8539  if (!SS.isSet())
8540  return false;
8541 
8542  // C++11 [temp.explicit]p3:
8543  // If the explicit instantiation is for a member function, a member class
8544  // or a static data member of a class template specialization, the name of
8545  // the class template specialization in the qualified-id for the member
8546  // name shall be a simple-template-id.
8547  //
8548  // C++98 has the same restriction, just worded differently.
8549  for (NestedNameSpecifier *NNS = SS.getScopeRep(); NNS;
8550  NNS = NNS->getPrefix())
8551  if (const Type *T = NNS->getAsType())
8552  if (isa<TemplateSpecializationType>(T))
8553  return true;
8554 
8555  return false;
8556 }
8557 
8558 /// Make a dllexport or dllimport attr on a class template specialization take
8559 /// effect.
8562  auto *A = cast_or_null<InheritableAttr>(getDLLAttr(Def));
8563  assert(A && "dllExportImportClassTemplateSpecialization called "
8564  "on Def without dllexport or dllimport");
8565 
8566  // We reject explicit instantiations in class scope, so there should
8567  // never be any delayed exported classes to worry about.
8568  assert(S.DelayedDllExportClasses.empty() &&
8569  "delayed exports present at explicit instantiation");
8571 
8572  // Propagate attribute to base class templates.
8573  for (auto &B : Def->bases()) {
8574  if (auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
8575  B.getType()->getAsCXXRecordDecl()))
8577  }
8578 
8580 }
8581 
8582 // Explicit instantiation of a class template specialization
8584  Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc,
8585  unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS,
8586  TemplateTy TemplateD, SourceLocation TemplateNameLoc,
8587  SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn,
8588  SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {
8589  // Find the class template we're specializing
8590  TemplateName Name = TemplateD.get();
8591  TemplateDecl *TD = Name.getAsTemplateDecl();
8592  // Check that the specialization uses the same tag kind as the
8593  // original template.
8595  assert(Kind != TTK_Enum &&
8596  "Invalid enum tag in class template explicit instantiation!");
8597 
8598  ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(TD);
8599 
8600  if (!ClassTemplate) {
8601  NonTagKind NTK = getNonTagTypeDeclKind(TD, Kind);
8602  Diag(TemplateNameLoc, diag::err_tag_reference_non_tag) << TD << NTK << Kind;
8603  Diag(TD->getLocation(), diag::note_previous_use);
8604  return true;
8605  }
8606 
8607  if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
8608  Kind, /*isDefinition*/false, KWLoc,
8609  ClassTemplate->getIdentifier())) {
8610  Diag(KWLoc, diag::err_use_with_wrong_tag)
8611  << ClassTemplate
8613  ClassTemplate->getTemplatedDecl()->getKindName());
8614  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
8615  diag::note_previous_use);
8616  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
8617  }
8618 
8619  // C++0x [temp.explicit]p2:
8620  // There are two forms of explicit instantiation: an explicit instantiation
8621  // definition and an explicit instantiation declaration. An explicit
8622  // instantiation declaration begins with the extern keyword. [...]
8623  TemplateSpecializationKind TSK = ExternLoc.isInvalid()
8626 
8628  // Check for dllexport class template instantiation declarations.
8629  for (const ParsedAttr &AL : Attr) {
8630  if (AL.getKind() == ParsedAttr::AT_DLLExport) {
8631  Diag(ExternLoc,
8632  diag::warn_attribute_dllexport_explicit_instantiation_decl);
8633  Diag(AL.getLoc(), diag::note_attribute);
8634  break;
8635  }
8636  }
8637 
8638  if (auto *A = ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
8639  Diag(ExternLoc,
8640  diag::warn_attribute_dllexport_explicit_instantiation_decl);
8641  Diag(A->getLocation(), diag::note_attribute);
8642  }
8643  }
8644 
8645  // In MSVC mode, dllimported explicit instantiation definitions are treated as
8646  // instantiation declarations for most purposes.
8647  bool DLLImportExplicitInstantiationDef = false;
8649  Context.getTargetInfo().getCXXABI().isMicrosoft()) {
8650  // Check for dllimport class template instantiation definitions.
8651  bool DLLImport =
8652  ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
8653  for (const ParsedAttr &AL : Attr) {
8654  if (AL.getKind() == ParsedAttr::AT_DLLImport)
8655  DLLImport = true;
8656  if (AL.getKind() == ParsedAttr::AT_DLLExport) {
8657  // dllexport trumps dllimport here.
8658  DLLImport = false;
8659  break;
8660  }
8661  }
8662  if (DLLImport) {
8664  DLLImportExplicitInstantiationDef = true;
8665  }
8666  }
8667 
8668  // Translate the parser's template argument list in our AST format.
8669  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
8670  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
8671 
8672  // Check that the template argument list is well-formed for this
8673  // template.
8675  if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
8676  TemplateArgs, false, Converted))
8677  return true;
8678 
8679  // Find the class template specialization declaration that
8680  // corresponds to these arguments.
8681  void *InsertPos = nullptr;
8683  = ClassTemplate->findSpecialization(Converted, InsertPos);
8684 
8685  TemplateSpecializationKind PrevDecl_TSK
8686  = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared;
8687 
8688  // C++0x [temp.explicit]p2:
8689  // [...] An explicit instantiation shall appear in an enclosing
8690  // namespace of its template. [...]
8691  //
8692  // This is C++ DR 275.
8693  if (CheckExplicitInstantiationScope(*this, ClassTemplate, TemplateNameLoc,
8694  SS.isSet()))
8695  return true;
8696 
8697  ClassTemplateSpecializationDecl *Specialization = nullptr;
8698 
8699  bool HasNoEffect = false;
8700  if (PrevDecl) {
8701  if (CheckSpecializationInstantiationRedecl(TemplateNameLoc, TSK,
8702  PrevDecl, PrevDecl_TSK,
8703  PrevDecl->getPointOfInstantiation(),
8704  HasNoEffect))
8705  return PrevDecl;
8706 
8707  // Even though HasNoEffect == true means that this explicit instantiation
8708  // has no effect on semantics, we go on to put its syntax in the AST.
8709 
8710  if (PrevDecl_TSK == TSK_ImplicitInstantiation ||
8711  PrevDecl_TSK == TSK_Undeclared) {
8712  // Since the only prior class template specialization with these
8713  // arguments was referenced but not declared, reuse that
8714  // declaration node as our own, updating the source location
8715  // for the template name to reflect our new declaration.
8716  // (Other source locations will be updated later.)
8717  Specialization = PrevDecl;
8718  Specialization->setLocation(TemplateNameLoc);
8719  PrevDecl = nullptr;
8720  }
8721 
8722  if (PrevDecl_TSK == TSK_ExplicitInstantiationDeclaration &&
8723  DLLImportExplicitInstantiationDef) {
8724  // The new specialization might add a dllimport attribute.
8725  HasNoEffect = false;
8726  }
8727  }
8728 
8729  if (!Specialization) {
8730  // Create a new class template specialization declaration node for
8731  // this explicit specialization.
8732  Specialization
8734  ClassTemplate->getDeclContext(),
8735  KWLoc, TemplateNameLoc,
8736  ClassTemplate,
8737  Converted,
8738  PrevDecl);
8739  SetNestedNameSpecifier(Specialization, SS);
8740 
8741  if (!HasNoEffect && !PrevDecl) {
8742  // Insert the new specialization.
8743  ClassTemplate->AddSpecialization(Specialization, InsertPos);
8744  }
8745  }
8746 
8747  // Build the fully-sugared type for this explicit instantiation as
8748  // the user wrote in the explicit instantiation itself. This means
8749  // that we'll pretty-print the type retrieved from the
8750  // specialization's declaration the way that the user actually wrote
8751  // the explicit instantiation, rather than formatting the name based
8752  // on the "canonical" representation used to store the template
8753  // arguments in the specialization.
8754  TypeSourceInfo *WrittenTy
8755  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
8756  TemplateArgs,
8757  Context.getTypeDeclType(Specialization));
8758  Specialization->setTypeAsWritten(WrittenTy);
8759 
8760  // Set source locations for keywords.
8761  Specialization->setExternLoc(ExternLoc);
8762  Specialization->setTemplateKeywordLoc(TemplateLoc);
8763  Specialization->setBraceRange(SourceRange());
8764 
8765  bool PreviouslyDLLExported = Specialization->hasAttr<DLLExportAttr>();
8766  ProcessDeclAttributeList(S, Specialization, Attr);
8767 
8768  // Add the explicit instantiation into its lexical context. However,
8769  // since explicit instantiations are never found by name lookup, we
8770  // just put it into the declaration context directly.
8771  Specialization->setLexicalDeclContext(CurContext);
8772  CurContext->addDecl(Specialization);
8773 
8774  // Syntax is now OK, so return if it has no other effect on semantics.
8775  if (HasNoEffect) {
8776  // Set the template specialization kind.
8777  Specialization->setTemplateSpecializationKind(TSK);
8778  return Specialization;
8779  }
8780 
8781  // C++ [temp.explicit]p3:
8782  // A definition of a class template or class member template
8783  // shall be in scope at the point of the explicit instantiation of
8784  // the class template or class member template.
8785  //
8786  // This check comes when we actually try to perform the
8787  // instantiation.
8789  = cast_or_null<ClassTemplateSpecializationDecl>(
8790  Specialization->getDefinition());
8791  if (!Def)
8792  InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK);
8793  else if (TSK == TSK_ExplicitInstantiationDefinition) {
8794  MarkVTableUsed(TemplateNameLoc, Specialization, true);
8795  Specialization->setPointOfInstantiation(Def->getPointOfInstantiation());
8796  }
8797 
8798  // Instantiate the members of this class template specialization.
8799  Def = cast_or_null<ClassTemplateSpecializationDecl>(
8800  Specialization->getDefinition());
8801  if (Def) {
8803  // Fix a TSK_ExplicitInstantiationDeclaration followed by a
8804  // TSK_ExplicitInstantiationDefinition
8805  if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
8807  DLLImportExplicitInstantiationDef)) {
8808  // FIXME: Need to notify the ASTMutationListener that we did this.
8810 
8811  if (!getDLLAttr(Def) && getDLLAttr(Specialization) &&
8812  (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
8813  Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
8814  // In the MS ABI, an explicit instantiation definition can add a dll
8815  // attribute to a template with a previous instantiation declaration.
8816  // MinGW doesn't allow this.
8817  auto *A = cast<InheritableAttr>(
8818  getDLLAttr(Specialization)->clone(getASTContext()));
8819  A->setInherited(true);
8820  Def->addAttr(A);
8822  }
8823  }
8824 
8825  // Fix a TSK_ImplicitInstantiation followed by a
8826  // TSK_ExplicitInstantiationDefinition
8827  bool NewlyDLLExported =
8828  !PreviouslyDLLExported && Specialization->hasAttr<DLLExportAttr>();
8829  if (Old_TSK == TSK_ImplicitInstantiation && NewlyDLLExported &&
8830  (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
8831  Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
8832  // In the MS ABI, an explicit instantiation definition can add a dll
8833  // attribute to a template with a previous implicit instantiation.
8834  // MinGW doesn't allow this. We limit clang to only adding dllexport, to
8835  // avoid potentially strange codegen behavior. For example, if we extend
8836  // this conditional to dllimport, and we have a source file calling a
8837  // method on an implicitly instantiated template class instance and then
8838  // declaring a dllimport explicit instantiation definition for the same
8839  // template class, the codegen for the method call will not respect the
8840  // dllimport, while it will with cl. The Def will already have the DLL
8841  // attribute, since the Def and Specialization will be the same in the
8842  // case of Old_TSK == TSK_ImplicitInstantiation, and we already added the
8843  // attribute to the Specialization; we just need to make it take effect.
8844  assert(Def == Specialization &&
8845  "Def and Specialization should match for implicit instantiation");
8847  }
8848 
8849  // Set the template specialization kind. Make sure it is set before
8850  // instantiating the members which will trigger ASTConsumer callbacks.
8851  Specialization->setTemplateSpecializationKind(TSK);
8852  InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK);
8853  } else {
8854 
8855  // Set the template specialization kind.
8856  Specialization->setTemplateSpecializationKind(TSK);
8857  }
8858 
8859  return Specialization;
8860 }
8861 
8862 // Explicit instantiation of a member class of a class template.
8863 DeclResult
8865  SourceLocation TemplateLoc, unsigned TagSpec,
8866  SourceLocation KWLoc, CXXScopeSpec &SS,
8867  IdentifierInfo *Name, SourceLocation NameLoc,
8868  const ParsedAttributesView &Attr) {
8869 
8870  bool Owned = false;
8871  bool IsDependent = false;
8872  Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference,
8873  KWLoc, SS, Name, NameLoc, Attr, AS_none,
8874  /*ModulePrivateLoc=*/SourceLocation(),
8875  MultiTemplateParamsArg(), Owned, IsDependent,
8876  SourceLocation(), false, TypeResult(),
8877  /*IsTypeSpecifier*/false,
8878  /*IsTemplateParamOrArg*/false);
8879  assert(!IsDependent && "explicit instantiation of dependent name not yet handled");
8880 
8881  if (!TagD)
8882  return true;
8883 
8884  TagDecl *Tag = cast<TagDecl>(TagD);
8885  assert(!Tag->isEnum() && "shouldn't see enumerations here");
8886 
8887  if (Tag->isInvalidDecl())
8888  return true;
8889 
8890  CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag);
8891  CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
8892  if (!Pattern) {
8893  Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
8894  << Context.getTypeDeclType(Record);
8895  Diag(Record->getLocation(), diag::note_nontemplate_decl_here);
8896  return true;
8897  }
8898 
8899  // C++0x [temp.explicit]p2:
8900  // If the explicit instantiation is for a class or member class, the
8901  // elaborated-type-specifier in the declaration shall include a
8902  // simple-template-id.
8903  //
8904  // C++98 has the same restriction, just worded differently.
8905  if (!ScopeSpecifierHasTemplateId(SS))
8906  Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
8907  << Record << SS.getRange();
8908 
8909  // C++0x [temp.explicit]p2:
8910  // There are two forms of explicit instantiation: an explicit instantiation
8911  // definition and an explicit instantiation declaration. An explicit
8912  // instantiation declaration begins with the extern keyword. [...]
8916 
8917  // C++0x [temp.explicit]p2:
8918  // [...] An explicit instantiation shall appear in an enclosing
8919  // namespace of its template. [...]
8920  //
8921  // This is C++ DR 275.
8922  CheckExplicitInstantiationScope(*this, Record, NameLoc, true);
8923 
8924  // Verify that it is okay to explicitly instantiate here.
8925  CXXRecordDecl *PrevDecl
8926  = cast_or_null<CXXRecordDecl>(Record->getPreviousDecl());
8927  if (!PrevDecl && Record->getDefinition())
8928  PrevDecl = Record;
8929  if (PrevDecl) {
8931  bool HasNoEffect = false;
8932  assert(MSInfo && "No member specialization information?");
8933  if (CheckSpecializationInstantiationRedecl(TemplateLoc, TSK,
8934  PrevDecl,
8936  MSInfo->getPointOfInstantiation(),
8937  HasNoEffect))
8938  return true;
8939  if (HasNoEffect)
8940  return TagD;
8941  }
8942 
8943  CXXRecordDecl *RecordDef
8944  = cast_or_null<CXXRecordDecl>(Record->getDefinition());
8945  if (!RecordDef) {
8946  // C++ [temp.explicit]p3:
8947  // A definition of a member class of a class template shall be in scope
8948  // at the point of an explicit instantiation of the member class.
8949  CXXRecordDecl *Def
8950  = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
8951  if (!Def) {
8952  Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
8953  << 0 << Record->getDeclName() << Record->getDeclContext();
8954  Diag(Pattern->getLocation(), diag::note_forward_declaration)
8955  << Pattern;
8956  return true;
8957  } else {
8958  if (InstantiateClass(NameLoc, Record, Def,
8959  getTemplateInstantiationArgs(Record),
8960  TSK))
8961  return true;
8962 
8963  RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition());
8964  if (!RecordDef)
8965  return true;
8966  }
8967  }
8968 
8969  // Instantiate all of the members of the class.
8970  InstantiateClassMembers(NameLoc, RecordDef,
8971  getTemplateInstantiationArgs(Record), TSK);
8972 
8974  MarkVTableUsed(NameLoc, RecordDef, true);
8975 
8976  // FIXME: We don't have any representation for explicit instantiations of
8977  // member classes. Such a representation is not needed for compilation, but it
8978  // should be available for clients that want to see all of the declarations in
8979  // the source code.
8980  return TagD;
8981 }
8982 
8984  SourceLocation ExternLoc,
8985  SourceLocation TemplateLoc,
8986  Declarator &D) {
8987  // Explicit instantiations always require a name.
8988  // TODO: check if/when DNInfo should replace Name.
8989  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
8990  DeclarationName Name = NameInfo.getName();
8991  if (!Name) {
8992  if (!D.isInvalidType())
8994  diag::err_explicit_instantiation_requires_name)
8995  << D.getDeclSpec().getSourceRange()
8996  << D.getSourceRange();
8997 
8998  return true;
8999  }
9000 
9001  // The scope passed in may not be a decl scope. Zip up the scope tree until
9002  // we find one that is.
9003  while ((S->getFlags() & Scope::DeclScope) == 0 ||
9004  (S->getFlags() & Scope::TemplateParamScope) != 0)
9005  S = S->getParent();
9006 
9007  // Determine the type of the declaration.
9008  TypeSourceInfo *T = GetTypeForDeclarator(D, S);
9009  QualType R = T->getType();
9010  if (R.isNull())
9011  return true;
9012 
9013  // C++ [dcl.stc]p1:
9014  // A storage-class-specifier shall not be specified in [...] an explicit
9015  // instantiation (14.7.2) directive.
9017  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)
9018  << Name;
9019  return true;
9020  } else if (D.getDeclSpec().getStorageClassSpec()
9022  // Complain about then remove the storage class specifier.
9023  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)
9025 
9027  }
9028 
9029  // C++0x [temp.explicit]p1:
9030  // [...] An explicit instantiation of a function template shall not use the
9031  // inline or constexpr specifiers.
9032  // Presumably, this also applies to member functions of class templates as
9033  // well.
9034  if (D.getDeclSpec().isInlineSpecified())
9036  getLangOpts().CPlusPlus11 ?
9037  diag::err_explicit_instantiation_inline :
9038  diag::warn_explicit_instantiation_inline_0x)
9041  // FIXME: Add a fix-it to remove the 'constexpr' and add a 'const' if one is
9042  // not already specified.
9044  diag::err_explicit_instantiation_constexpr);
9045 
9046  // A deduction guide is not on the list of entities that can be explicitly
9047  // instantiated.
9049  Diag(D.getDeclSpec().getLocStart(), diag::err_deduction_guide_specialized)
9050  << /*explicit instantiation*/ 0;
9051  return true;
9052  }
9053 
9054  // C++0x [temp.explicit]p2:
9055  // There are two forms of explicit instantiation: an explicit instantiation
9056  // definition and an explicit instantiation declaration. An explicit
9057  // instantiation declaration begins with the extern keyword. [...]
9061 
9062  LookupResult Previous(*this, NameInfo, LookupOrdinaryName);
9063  LookupParsedName(Previous, S, &D.getCXXScopeSpec());
9064 
9065  if (!R->isFunctionType()) {
9066  // C++ [temp.explicit]p1:
9067  // A [...] static data member of a class template can be explicitly
9068  // instantiated from the member definition associated with its class
9069  // template.
9070  // C++1y [temp.explicit]p1:
9071  // A [...] variable [...] template specialization can be explicitly
9072  // instantiated from its template.
9073  if (Previous.isAmbiguous())
9074  return true;
9075 
9076  VarDecl *Prev = Previous.getAsSingle<VarDecl>();
9077  VarTemplateDecl *PrevTemplate = Previous.getAsSingle<VarTemplateDecl>();
9078 
9079  if (!PrevTemplate) {
9080  if (!Prev || !Prev->isStaticDataMember()) {
9081  // We expect to see a data data member here.
9082  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
9083  << Name;
9084  for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
9085  P != PEnd; ++P)
9086  Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
9087  return true;
9088  }
9089 
9090  if (!Prev->getInstantiatedFromStaticDataMember()) {
9091  // FIXME: Check for explicit specialization?
9092  Diag(D.getIdentifierLoc(),
9093  diag::err_explicit_instantiation_data_member_not_instantiated)
9094  << Prev;
9095  Diag(Prev->getLocation(), diag::note_explicit_instantiation_here);
9096  // FIXME: Can we provide a note showing where this was declared?
9097  return true;
9098  }
9099  } else {
9100  // Explicitly instantiate a variable template.
9101 
9102  // C++1y [dcl.spec.auto]p6:
9103  // ... A program that uses auto or decltype(auto) in a context not
9104  // explicitly allowed in this section is ill-formed.
9105  //
9106  // This includes auto-typed variable template instantiations.
9107  if (R->isUndeducedType()) {
9108  Diag(T->getTypeLoc().getLocStart(),
9109  diag::err_auto_not_allowed_var_inst);
9110  return true;
9111  }
9112 
9114  // C++1y [temp.explicit]p3:
9115  // If the explicit instantiation is for a variable, the unqualified-id
9116  // in the declaration shall be a template-id.
9117  Diag(D.getIdentifierLoc(),
9118  diag::err_explicit_instantiation_without_template_id)
9119  << PrevTemplate;
9120  Diag(PrevTemplate->getLocation(),
9121  diag::note_explicit_instantiation_here);
9122  return true;
9123  }
9124 
9125  // Translate the parser's template argument list into our AST format.
9126  TemplateArgumentListInfo TemplateArgs =
9128 
9129  DeclResult Res = CheckVarTemplateId(PrevTemplate, TemplateLoc,
9130  D.getIdentifierLoc(), TemplateArgs);
9131  if (Res.isInvalid())
9132  return true;
9133 
9134  // Ignore access control bits, we don't need them for redeclaration
9135  // checking.
9136  Prev = cast<VarDecl>(Res.get());
9137  }
9138 
9139  // C++0x [temp.explicit]p2:
9140  // If the explicit instantiation is for a member function, a member class
9141  // or a static data member of a class template specialization, the name of
9142  // the class template specialization in the qualified-id for the member
9143  // name shall be a simple-template-id.
9144  //
9145  // C++98 has the same restriction, just worded differently.
9146  //
9147  // This does not apply to variable template specializations, where the
9148  // template-id is in the unqualified-id instead.
9149  if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()) && !PrevTemplate)
9150  Diag(D.getIdentifierLoc(),
9151  diag::ext_explicit_instantiation_without_qualified_id)
9152  << Prev << D.getCXXScopeSpec().getRange();
9153 
9154  // Check the scope of this explicit instantiation.
9155  CheckExplicitInstantiationScope(*this, Prev, D.getIdentifierLoc(), true);
9156 
9157  // Verify that it is okay to explicitly instantiate here.
9160  bool HasNoEffect = false;
9161  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
9162  PrevTSK, POI, HasNoEffect))
9163  return true;
9164 
9165  if (!HasNoEffect) {
9166  // Instantiate static data member or variable template.
9167  Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
9168  if (PrevTemplate) {
9169  // Merge attributes.
9170  ProcessDeclAttributeList(S, Prev, D.getDeclSpec().getAttributes());
9171  }
9173  InstantiateVariableDefinition(D.getIdentifierLoc(), Prev);
9174  }
9175 
9176  // Check the new variable specialization against the parsed input.
9177  if (PrevTemplate && Prev && !Context.hasSameType(Prev->getType(), R)) {
9178  Diag(T->getTypeLoc().getLocStart(),
9179  diag::err_invalid_var_template_spec_type)
9180  << 0 << PrevTemplate << R << Prev->getType();
9181  Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
9182  << 2 << PrevTemplate->getDeclName();
9183  return true;
9184  }
9185 
9186  // FIXME: Create an ExplicitInstantiation node?
9187  return (Decl*) nullptr;
9188  }
9189 
9190  // If the declarator is a template-id, translate the parser's template
9191  // argument list into our AST format.
9192  bool HasExplicitTemplateArgs = false;
9193  TemplateArgumentListInfo TemplateArgs;
9195  TemplateArgs = makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);
9196  HasExplicitTemplateArgs = true;
9197  }
9198 
9199  // C++ [temp.explicit]p1:
9200  // A [...] function [...] can be explicitly instantiated from its template.
9201  // A member function [...] of a class template can be explicitly
9202  // instantiated from the member definition associated with its class
9203  // template.
9204  UnresolvedSet<8> TemplateMatches;
9205  FunctionDecl *NonTemplateMatch = nullptr;
9206  TemplateSpecCandidateSet FailedCandidates(D.getIdentifierLoc());
9207  for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
9208  P != PEnd; ++P) {
9209  NamedDecl *Prev = *P;
9210  if (!HasExplicitTemplateArgs) {
9211  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
9212  QualType Adjusted = adjustCCAndNoReturn(R, Method->getType(),
9213  /*AdjustExceptionSpec*/true);
9214  if (Context.hasSameUnqualifiedType(Method->getType(), Adjusted)) {
9215  if (Method->getPrimaryTemplate()) {
9216  TemplateMatches.addDecl(Method, P.getAccess());
9217  } else {
9218  // FIXME: Can this assert ever happen? Needs a test.
9219  assert(!NonTemplateMatch && "Multiple NonTemplateMatches");
9220  NonTemplateMatch = Method;
9221  }
9222  }
9223  }
9224  }
9225 
9226  FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Prev);
9227  if (!FunTmpl)
9228  continue;
9229 
9230  TemplateDeductionInfo Info(FailedCandidates.getLocation());
9231  FunctionDecl *Specialization = nullptr;
9232  if (TemplateDeductionResult TDK
9233  = DeduceTemplateArguments(FunTmpl,
9234  (HasExplicitTemplateArgs ? &TemplateArgs
9235  : nullptr),
9236  R, Specialization, Info)) {
9237  // Keep track of almost-matches.
9238  FailedCandidates.addCandidate()
9239  .set(P.getPair(), FunTmpl->getTemplatedDecl(),
9240  MakeDeductionFailureInfo(Context, TDK, Info));
9241  (void)TDK;
9242  continue;
9243  }
9244 
9245  // Target attributes are part of the cuda function signature, so
9246  // the cuda target of the instantiated function must match that of its
9247  // template. Given that C++ template deduction does not take
9248  // target attributes into account, we reject candidates here that
9249  // have a different target.
9250  if (LangOpts.CUDA &&
9251  IdentifyCUDATarget(Specialization,
9252  /* IgnoreImplicitHDAttributes = */ true) !=
9253  IdentifyCUDATarget(D.getDeclSpec().getAttributes())) {
9254  FailedCandidates.addCandidate().set(
9255  P.getPair(), FunTmpl->getTemplatedDecl(),
9256  MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
9257  continue;
9258  }
9259 
9260  TemplateMatches.addDecl(Specialization, P.getAccess());
9261  }
9262 
9263  FunctionDecl *Specialization = NonTemplateMatch;
9264  if (!Specialization) {
9265  // Find the most specialized function template specialization.
9266  UnresolvedSetIterator Result = getMostSpecialized(
9267  TemplateMatches.begin(), TemplateMatches.end(), FailedCandidates,
9268  D.getIdentifierLoc(),
9269  PDiag(diag::err_explicit_instantiation_not_known) << Name,
9270  PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
9271  PDiag(diag::note_explicit_instantiation_candidate));
9272 
9273  if (Result == TemplateMatches.end())
9274  return true;
9275 
9276  // Ignore access control bits, we don't need them for redeclaration checking.
9277  Specialization = cast<FunctionDecl>(*Result);
9278  }
9279 
9280  // C++11 [except.spec]p4
9281  // In an explicit instantiation an exception-specification may be specified,
9282  // but is not required.
9283  // If an exception-specification is specified in an explicit instantiation
9284  // directive, it shall be compatible with the exception-specifications of
9285  // other declarations of that function.
9286  if (auto *FPT = R->getAs<FunctionProtoType>())
9287  if (FPT->hasExceptionSpec()) {
9288  unsigned DiagID =
9289  diag::err_mismatched_exception_spec_explicit_instantiation;
9290  if (getLangOpts().MicrosoftExt)
9291  DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
9292  bool Result = CheckEquivalentExceptionSpec(
9293  PDiag(DiagID) << Specialization->getType(),
9294  PDiag(diag::note_explicit_instantiation_here),
9295  Specialization->getType()->getAs<FunctionProtoType>(),
9296  Specialization->getLocation(), FPT, D.getLocStart());
9297  // In Microsoft mode, mismatching exception specifications just cause a
9298  // warning.
9299  if (!getLangOpts().MicrosoftExt && Result)
9300  return true;
9301  }
9302 
9303  if (Specialization->getTemplateSpecializationKind() == TSK_Undeclared) {
9304  Diag(D.getIdentifierLoc(),
9305  diag::err_explicit_instantiation_member_function_not_instantiated)
9306  << Specialization
9307  << (Specialization->getTemplateSpecializationKind() ==
9309  Diag(Specialization->getLocation(), diag::note_explicit_instantiation_here);
9310  return true;
9311  }
9312 
9313  FunctionDecl *PrevDecl = Specialization->getPreviousDecl();
9314  if (!PrevDecl && Specialization->isThisDeclarationADefinition())
9315  PrevDecl = Specialization;
9316 
9317  if (PrevDecl) {
9318  bool HasNoEffect = false;
9319  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK,
9320  PrevDecl,
9321  PrevDecl->getTemplateSpecializationKind(),
9322  PrevDecl->getPointOfInstantiation(),
9323  HasNoEffect))
9324  return true;
9325 
9326  // FIXME: We may still want to build some representation of this
9327  // explicit specialization.
9328  if (HasNoEffect)
9329  return (Decl*) nullptr;
9330  }
9331 
9332  ProcessDeclAttributeList(S, Specialization, D.getDeclSpec().getAttributes());
9333 
9334  // In MSVC mode, dllimported explicit instantiation definitions are treated as
9335  // instantiation declarations.
9337  Specialization->hasAttr<DLLImportAttr>() &&
9338  Context.getTargetInfo().getCXXABI().isMicrosoft())
9340 
9341  Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
9342 
9343  if (Specialization->isDefined()) {
9344  // Let the ASTConsumer know that this function has been explicitly
9345  // instantiated now, and its linkage might have changed.
9346  Consumer.HandleTopLevelDecl(DeclGroupRef(Specialization));
9347  } else if (TSK == TSK_ExplicitInstantiationDefinition)
9348  InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization);
9349 
9350  // C++0x [temp.explicit]p2:
9351  // If the explicit instantiation is for a member function, a member class
9352  // or a static data member of a class template specialization, the name of
9353  // the class template specialization in the qualified-id for the member
9354  // name shall be a simple-template-id.
9355  //
9356  // C++98 has the same restriction, just worded differently.
9357  FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate();
9358  if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId && !FunTmpl &&
9359  D.getCXXScopeSpec().isSet() &&
9361  Diag(D.getIdentifierLoc(),
9362  diag::ext_explicit_instantiation_without_qualified_id)
9363  << Specialization << D.getCXXScopeSpec().getRange();
9364 
9366  FunTmpl? (NamedDecl *)FunTmpl
9367  : Specialization->getInstantiatedFromMemberFunction(),
9368  D.getIdentifierLoc(),
9369  D.getCXXScopeSpec().isSet());
9370 
9371  // FIXME: Create some kind of ExplicitInstantiationDecl here.
9372  return (Decl*) nullptr;
9373 }
9374 
9375 TypeResult
9376 Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
9377  const CXXScopeSpec &SS, IdentifierInfo *Name,
9378  SourceLocation TagLoc, SourceLocation NameLoc) {
9379  // This has to hold, because SS is expected to be defined.
9380  assert(Name && "Expected a name in a dependent tag");
9381 
9382  NestedNameSpecifier *NNS = SS.getScopeRep();
9383  if (!NNS)
9384  return true;
9385 
9387 
9388  if (TUK == TUK_Declaration || TUK == TUK_Definition) {
9389  Diag(NameLoc, diag::err_dependent_tag_decl)
9390  << (TUK == TUK_Definition) << Kind << SS.getRange();
9391  return true;
9392  }
9393 
9394  // Create the resulting type.
9396  QualType Result = Context.getDependentNameType(Kwd, NNS, Name);
9397 
9398  // Create type-source location information for this type.
9399  TypeLocBuilder TLB;
9401  TL.setElaboratedKeywordLoc(TagLoc);
9402  TL.setQualifierLoc(SS.getWithLocInContext(Context));
9403  TL.setNameLoc(NameLoc);
9404  return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
9405 }
9406 
9407 TypeResult
9409  const CXXScopeSpec &SS, const IdentifierInfo &II,
9410  SourceLocation IdLoc) {
9411  if (SS.isInvalid())
9412  return true;
9413 
9414  if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
9415  Diag(TypenameLoc,
9416  getLangOpts().CPlusPlus11 ?
9417  diag::warn_cxx98_compat_typename_outside_of_template :
9418  diag::ext_typename_outside_of_template)
9419  << FixItHint::CreateRemoval(TypenameLoc);
9420 
9421  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
9422  QualType T = CheckTypenameType(TypenameLoc.isValid()? ETK_Typename : ETK_None,
9423  TypenameLoc, QualifierLoc, II, IdLoc);
9424  if (T.isNull())
9425  return true;
9426 
9427  TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
9428  if (isa<DependentNameType>(T)) {
9430  TL.setElaboratedKeywordLoc(TypenameLoc);
9431  TL.setQualifierLoc(QualifierLoc);
9432  TL.setNameLoc(IdLoc);
9433  } else {
9435  TL.setElaboratedKeywordLoc(TypenameLoc);
9436  TL.setQualifierLoc(QualifierLoc);
9437  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
9438  }
9439 
9440  return CreateParsedType(T, TSI);
9441 }
9442 
9443 TypeResult
9445  SourceLocation TypenameLoc,
9446  const CXXScopeSpec &SS,
9447  SourceLocation TemplateKWLoc,
9448  TemplateTy TemplateIn,
9449  IdentifierInfo *TemplateII,
9450  SourceLocation TemplateIILoc,
9451  SourceLocation LAngleLoc,
9452  ASTTemplateArgsPtr TemplateArgsIn,
9453  SourceLocation RAngleLoc) {
9454  if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
9455  Diag(TypenameLoc,
9456  getLangOpts().CPlusPlus11 ?
9457  diag::warn_cxx98_compat_typename_outside_of_template :
9458  diag::ext_typename_outside_of_template)
9459  << FixItHint::CreateRemoval(TypenameLoc);
9460 
9461  // Strangely, non-type results are not ignored by this lookup, so the
9462  // program is ill-formed if it finds an injected-class-name.
9463  if (TypenameLoc.isValid()) {
9464  auto *LookupRD =
9465  dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, false));
9466  if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
9467  Diag(TemplateIILoc,
9468  diag::ext_out_of_line_qualified_id_type_names_constructor)
9469  << TemplateII << 0 /*injected-class-name used as template name*/
9470  << (TemplateKWLoc.isValid() ? 1 : 0 /*'template'/'typename' keyword*/);
9471  }
9472  }
9473 
9474  // Translate the parser's template argument list in our AST format.
9475  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
9476  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
9477 
9478  TemplateName Template = TemplateIn.get();
9479  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
9480  // Construct a dependent template specialization type.
9481  assert(DTN && "dependent template has non-dependent name?");
9482  assert(DTN->getQualifier() == SS.getScopeRep());
9484  DTN->getQualifier(),
9485  DTN->getIdentifier(),
9486  TemplateArgs);
9487 
9488  // Create source-location information for this type.
9489  TypeLocBuilder Builder;
9492  SpecTL.setElaboratedKeywordLoc(TypenameLoc);
9493  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
9494  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
9495  SpecTL.setTemplateNameLoc(TemplateIILoc);
9496  SpecTL.setLAngleLoc(LAngleLoc);
9497  SpecTL.setRAngleLoc(RAngleLoc);
9498  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
9499  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
9500  return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
9501  }
9502 
9503  QualType T = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
9504  if (T.isNull())
9505  return true;
9506 
9507  // Provide source-location information for the template specialization type.
9508  TypeLocBuilder Builder;
9510  = Builder.push<TemplateSpecializationTypeLoc>(T);
9511  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
9512  SpecTL.setTemplateNameLoc(TemplateIILoc);
9513  SpecTL.setLAngleLoc(LAngleLoc);
9514  SpecTL.setRAngleLoc(RAngleLoc);
9515  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
9516  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
9517 
9518  T = Context.getElaboratedType(ETK_Typename, SS.getScopeRep(), T);
9519  ElaboratedTypeLoc TL = Builder.push<ElaboratedTypeLoc>(T);
9520  TL.setElaboratedKeywordLoc(TypenameLoc);
9521  TL.setQualifierLoc(SS.getWithLocInContext(Context));
9522 
9523  TypeSourceInfo *TSI = Builder.getTypeSourceInfo(Context, T);
9524  return CreateParsedType(T, TSI);
9525 }
9526 
9527 
9528 /// Determine whether this failed name lookup should be treated as being
9529 /// disabled by a usage of std::enable_if.
9531  SourceRange &CondRange, Expr *&Cond) {
9532  // We must be looking for a ::type...
9533  if (!II.isStr("type"))
9534  return false;
9535 
9536  // ... within an explicitly-written template specialization...
9537  if (!NNS || !NNS.getNestedNameSpecifier()->getAsType())
9538  return false;
9539  TypeLoc EnableIfTy = NNS.getTypeLoc();
9540  TemplateSpecializationTypeLoc EnableIfTSTLoc =
9541  EnableIfTy.getAs<TemplateSpecializationTypeLoc>();
9542  if (!EnableIfTSTLoc || EnableIfTSTLoc.getNumArgs() == 0)
9543  return false;
9544  const TemplateSpecializationType *EnableIfTST = EnableIfTSTLoc.getTypePtr();
9545 
9546  // ... which names a complete class template declaration...
9547  const TemplateDecl *EnableIfDecl =
9548  EnableIfTST->getTemplateName().getAsTemplateDecl();
9549  if (!EnableIfDecl || EnableIfTST->isIncompleteType())
9550  return false;
9551 
9552  // ... called "enable_if".
9553  const IdentifierInfo *EnableIfII =
9554  EnableIfDecl->getDeclName().getAsIdentifierInfo();
9555  if (!EnableIfII || !EnableIfII->isStr("enable_if"))
9556  return false;
9557 
9558  // Assume the first template argument is the condition.
9559  CondRange = EnableIfTSTLoc.getArgLoc(0).getSourceRange();
9560 
9561  // Dig out the condition.
9562  Cond = nullptr;
9563  if (EnableIfTSTLoc.getArgLoc(0).getArgument().getKind()
9565  return true;
9566 
9567  Cond = EnableIfTSTLoc.getArgLoc(0).getSourceExpression();
9568 
9569  // Ignore Boolean literals; they add no value.
9570  if (isa<CXXBoolLiteralExpr>(Cond->IgnoreParenCasts()))
9571  Cond = nullptr;
9572 
9573  return true;
9574 }
9575 
9576 /// Build the type that describes a C++ typename specifier,
9577 /// e.g., "typename T::type".
9578 QualType
9580  SourceLocation KeywordLoc,
9581  NestedNameSpecifierLoc QualifierLoc,
9582  const IdentifierInfo &II,
9583  SourceLocation IILoc) {
9584  CXXScopeSpec SS;
9585  SS.Adopt(QualifierLoc);
9586 
9587  DeclContext *Ctx = computeDeclContext(SS);
9588  if (!Ctx) {
9589  // If the nested-name-specifier is dependent and couldn't be
9590  // resolved to a type, build a typename type.
9591  assert(QualifierLoc.getNestedNameSpecifier()->isDependent());
9592  return Context.getDependentNameType(Keyword,
9593  QualifierLoc.getNestedNameSpecifier(),
9594  &II);
9595  }
9596 
9597  // If the nested-name-specifier refers to the current instantiation,
9598  // the "typename" keyword itself is superfluous. In C++03, the
9599  // program is actually ill-formed. However, DR 382 (in C++0x CD1)
9600  // allows such extraneous "typename" keywords, and we retroactively
9601  // apply this DR to C++03 code with only a warning. In any case we continue.
9602 
9603  if (RequireCompleteDeclContext(SS, Ctx))
9604  return QualType();
9605 
9606  DeclarationName Name(&II);
9607  LookupResult Result(*this, Name, IILoc, LookupOrdinaryName);
9608  LookupQualifiedName(Result, Ctx, SS);
9609  unsigned DiagID = 0;
9610  Decl *Referenced = nullptr;
9611  switch (Result.getResultKind()) {
9612  case LookupResult::NotFound: {
9613  // If we're looking up 'type' within a template named 'enable_if', produce
9614  // a more specific diagnostic.
9615  SourceRange CondRange;
9616  Expr *Cond = nullptr;
9617  if (isEnableIf(QualifierLoc, II, CondRange, Cond)) {
9618  // If we have a condition, narrow it down to the specific failed
9619  // condition.
9620  if (Cond) {
9621  Expr *FailedCond;
9622  std::string FailedDescription;
9623  std::tie(FailedCond, FailedDescription) =
9624  findFailedBooleanCondition(Cond, /*AllowTopLevelCond=*/true);
9625 
9626  Diag(FailedCond->getExprLoc(),
9627  diag::err_typename_nested_not_found_requirement)
9628  << FailedDescription
9629  << FailedCond->getSourceRange();
9630  return QualType();
9631  }
9632 
9633  Diag(CondRange.getBegin(), diag::err_typename_nested_not_found_enable_if)
9634  << Ctx << CondRange;
9635  return QualType();
9636  }
9637 
9638  DiagID = diag::err_typename_nested_not_found;
9639  break;
9640  }
9641 
9643  // We found a using declaration that is a value. Most likely, the using
9644  // declaration itself is meant to have the 'typename' keyword.
9645  SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
9646  IILoc);
9647  Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
9648  << Name << Ctx << FullRange;
9649  if (UnresolvedUsingValueDecl *Using
9650  = dyn_cast<UnresolvedUsingValueDecl>(Result.getRepresentativeDecl())){
9651  SourceLocation Loc = Using->getQualifierLoc().getBeginLoc();
9652  Diag(Loc, diag::note_using_value_decl_missing_typename)
9653  << FixItHint::CreateInsertion(Loc, "typename ");
9654  }
9655  }
9656  // Fall through to create a dependent typename type, from which we can recover
9657  // better.
9658  LLVM_FALLTHROUGH;
9659 
9661  // Okay, it's a member of an unknown instantiation.
9662  return Context.getDependentNameType(Keyword,
9663  QualifierLoc.getNestedNameSpecifier(),
9664  &II);
9665 
9666  case LookupResult::Found:
9667  if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
9668  // C++ [class.qual]p2:
9669  // In a lookup in which function names are not ignored and the
9670  // nested-name-specifier nominates a class C, if the name specified
9671  // after the nested-name-specifier, when looked up in C, is the
9672  // injected-class-name of C [...] then the name is instead considered
9673  // to name the constructor of class C.
9674  //
9675  // Unlike in an elaborated-type-specifier, function names are not ignored
9676  // in typename-specifier lookup. However, they are ignored in all the
9677  // contexts where we form a typename type with no keyword (that is, in
9678  // mem-initializer-ids, base-specifiers, and elaborated-type-specifiers).
9679  //
9680  // FIXME: That's not strictly true: mem-initializer-id lookup does not
9681  // ignore functions, but that appears to be an oversight.
9682  auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(Ctx);
9683  auto *FoundRD = dyn_cast<CXXRecordDecl>(Type);
9684  if (Keyword == ETK_Typename && LookupRD && FoundRD &&
9685  FoundRD->isInjectedClassName() &&
9686  declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
9687  Diag(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)
9688  << &II << 1 << 0 /*'typename' keyword used*/;
9689 
9690  // We found a type. Build an ElaboratedType, since the
9691  // typename-specifier was just sugar.
9692  MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
9693  return Context.getElaboratedType(Keyword,
9694  QualifierLoc.getNestedNameSpecifier(),
9695  Context.getTypeDeclType(Type));
9696  }
9697 
9698  // C++ [dcl.type.simple]p2:
9699  // A type-specifier of the form
9700  // typename[opt] nested-name-specifier[opt] template-name
9701  // is a placeholder for a deduced class type [...].
9702  if (getLangOpts().CPlusPlus17) {
9703  if (auto *TD = getAsTypeTemplateDecl(Result.getFoundDecl())) {
9704  return Context.getElaboratedType(
9705  Keyword, QualifierLoc.getNestedNameSpecifier(),
9707  QualType(), false));
9708  }
9709  }
9710 
9711  DiagID = diag::err_typename_nested_not_type;
9712  Referenced = Result.getFoundDecl();
9713  break;
9714 
9716  DiagID = diag::err_typename_nested_not_type;
9717  Referenced = *Result.begin();
9718  break;
9719 
9721  return QualType();
9722  }
9723 
9724  // If we get here, it's because name lookup did not find a
9725  // type. Emit an appropriate diagnostic and return an error.
9726  SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
9727  IILoc);
9728  Diag(IILoc, DiagID) << FullRange << Name << Ctx;
9729  if (Referenced)
9730  Diag(Referenced->getLocation(), diag::note_typename_refers_here)
9731  << Name;
9732  return QualType();
9733 }
9734 
9735 namespace {
9736  // See Sema::RebuildTypeInCurrentInstantiation
9737  class CurrentInstantiationRebuilder
9738  : public TreeTransform<CurrentInstantiationRebuilder> {
9739  SourceLocation Loc;
9740  DeclarationName Entity;
9741 
9742  public:
9744 
9745  CurrentInstantiationRebuilder(Sema &SemaRef,
9746  SourceLocation Loc,
9747  DeclarationName Entity)
9749  Loc(Loc), Entity(Entity) { }
9750 
9751  /// Determine whether the given type \p T has already been
9752  /// transformed.
9753  ///
9754  /// For the purposes of type reconstruction, a type has already been
9755  /// transformed if it is NULL or if it is not dependent.
9756  bool AlreadyTransformed(QualType T) {
9757  return T.isNull() || !T->isDependentType();
9758  }
9759 
9760  /// Returns the location of the entity whose type is being
9761  /// rebuilt.
9762  SourceLocation getBaseLocation() { return Loc; }
9763 
9764  /// Returns the name of the entity whose type is being rebuilt.
9765  DeclarationName getBaseEntity() { return Entity; }
9766 
9767  /// Sets the "base" location and entity when that
9768  /// information is known based on another transformation.
9769  void setBase(SourceLocation Loc, DeclarationName Entity) {
9770  this->Loc = Loc;
9771  this->Entity = Entity;
9772  }
9773 
9774  ExprResult TransformLambdaExpr(LambdaExpr *E) {
9775  // Lambdas never need to be transformed.
9776  return E;
9777  }
9778  };
9779 } // end anonymous namespace
9780 
9781 /// Rebuilds a type within the context of the current instantiation.
9782 ///
9783 /// The type \p T is part of the type of an out-of-line member definition of
9784 /// a class template (or class template partial specialization) that was parsed
9785 /// and constructed before we entered the scope of the class template (or
9786 /// partial specialization thereof). This routine will rebuild that type now
9787 /// that we have entered the declarator's scope, which may produce different
9788 /// canonical types, e.g.,
9789 ///
9790 /// \code
9791 /// template<typename T>
9792 /// struct X {
9793 /// typedef T* pointer;
9794 /// pointer data();
9795 /// };
9796 ///
9797 /// template<typename T>
9798 /// typename X<T>::pointer X<T>::data() { ... }
9799 /// \endcode
9800 ///
9801 /// Here, the type "typename X<T>::pointer" will be created as a DependentNameType,
9802 /// since we do not know that we can look into X<T> when we parsed the type.
9803 /// This function will rebuild the type, performing the lookup of "pointer"
9804 /// in X<T> and returning an ElaboratedType whose canonical type is the same
9805 /// as the canonical type of T*, allowing the return types of the out-of-line
9806 /// definition and the declaration to match.
9808  SourceLocation Loc,
9809  DeclarationName Name) {
9810  if (!T || !T->getType()->isDependentType())
9811  return T;
9812 
9813  CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name);
9814  return Rebuilder.TransformType(T);
9815 }
9816 
9818  CurrentInstantiationRebuilder Rebuilder(*this, E->getExprLoc(),
9819  DeclarationName());
9820  return Rebuilder.TransformExpr(E);
9821 }
9822 
9824  if (SS.isInvalid())
9825  return true;
9826 
9827  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
9828  CurrentInstantiationRebuilder Rebuilder(*this, SS.getRange().getBegin(),
9829  DeclarationName());
9830  NestedNameSpecifierLoc Rebuilt
9831  = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
9832  if (!Rebuilt)
9833  return true;
9834 
9835  SS.Adopt(Rebuilt);
9836  return false;
9837 }
9838 
9839 /// Rebuild the template parameters now that we know we're in a current
9840 /// instantiation.
9842  TemplateParameterList *Params) {
9843  for (unsigned I = 0, N = Params->size(); I != N; ++I) {
9844  Decl *Param = Params->getParam(I);
9845 
9846  // There is nothing to rebuild in a type parameter.
9847  if (isa<TemplateTypeParmDecl>(Param))
9848  continue;
9849 
9850  // Rebuild the template parameter list of a template template parameter.
9851  if (TemplateTemplateParmDecl *TTP
9852  = dyn_cast<TemplateTemplateParmDecl>(Param)) {
9853  if (RebuildTemplateParamsInCurrentInstantiation(
9854  TTP->getTemplateParameters()))
9855  return true;
9856 
9857  continue;
9858  }
9859 
9860  // Rebuild the type of a non-type template parameter.
9861  NonTypeTemplateParmDecl *NTTP = cast<NonTypeTemplateParmDecl>(Param);
9862  TypeSourceInfo *NewTSI
9863  = RebuildTypeInCurrentInstantiation(NTTP->getTypeSourceInfo(),
9864  NTTP->getLocation(),
9865  NTTP->getDeclName());
9866  if (!NewTSI)
9867  return true;
9868 
9869  if (NewTSI != NTTP->getTypeSourceInfo()) {
9870  NTTP->setTypeSourceInfo(NewTSI);
9871  NTTP->setType(NewTSI->getType());
9872  }
9873  }
9874 
9875  return false;
9876 }
9877 
9878 /// Produces a formatted string that describes the binding of
9879 /// template parameters to template arguments.
9880 std::string
9882  const TemplateArgumentList &Args) {
9883  return getTemplateArgumentBindingsText(Params, Args.data(), Args.size());
9884 }
9885 
9886 std::string
9888  const TemplateArgument *Args,
9889  unsigned NumArgs) {
9890  SmallString<128> Str;
9891  llvm::raw_svector_ostream Out(Str);
9892 
9893  if (!Params || Params->size() == 0 || NumArgs == 0)
9894  return std::string();
9895 
9896  for (unsigned I = 0, N = Params->size(); I != N; ++I) {
9897  if (I >= NumArgs)
9898  break;
9899 
9900  if (I == 0)
9901  Out << "[with ";
9902  else
9903  Out << ", ";
9904 
9905  if (const IdentifierInfo *Id = Params->getParam(I)->getIdentifier()) {
9906  Out << Id->getName();
9907  } else {
9908  Out << '$' << I;
9909  }
9910 
9911  Out << " = ";
9912  Args[I].print(getPrintingPolicy(), Out);
9913  }
9914 
9915  Out << ']';
9916  return Out.str();
9917 }
9918 
9920  CachedTokens &Toks) {
9921  if (!FD)
9922  return;
9923 
9924  auto LPT = llvm::make_unique<LateParsedTemplate>();
9925 
9926  // Take tokens to avoid allocations
9927  LPT->Toks.swap(Toks);
9928  LPT->D = FnD;
9929  LateParsedTemplateMap.insert(std::make_pair(FD, std::move(LPT)));
9930 
9931  FD->setLateTemplateParsed(true);
9932 }
9933 
9935  if (!FD)
9936  return;
9937  FD->setLateTemplateParsed(false);
9938 }
9939 
9941  DeclContext *DC = CurContext;
9942 
9943  while (DC) {
9944  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(CurContext)) {
9945  const FunctionDecl *FD = RD->isLocalClass();
9946  return (FD && FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate);
9947  } else if (DC->isTranslationUnit() || DC->isNamespace())
9948  return false;
9949 
9950  DC = DC->getParent();
9951  }
9952  return false;
9953 }
9954 
9955 namespace {
9956 /// Walk the path from which a declaration was instantiated, and check
9957 /// that every explicit specialization along that path is visible. This enforces
9958 /// C++ [temp.expl.spec]/6:
9959 ///
9960 /// If a template, a member template or a member of a class template is
9961 /// explicitly specialized then that specialization shall be declared before
9962 /// the first use of that specialization that would cause an implicit
9963 /// instantiation to take place, in every translation unit in which such a
9964 /// use occurs; no diagnostic is required.
9965 ///
9966 /// and also C++ [temp.class.spec]/1:
9967 ///
9968 /// A partial specialization shall be declared before the first use of a
9969 /// class template specialization that would make use of the partial
9970 /// specialization as the result of an implicit or explicit instantiation
9971 /// in every translation unit in which such a use occurs; no diagnostic is
9972 /// required.
9973 class ExplicitSpecializationVisibilityChecker {
9974  Sema &S;
9975  SourceLocation Loc;
9977 
9978 public:
9979  ExplicitSpecializationVisibilityChecker(Sema &S, SourceLocation Loc)
9980  : S(S), Loc(Loc) {}
9981 
9982  void check(NamedDecl *ND) {
9983  if (auto *FD = dyn_cast<FunctionDecl>(ND))
9984  return checkImpl(FD);
9985  if (auto *RD = dyn_cast<CXXRecordDecl>(ND))
9986  return checkImpl(RD);
9987  if (auto *VD = dyn_cast<VarDecl>(ND))
9988  return checkImpl(VD);
9989  if (auto *ED = dyn_cast<EnumDecl>(ND))
9990  return checkImpl(ED);
9991  }
9992 
9993 private:
9994  void diagnose(NamedDecl *D, bool IsPartialSpec) {
9995  auto Kind = IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization
9997  const bool Recover = true;
9998 
9999  // If we got a custom set of modules (because only a subset of the
10000  // declarations are interesting), use them, otherwise let
10001  // diagnoseMissingImport intelligently pick some.
10002  if (Modules.empty())
10003  S.diagnoseMissingImport(Loc, D, Kind, Recover);
10004  else
10005  S.diagnoseMissingImport(Loc, D, D->getLocation(), Modules, Kind, Recover);
10006  }
10007 
10008  // Check a specific declaration. There are three problematic cases:
10009  //
10010  // 1) The declaration is an explicit specialization of a template
10011  // specialization.
10012  // 2) The declaration is an explicit specialization of a member of an
10013  // templated class.
10014  // 3) The declaration is an instantiation of a template, and that template
10015  // is an explicit specialization of a member of a templated class.
10016  //
10017  // We don't need to go any deeper than that, as the instantiation of the
10018  // surrounding class / etc is not triggered by whatever triggered this
10019  // instantiation, and thus should be checked elsewhere.
10020  template<typename SpecDecl>
10021  void checkImpl(SpecDecl *Spec) {
10022  bool IsHiddenExplicitSpecialization = false;
10023  if (Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
10024  IsHiddenExplicitSpecialization =
10025  Spec->getMemberSpecializationInfo()
10026  ? !S.hasVisibleMemberSpecialization(Spec, &Modules)
10027  : !S.hasVisibleExplicitSpecialization(Spec, &Modules);
10028  } else {
10029  checkInstantiated(Spec);
10030  }
10031 
10032  if (IsHiddenExplicitSpecialization)
10033  diagnose(Spec->getMostRecentDecl(), false);
10034  }
10035 
10036  void checkInstantiated(FunctionDecl *FD) {
10037  if (auto *TD = FD->getPrimaryTemplate())
10038  checkTemplate(TD);
10039  }
10040 
10041  void checkInstantiated(CXXRecordDecl *RD) {
10042  auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
10043  if (!SD)
10044  return;
10045 
10046  auto From = SD->getSpecializedTemplateOrPartial();
10047  if (auto *TD = From.dyn_cast<ClassTemplateDecl *>())
10048  checkTemplate(TD);
10049  else if (auto *TD =
10050  From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
10051  if (!S.hasVisibleDeclaration(TD))
10052  diagnose(TD, true);
10053  checkTemplate(TD);
10054  }
10055  }
10056 
10057  void checkInstantiated(VarDecl *RD) {
10058  auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
10059  if (!SD)
10060  return;
10061 
10062  auto From = SD->getSpecializedTemplateOrPartial();
10063  if (auto *TD = From.dyn_cast<VarTemplateDecl *>())
10064  checkTemplate(TD);
10065  else if (auto *TD =
10066  From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
10067  if (!S.hasVisibleDeclaration(TD))
10068  diagnose(TD, true);
10069  checkTemplate(TD);
10070  }
10071  }
10072 
10073  void checkInstantiated(EnumDecl *FD) {}
10074 
10075  template<typename TemplDecl>
10076  void checkTemplate(TemplDecl *TD) {
10077  if (TD->isMemberSpecialization()) {
10078  if (!S.hasVisibleMemberSpecialization(TD, &Modules))
10079  diagnose(TD->getMostRecentDecl(), false);
10080  }
10081  }
10082 };
10083 } // end anonymous namespace
10084 
10086  if (!getLangOpts().Modules)
10087  return;
10088 
10089  ExplicitSpecializationVisibilityChecker(*this, Loc).check(Spec);
10090 }
10091 
10092 /// Check whether a template partial specialization that we've discovered
10093 /// is hidden, and produce suitable diagnostics if so.
10095  NamedDecl *Spec) {
10097  if (!hasVisibleDeclaration(Spec, &Modules))
10098  diagnoseMissingImport(Loc, Spec, Spec->getLocation(), Modules,
10099  MissingImportKind::PartialSpecialization,
10100  /*Recover*/true);
10101 }
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:5192
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.
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it&#39;s either not been deduced or was deduce...
Definition: Type.h:4548
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1568
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:593
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition: Sema.h:3067
void setImplicit(bool I=true)
Definition: DeclBase.h:555
Represents a function declaration or definition.
Definition: Decl.h:1716
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
Definition: DeclTemplate.h:570
Name lookup found a set of overloaded functions that met the criteria.
Definition: Lookup.h:64
TypeResult ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK, const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation TagLoc, SourceLocation NameLoc)
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.
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.
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this function template specialization.
Definition: DeclTemplate.h:581
QualType BuildFunctionType(QualType T, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc, DeclarationName Entity, const FunctionProtoType::ExtProtoInfo &EPI)
Build a function type.
Definition: SemaType.cpp:2429
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...
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:497
PtrTy get() const
Definition: Ownership.h:81
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:2393
QualType getPointeeType() const
Definition: Type.h:2406
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:3886
A (possibly-)qualified type.
Definition: Type.h:655
Simple class containing the result of Sema::CorrectTypo.
TemplateDeductionResult
Describes the result of template argument deduction.
Definition: Sema.h:6905
void InstantiatedLocal(const Decl *D, Decl *Inst)
base_class_range bases()
Definition: DeclCXX.h:825
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis that makes a template template argument into a pack expansion...
bool isArrayType() const
Definition: Type.h:6162
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...
bool isMemberPointerType() const
Definition: Type.h:6144
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
static const TemplateArgument & getArgument(const TemplateArgument &A)
QualType getInjectedSpecializationType() const
Definition: Type.h:4826
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
Definition: TemplateName.h:478
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition: Type.cpp:1904
llvm::PointerUnion3< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
Definition: DeclTemplate.h:62
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1122
A stack-allocated class that identifies which local variable declaration instantiations are present i...
Definition: Template.h:228
void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName, SourceLocation Less, SourceLocation Greater)
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:404
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:1162
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3016
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Definition: TemplateBase.h:532
void addOuterTemplateArguments(const TemplateArgumentList *TemplateArgs)
Add a new outermost level to the multi-level template argument list.
Definition: Template.h:134
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Lookup.h:246
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
static UnresolvedLookupExpr * Create(const ASTContext &C, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool ADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.h:2869
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1443
Stmt - This represents one statement.
Definition: Stmt.h:66
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
Definition: DeclSpec.h:950
Filter makeFilter()
Create a filter for this result set.
Definition: Lookup.h:671
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1637
void setExceptionSpecRange(SourceRange R)
Definition: TypeLoc.h:1457
We are matching the template parameter lists of two templates that might be redeclarations.
Definition: Sema.h:6447
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:4283
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...
DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization)
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:497
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:941
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 ...
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1019
The name refers to a function template or a set of overloaded functions that includes at least one fu...
Definition: TemplateKinds.h:26
bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc, TemplateDecl *PrimaryTemplate, unsigned NumExplicitArgs, ArrayRef< TemplateArgument > Args)
Check the non-type template arguments of a class template partial specialization according to C++ [te...
The name refers to a dependent template name:
Definition: TemplateKinds.h:46
Microsoft&#39;s &#39;__super&#39; specifier, stored as a CXXRecordDecl* of the class it appeared in...
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2090
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:5020
void setObjCLifetime(ObjCLifetime type)
Definition: Type.h:346
The template argument is an expression, and we&#39;ve not resolved it to one of the other forms yet...
Definition: TemplateBase.h:87
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:270
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
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...
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5039
void erase()
Erase the last element returned from this iterator.
Definition: Lookup.h:643
static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)
Determine what kind of template specialization the given declaration is.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1918
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1281
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
bool isVariadic() const
Definition: Type.h:3774
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2824
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
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
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
Definition: Scope.h:375
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4562
bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS)
static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context, QualType T, const CXXScopeSpec &SS)
Expr * getAsExpr() const
Retrieve the non-type template argument&#39;s expression.
Not a friend object.
Definition: DeclBase.h:1101
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1751
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
Definition: DeclBase.h:960
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:6062
void AddDecl(Decl *D)
Definition: Scope.h:286
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition: Type.cpp:2543
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
TemplateParameterList * MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId, ArrayRef< TemplateParameterList *> ParamLists, bool IsFriend, bool &IsMemberSpecialization, bool &Invalid)
Match the given template parameter lists to the given scope specifier, returning the template paramet...
The base class of the type hierarchy.
Definition: Type.h:1428
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2160
Declaration of a variable template.
TemplateParamListContext
The context in which we are checking a template parameter list.
Definition: Sema.h:6192
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:64
Represent a C++ namespace.
Definition: Decl.h:514
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:46
Wrapper for source info for typedefs.
Definition: TypeLoc.h:665
void setSpecializationKind(TemplateSpecializationKind TSK)
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:133
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:679
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:98
A container of type source information.
Definition: Decl.h:86
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5800
bool isSuppressingDiagnostics() const
Determines whether this lookup is suppressing diagnostics.
Definition: Lookup.h:577
bool hasVisibleDeclaration(const NamedDecl *D, llvm::SmallVectorImpl< Module *> *Modules=nullptr)
Determine whether any declaration of an entity is visible.
Definition: Sema.h:1568
TypeSourceInfo * getDefaultArgumentInfo() const
Retrieves the default argument&#39;s source information, if any.
An overloaded operator name, e.g., operator+.
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function has a definition that does not need to be instantiated.
Definition: Decl.cpp:2651
void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo)
bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation, NamedDecl *Instantiation, bool InstantiatedFromMember, const NamedDecl *Pattern, const NamedDecl *PatternDef, TemplateSpecializationKind TSK, bool Complain=true)
Determine whether we would be unable to instantiate this template (because it either has no definitio...
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:452
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclBase.h:414
static void StripImplicitInstantiation(NamedDecl *D)
Strips various properties off an implicit instantiation that has just been explicitly specialized...
bool hasNext() const
Definition: Lookup.h:628
Abstract base class used for diagnosing integer constant expression violations.
Definition: Sema.h:9880
static NullPointerValueKind isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *Arg, Decl *Entity=nullptr)
Determine whether the given template argument is a null pointer value of the appropriate type...
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &Converted, bool UpdateArgsWithConversions=true)
Check that the given template arguments can be be provided to the given template, converting the argu...
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2477
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
QualType getElementType() const
Definition: Type.h:2703
DeclarationName getCXXDeductionGuideName(TemplateDecl *TD)
Returns the name of a C++ deduction guide for the given template.
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
Definition: TemplateName.h:484
An identifier, stored as an IdentifierInfo*.
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:125
bool CheckTemplateTemplateArgument(TemplateParameterList *Params, TemplateArgumentLoc &Arg)
Check a template argument against its corresponding template template parameter.
unsigned getDepth() const
Get the nesting depth of the template parameter.
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:54
TemplateParameterList * getExpansionTemplateParameters(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10734
Represents a variable declaration or definition.
Definition: Decl.h:814
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Lookup.h:241
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1752
bool isEnumeralType() const
Definition: Type.h:6190
static SourceLocation DiagLocForExplicitInstantiation(NamedDecl *D, SourceLocation PointOfInstantiation)
Compute the diagnostic location for an explicit instantiation.
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6526
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
Definition: Decl.cpp:2587
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:553
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:57
Extra information about a function prototype.
Definition: Type.h:3551
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:45
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical) const
Produce a unique representation of the given statement.
Represents a C++17 deduced template specialization type.
Definition: Type.h:4598
Represents a variable template specialization, which refers to a variable template with a given set o...
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:1091
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:431
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
Definition: Sema.h:10653
ArrayRef< LValuePathEntry > getLValuePath() const
Definition: APValue.cpp:615
SourceLocation getLAngleLoc() const
Definition: DeclTemplate.h:173
static bool isTemplateArgumentTemplateParameter(const TemplateArgument &Arg, unsigned Depth, unsigned Index)
bool isAmbiguous() const
Definition: Lookup.h:290
A namespace, stored as a NamespaceDecl*.
TypeLoc getNamedTypeLoc() const
Definition: TypeLoc.h:2041
bool isInvalidDecl() const
Definition: DeclBase.h:549
bool isChar32Type() const
Definition: Type.cpp:1819
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
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...
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
bool isParameterPack() const
Whether this declaration is a parameter pack.
Definition: DeclBase.cpp:211
static Optional< unsigned > getExpandedPackSize(NamedDecl *Param)
Check whether the template parameter is a pack expansion, and if so, determine the number of paramete...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:630
Represents a parameter to a function.
Definition: Decl.h:1535
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4417
Defines the clang::Expr interface and subclasses for C++ expressions.
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:315
void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD, CachedTokens &Toks)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2021
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:508
The collection of all-type qualifiers we support.
Definition: Type.h:154
bool isLValueOnePastTheEnd() const
Definition: APValue.cpp:600
Information about a template-id annotation token.
PipeType - OpenCL20.
Definition: Type.h:5819
bool isObjCObjectOrInterfaceType() const
Definition: Type.h:6218
const ValueDecl * getMemberPointerDecl() const
Definition: APValue.cpp:660
static void DiagnoseTemplateParameterListArityMismatch(Sema &S, TemplateParameterList *New, TemplateParameterList *Old, Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc)
Diagnose a known arity mismatch when comparing template argument lists.
static SourceRange findTemplateParameter(unsigned Depth, TypeLoc TL)
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
Definition: DeclCXX.cpp:1604
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
Expr * IgnoreImpCasts() LLVM_READONLY
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
Definition: Expr.h:3016
Represents a struct/union/class.
Definition: Decl.h:3570
A semantic tree transformation that allows one to transform one abstract syntax tree into another...
Definition: TreeTransform.h:96
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
Scope * getTemplateParamParent()
Definition: Scope.h:259
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:974
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1110
bool isWideCharType() const
Definition: Type.cpp:1800
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...
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1010
TemplateName getUnderlying() const
Definition: TemplateName.h:348
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7574
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
Definition: Lookup.h:74
void setLocalRangeEnd(SourceLocation L)
Definition: TypeLoc.h:1427
unsigned getDepth() const
Retrieve the depth of the template parameter.
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
bool LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, bool &MemberOfUnknownSpecialization, SourceLocation TemplateKWLoc=SourceLocation())
void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl)
DiagnoseTemplateParameterShadow - Produce a diagnostic complaining that the template parameter &#39;PrevD...
bool isConst() const
Definition: DeclCXX.h:2087
void replace(NamedDecl *D)
Replaces the current entry with the given one, preserving the access bits.
Definition: Lookup.h:650
static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate)
Determine whether this alias template is "enable_if_t".
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
ExprResult RebuildExprInCurrentInstantiation(Expr *E)
Represents a class type in Objective C.
Definition: Type.h:5355
QualType getPointeeType() const
Definition: Type.h:2510
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:330
CXXRecordDecl * getPreviousDecl()
Definition: DeclCXX.h:738
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:150
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:422
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3675
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 isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:3958
TypeSourceInfo * getTypeSourceInfo() const
Definition: TemplateBase.h:507
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:72
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:1653
bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, const TemplateArgumentListInfo &ExplicitTemplateArgs, LookupResult &Previous)
Perform semantic analysis for the given dependent function template specialization.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3776
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
Definition: Type.cpp:3315
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
VarTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:4724
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We&#39;ve found a use of a templated declaration that would trigger an implicit instantiation.
static SourceRange findTemplateParameterInType(unsigned Depth, Expr *E)
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
SourceLocation getLocation() const
Retrieve the location of the template argument.
SourceLocation getLocation() const
Definition: TemplateBase.h:488
OverloadedOperatorKind Operator
The kind of overloaded operator.
Definition: DeclSpec.h:933
bool isNamespace() const
Definition: DeclBase.h:1421
An operation on a type.
Definition: TypeVisitor.h:65
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
Definition: Decl.h:1588
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:231
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:3791
struct OFI OperatorFunctionId
When Kind == IK_OperatorFunctionId, the overloaded operator that we parsed.
Definition: DeclSpec.h:954
bool isReferenceType() const
Definition: Type.h:6125
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2071
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4473
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
A non-type template parameter, stored as an expression.
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1463
SourceLocation getRParenLoc() const
Definition: TypeLoc.h:1439
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, bool IsExplicit, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation)
Definition: DeclCXX.cpp:1821
bool hasAnyAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true)
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:1877
bool DiagnoseUnknownTemplateName(const IdentifierInfo &II, SourceLocation IILoc, Scope *S, const CXXScopeSpec *SS, TemplateTy &SuggestedTemplate, TemplateNameKind &SuggestedKind)
LookupResultKind getResultKind() const
Definition: Lookup.h:310
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:465
The type of a non-type template parameter.
Definition: Sema.h:6596
ParsedType getAsType() const
Retrieve the template type argument&#39;s type.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation getTemplateLoc() const
Definition: DeclTemplate.h:172
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:419
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:6440
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Lookup.h:56
A user-defined literal name, e.g., operator "" _i.
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:110
bool isInvalidType() const
Definition: DeclSpec.h:2432
TypeSourceInfo * getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &Args, QualType Canon=QualType()) const
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:508
DeclClass * getAsSingle() const
Definition: Lookup.h:496
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:2416
NamedDecl * 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.
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, const ParsedAttributesView &Attr)
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:922
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1616
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2594
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 ...
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:558
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
Definition: DeclBase.cpp:1683
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:522
Represents the results of name lookup.
Definition: Lookup.h:47
PtrTy get() const
Definition: Ownership.h:174
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:2184
Wrapper for source info for injected class names of class templates.
Definition: TypeLoc.h:676
static void dllExportImportClassTemplateSpecialization(Sema &S, ClassTemplateSpecializationDecl *Def)
Make a dllexport or dllimport attr on a class template specialization take effect.
TagKind getTagKind() const
Definition: Decl.h:3230
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:573
A convenient class for passing around template argument information.
Definition: TemplateBase.h:552
void FilterAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true)
bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T, sema::TemplateDeductionInfo &Info)
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:405
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:3941
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:2406
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:1125
Represents a declaration of a type.
Definition: Decl.h:2829
std::string getAsString(ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:587
void setRedeclaration(bool Val)
Definition: DeclSpec.h:2473
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3143
static void collectConjunctionTerms(Expr *Clause, SmallVectorImpl< Expr *> &Terms)
Collect all of the separable terms in the given condition, which might be a conjunction.
SourceLocation getLParenLoc() const
Definition: TypeLoc.h:1431
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.
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition: Ownership.h:281
const Type * getClass() const
Definition: Type.h:2646
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization...
Definition: Decl.h:3551
bool isNull() const
Definition: TypeLoc.h:118
CXXRecordDecl * getDecl() const
Definition: Type.cpp:3274
SourceLocation getDefaultArgumentLoc() const
Retrieves the location of the default argument declaration.
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:3399
ActionResult< ParsedType > TypeResult
Definition: Ownership.h:269
SourceLocation getTemplateEllipsisLoc() const
Definition: TemplateBase.h:544
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2544
void setSpecializationKind(TemplateSpecializationKind TSK)
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, const ASTContext *Context=nullptr) const
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
static TemplateArgument CreatePackCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument pack by copying the given set of template arguments.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5889
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1161
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
Definition: Sema.h:2165
NullPointerValueKind
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type...
Definition: Decl.h:3257
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
bool isNoreturnSpecified() const
Definition: DeclSpec.h:582
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:828
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1649
const LangOptions & getLangOpts() const
Definition: Sema.h:1204
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:1661
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:752
Decl * ActOnTemplateDeclarator(Scope *S, MultiTemplateParamsArg TemplateParameterLists, Declarator &D)
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:167
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1856
const TemplateArgument * data() const
Retrieve a pointer to the template argument list.
Definition: DeclTemplate.h:273
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:3262
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3300
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
void setLocalRangeBegin(SourceLocation L)
Definition: TypeLoc.h:1419
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...
Represents a linkage specification.
Definition: DeclCXX.h:2823
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclSpec.h:508
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Lookup.h:415
We are matching the template parameter lists of a template template argument against the template par...
Definition: Sema.h:6468
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:507
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:143
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:2116
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location...
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:877
QualType getElementType() const
Definition: Type.h:3000
RAII object used to change the argument pack substitution index within a Sema object.
Definition: Sema.h:7315
TypeSpecTypeLoc pushTypeSpec(QualType T)
Pushes space for a typespec TypeLoc.
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:2984
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1545
SourceLocation LAngleLoc
The location of the &#39;<&#39; before the template argument list.
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3385
We are matching the template parameter lists of two template template parameters as part of matching ...
Definition: Sema.h:6457
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1208
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3397
NodeId Parent
Definition: ASTDiff.cpp:192
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:217
void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD)
static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
void print(const PrintingPolicy &Policy, raw_ostream &Out) const
Print this template argument to the given output stream.
bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, TemplateArgumentLoc &Arg, SmallVectorImpl< TemplateArgument > &Converted)
bool hasAttr() const
Definition: DeclBase.h:538
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1848
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:277
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:2994
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.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1627
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3432
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:119
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
Definition: SemaExpr.cpp:15447
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2856
bool hasLValuePath() const
Definition: APValue.cpp:610
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1593
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...
TemplateParameterList * ActOnTemplateParameterList(unsigned Depth, SourceLocation ExportLoc, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
ActOnTemplateParameterList - Builds a TemplateParameterList, optionally constrained by RequiresClause...
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:548
Specifies that the expression should never be value-dependent.
Definition: Expr.h:705
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...
void addOuterRetainedLevel()
Add an outermost level that we are not substituting.
Definition: Template.h:150
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5964
SourceRange getRange() const
Definition: DeclSpec.h:68
TemplateParameterListEqualKind
Enumeration describing how template parameter lists are compared for equality.
Definition: Sema.h:6439
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:2192
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.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:264
bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams)
Check whether a template can be declared within this scope.
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:2922
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2168
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:2882
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, Optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
Definition: Attr.h:200
QualType getElementType() const
Definition: Type.h:2346
unsigned getFunctionScopeDepth() const
Definition: Decl.h:1582
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2140
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
Expr - This represents one expression.
Definition: Expr.h:106
Defines the clang::LangOptions interface.
StringRef getKindName() const
Definition: Decl.h:3226
DeclResult CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation TemplateNameLoc, const TemplateArgumentListInfo &TemplateArgs)
SourceLocation getLocalRangeEnd() const
Definition: TypeLoc.h:1423
LookupNameKind
Describes the kind of name lookup to perform.
Definition: Sema.h:3012
QualType getPointeeType() const
Definition: Type.h:2550
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:107
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition: Type.h:4884
bool isExplicitSpecified() const
Definition: DeclSpec.h:579
Expr * getAssociatedConstraints() const
Definition: DeclTemplate.h:445
int Id
Definition: ASTDiff.cpp:191
StateNode * Previous
QualType getCanonicalTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args) const
Declaration of a template type parameter.
unsigned getIndex() const
Definition: Type.h:4380
DeclContext * getEntity() const
Definition: Scope.h:324
This file defines the classes used to store parsed information about declaration-specifiers and decla...
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6589
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
Definition: Sema.h:7448
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:4866
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:68
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...
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:86
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:2019
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
std::string getAsString() const
getNameAsString - Retrieve the human-readable string for this name.
bool isChar16Type() const
Definition: Type.cpp:1813
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:461
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:1702
bool isNullPtrType() const
Definition: Type.h:6365
bool isFileContext() const
Definition: DeclBase.h:1409
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
DeclContext * getDeclContext()
Definition: DeclBase.h:428
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:771
bool hasEllipsis() const
Definition: DeclSpec.h:2443
bool isConstexprSpecified() const
Definition: DeclSpec.h:715
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:2530
void setMemberSpecialization()
Note that this member template is a specialization.
Definition: DeclTemplate.h:884
bool wasNotFoundInCurrentInstantiation() const
Determine whether no result was found because we could not search into dependent base classes of the ...
Definition: Lookup.h:435
void NoteAllFoundTemplates(TemplateName Name)
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition: DeclBase.h:1971
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack...
Definition: DeclBase.cpp:201
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
static DependentScopeDeclRefExpr * Create(const ASTContext &C, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:421
Represents the type decltype(expr) (C++11).
Definition: Type.h:4011
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous)
Perform semantic analysis for the given function template specialization.
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:460
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the class template or class template partial specialization which was specialized by this...
A namespace alias, stored as a NamespaceAliasDecl*.
bool isIdentifier() const
Determine whether this template name refers to an identifier.
Definition: TemplateName.h:481
int Depth
Definition: ASTDiff.cpp:191
void setLateTemplateParsed(bool ILT=true)
Definition: Decl.h:2046
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1004
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.h:2043
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn&#39;t a simple identifier.
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:621
void propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc)
Perform propagation of DLL attributes from a derived class to a templated base class for MS compatibi...
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
Definition: TemplateKinds.h:21
QualType getType() const
Definition: Expr.h:128
bool isFunctionOrMethod() const
Definition: DeclBase.h:1392
StorageClass
Storage classes.
Definition: Specifiers.h:206
SourceLocation getLocalRangeBegin() const
Definition: TypeLoc.h:1415
static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II, SourceRange &CondRange, Expr *&Cond)
Determine whether this failed name lookup should be treated as being disabled by a usage of std::enab...
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:4054
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Lookup.h:297
Declaration of an alias template.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1343
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:65
bool isInvalid() const
Definition: Ownership.h:170
void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl, MissingImportKind MIK, bool Recover=true)
Diagnose that the specified declaration needs to be visible but isn&#39;t, and suggest a module import th...
SourceLocation getEnd() const
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1805
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1365
Represents a GCC generic vector type.
Definition: Type.h:3024
void setLocation(SourceLocation L)
Definition: DeclBase.h:420
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:1571
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2576
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:3946
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1040
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition: Type.h:4522
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
ValueDecl * getDecl()
Definition: Expr.h:1059
BuiltinTemplateKind getBuiltinTemplateKind() const
void setDescribedClassTemplate(ClassTemplateDecl *Template)
Definition: DeclCXX.cpp:1589
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:1381
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:152
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2080
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:720
static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef, const ParsedTemplateArgument &Arg)
bool isChar8Type() const
Definition: Type.cpp:1807
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList *> TPLists)
Definition: Decl.cpp:3857
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:2351
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1110
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:5922
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:124
bool isEnum() const
Definition: Decl.h:3240
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
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...
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
Definition: Decl.cpp:3960
RecordDecl * getDecl() const
Definition: Type.h:4145
SourceLocation getNoreturnSpecLoc() const
Definition: DeclSpec.h:583
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
void addAttr(Attr *A)
Definition: DeclBase.h:487
std::pair< Expr *, std::string > findFailedBooleanCondition(Expr *Cond, bool AllowTopLevelCond)
Find the failed Boolean condition within a given Boolean constant expression, and describe it with a ...
const CXXScopeSpec & getScopeSpec() const
Retrieve the nested-name-specifier that precedes the template name in a template template argument...
DeclResult ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, SourceLocation ModulePrivateLoc, TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr, MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody=nullptr)
char * location_data() const
Retrieve the data associated with the source-location information.
Definition: DeclSpec.h:217
static bool DiagnoseUnexpandedParameterPacks(Sema &S, TemplateTemplateParmDecl *TTP)
Check for unexpanded parameter packs within the template parameters of a template template parameter...
CanQualType OverloadTy
Definition: ASTContext.h:1033
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template.
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1720
#define false
Definition: stdbool.h:33
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply...
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:182
Kind
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
const LValueBase getLValueBase() const
Definition: APValue.cpp:595
param_type_range param_types() const
Definition: Type.h:3796
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:204
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:2176
Represents the parsed form of a C++ template argument.
A stack object to be created when performing template instantiation.
Definition: Sema.h:7352
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3679
SCS getStorageClassSpec() const
Definition: DeclSpec.h:451
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
ASTContext & getASTContext() const
Definition: Sema.h:1211
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, ArrayRef< TemplateParameterList *> FriendTypeTPLists=None)
Definition: DeclFriend.cpp:35
static bool isSameAsPrimaryTemplate(TemplateParameterList *Params, ArrayRef< TemplateArgument > Args)
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:3368
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Encodes a location in the source.
QualType getReturnType() const
Definition: Type.h:3365
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4161
Represents typeof(type), a GCC extension.
Definition: Type.h:3984
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5555
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1958
void setBraceRange(SourceRange R)
Definition: Decl.h:3148
Attr * clone(ASTContext &C) const
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:245
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1860
void setExternLoc(SourceLocation Loc)
Sets the location of the extern keyword.
static void SetNestedNameSpecifier(TagDecl *T, const CXXScopeSpec &SS)
DeclarationName getName() const
getName - Returns the embedded declaration name.
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3020
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3290
void referenceDLLExportedClassMethods()
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
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". ...
bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name, SourceLocation NameLoc, ParsedTemplateTy *Template=nullptr)
Determine whether a particular identifier might be the name in a C++1z deduction-guide declaration...
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.h:401
QualType getElementType() const
Definition: Type.h:3059
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
Definition: SemaInternal.h:94
ParsedAttr - Represents a syntactic attribute.
Definition: ParsedAttr.h:105
Represents a vector type where either the type or size is dependent.
Definition: Type.h:3101
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3579
NamedDecl * ActOnNonTypeTemplateParameter(Scope *S, Declarator &D, unsigned Depth, unsigned Position, SourceLocation EqualLoc, Expr *DefaultArg)
KindType getKind() const
Determine what kind of template argument we have.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
bool hasVisibleDefaultArgument(const NamedDecl *D, llvm::SmallVectorImpl< Module *> *Modules=nullptr)
Determine if the template parameter D has a visible default argument.
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2045
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
Definition: DeclTemplate.h:163
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isMemberPointer() const
Definition: APValue.h:243
Name lookup found an unresolvable value declaration and cannot yet complete.
Definition: Lookup.h:69
static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized, NamedDecl *PrevDecl, SourceLocation Loc, bool IsPartialSpecialization)
Check whether a specialization is well-formed in the current context.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:360
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template...
TemplateNameKind ActOnDependentTemplateName(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool AllowInjectedClassName=false)
Form a dependent template name.
static bool hasVisibleDefaultArgument(Sema &S, const ParmDecl *D, llvm::SmallVectorImpl< Module *> *Modules)
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1864
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:89
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:149
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
void setPointOfInstantiation(SourceLocation Loc)
A class for iterating through a result set and possibly filtering out results.
Definition: Lookup.h:606
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2128
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2961
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Stmt.h:403
No entity found met the criteria.
Definition: Lookup.h:51
bool isLValue() const
Definition: APValue.h:238
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:164
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:149
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
Definition: TemplateBase.h:301
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1827
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:174
EnumDecl * getDecl() const
Definition: Type.h:4168
A template type parameter, stored as a type.
DeductionFailureInfo MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK, sema::TemplateDeductionInfo &Info)
Convert from Sema&#39;s representation of template deduction information to the form used in overload-can...
SourceLocation getInlineSpecLoc() const
Definition: DeclSpec.h:572
ArrayRef< ParmVarDecl * > getParams() const
Definition: TypeLoc.h:1462
void checkPartialSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We&#39;ve found a use of a template specialization that would select a partial specialization.
NamedDecl * next()
Definition: Lookup.h:632
static TemplateArgumentLoc convertTypeTemplateArgumentToTemplate(TypeLoc TLoc)
Convert a template-argument that we parsed as a type into a template, if possible.
bool isCanonical() const
Definition: Type.h:5933
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2275
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:592
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl, Expr *AssociatedConstraints=nullptr)
Create a class template node.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
void UnmarkAsLateParsedTemplate(FunctionDecl *FD)
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4794
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:2944
QualType getPointeeType() const
Definition: Type.h:2956
Represents a pack expansion of types.
Definition: Type.h:5165
SourceLocation getLocation() const
A POD class for pairing a NamedDecl* with an access specifier.
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1435
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1629
static void checkTemplatePartialSpecialization(Sema &S, PartialSpecDecl *Partial)
StringRef getName() const
Return the actual identifier string.
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:1876
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:2461
Represents a template argument.
Definition: TemplateBase.h:51
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
TagTypeKind
The kind of a tag type.
Definition: Type.h:4847
bool hasVisibleExplicitSpecialization(const NamedDecl *D, llvm::SmallVectorImpl< Module *> *Modules=nullptr)
Determine if there is a visible declaration of D that is an explicit specialization declaration for a...
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
The name does not refer to a template.
Definition: TemplateKinds.h:23
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2501
void setMemberSpecialization()
Note that this member template is a specialization.
bool isNull() const
Determine whether this template name is NULL.
bool RebuildTemplateParamsInCurrentInstantiation(TemplateParameterList *Params)
Rebuild the template parameters now that we know we&#39;re in a current instantiation.
void removeDefaultArgument()
Removes the default argument of this template parameter.
Dataflow Directional Tag Classes.
bool isExplicit() const
Whether this function is explicit.
Definition: DeclCXX.h:2591
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
bool isValid() const
Return true if this is a valid SourceLocation object.
ParsedTemplateTy getAsTemplate() const
Retrieve the template template argument&#39;s template name.
SourceLocation getLocStart() const LLVM_READONLY
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:499
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
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:2452
UnaryOperatorKind
ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
NestedNameSpecifier * getQualifier() const
Definition: Type.h:5102
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1264
CanQualType NullPtrTy
Definition: ASTContext.h:1032
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:571
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
bool hasUnnamedOrLocalType() const
Whether this type is or contains a local or unnamed type.
Definition: Type.cpp:3610
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:225
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 &#39;Type&#39;, insert an implicit cast.
Definition: Sema.cpp:470
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:130
SourceLocation getLocStart() const LLVM_READONLY
Definition: TypeLoc.h:154
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:80
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3488
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.
bool isRecord() const
Definition: DeclBase.h:1417
SourceLocation RAngleLoc
The location of the &#39;>&#39; after the template argument list.
Expr * getSourceExpression() const
Definition: TemplateBase.h:512
QualType getUnderlyingType() const
Definition: Decl.h:2927
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:118
AccessSpecifier getAccess() const
Definition: DeclBase.h:463
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:77
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:160
bool isInvalid() const
Determine whether the given template argument is invalid.
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
DeclarationName - The name of a declaration.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:506
Expr * getDefaultArg()
Definition: Decl.cpp:2539
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:988
Kind getKind() const
Definition: DeclBase.h:422
bool isBooleanType() const
Definition: Type.h:6453
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:3446
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3756
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:1564
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:739
static Expr * lookThroughRangesV3Condition(Preprocessor &PP, Expr *Cond)
Represents an enum.
Definition: Decl.h:3313
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2612
This names the __type_pack_element BuiltinTemplateDecl.
Definition: Builtins.h:248
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:146
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
TemplateSpecCandidate & addCandidate()
Add a new candidate with NumConversions conversion sequence slots to the overload set...
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".
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:580
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
A type that was preceded by the &#39;template&#39; keyword, stored as a Type*.
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:340
The name refers to a template whose specialization produces a type.
Definition: TemplateKinds.h:30
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
Definition: APValue.cpp:674
bool isNull() const
Determine whether this template argument has no value.
Definition: TemplateBase.h:238
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous)
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 &#39;auto&#39; typ...
Definition: Type.h:6459
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it&#39;s the object of a friend declaration...
Definition: DeclBase.h:1071
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:196
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2631
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
Definition: SemaDecl.cpp:1153
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
unsigned getNumParams() const
Definition: TypeLoc.h:1471
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2091
Represents a pointer to an Objective C object.
Definition: Type.h:5611
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:150
Pointer to a block type.
Definition: Type.h:2495
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
Name lookup found a single declaration that met the criteria.
Definition: Lookup.h:60
static void completeMemberSpecializationImpl(Sema &S, DeclT *OrigD, SourceLocation Loc)
Complete the explicit specialization of a member of a class template by updating the instantiated mem...
NamedDecl * 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...
const UnresolvedSetImpl & asUnresolvedSet() const
Definition: Lookup.h:320
bool HasSideEffects
Whether the evaluated expression has side effects.
Definition: Expr.h:544
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4135
Complex values, per C99 6.2.5p11.
Definition: Type.h:2333
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:3837
ParsedTemplateArgument getTemplatePackExpansion(SourceLocation EllipsisLoc) const
Retrieve a pack expansion of the given template template argument.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3505
CheckTemplateArgumentKind
Specifies the context in which a particular template argument is being checked.
Definition: Sema.h:6361
QualType getCanonicalTypeInternal() const
Definition: Type.h:2214
SourceLocation getVirtualSpecLoc() const
Definition: DeclSpec.h:577
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:156
TypedefNameDecl * getTypedefNameDecl() const
Definition: TypeLoc.h:669
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)
ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType)
Convert a parsed type into a parsed template argument.
T * getAttr() const
Definition: DeclBase.h:534
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:1810
CanQualType DependentTy
Definition: ASTContext.h:1033
bool isFunctionType() const
Definition: Type.h:6109
void setTypeSourceInfo(TypeSourceInfo *TI)
Definition: Decl.h:722
void setInstantiationOfStaticDataMember(VarDecl *VD, TemplateSpecializationKind TSK)
Specify that this variable is an instantiation of the static data member VD.
Definition: Decl.cpp:2490
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:716
ExtVectorType - Extended vector type.
Definition: Type.h:3143
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2529
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1675
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2251
Wrapper for source info for record types.
Definition: TypeLoc.h:717
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.
The template argument is a type.
Definition: TemplateBase.h:60
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:32
QualType getUnderlyingType() const
Definition: Type.h:3999
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:92
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
Definition: DeclBase.cpp:1095
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1460
TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl)
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:251
The template argument is actually a parameter pack.
Definition: TemplateBase.h:91
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2804
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2543
static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS)
Determine whether the given scope specifier has a template-id in it.
void checkClassLevelDLLAttribute(CXXRecordDecl *Class)
Check class-level dllimport/dllexport attribute.
void setInstantiationOf(VarTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this variable template specialization is actually an instantiation of the given variable te...
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2052
This is a scope that can contain a declaration.
Definition: Scope.h:59
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:2034
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2122
void CheckTemplatePartialSpecialization(ClassTemplatePartialSpecializationDecl *Partial)
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2235
A template argument list.
Definition: DeclTemplate.h:210
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:239
CXXRecordDecl * getNamingClass() const
Returns the &#39;naming class&#39; for this lookup, i.e.
Definition: Lookup.h:392
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1585
SourceLocation getDefaultArgumentLoc() const
Retrieve the location of the default argument, if any.
static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial)
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:235
unsigned getDepth() const
Definition: Type.h:4379
DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II)
getCXXLiteralOperatorName - Get the name of the literal operator function with II as the identifier...
ValueKind getKind() const
Definition: APValue.h:232
TypeResult ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false)
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:997
QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI, SourceLocation Loc)
Check that the type of a non-type template parameter is well-formed.
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5969
Represents a C++ struct/union/class.
Definition: DeclCXX.h:302
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:2399
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:5072
bool isValid() const
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:76
Represents a C array with an unspecified size.
Definition: Type.h:2782
TemplateName getCanonicalTemplateName(TemplateName Name) const
Retrieves the "canonical" template name that refers to a given template.
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:2169
void setConstexpr(bool IC)
Definition: Decl.h:2091
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5916
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1478
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:608
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:191
A structure for storing the information associated with an overloaded template name.
Definition: TemplateName.h:95
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...
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1841
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4438
Location information for a TemplateArgument.
Definition: TemplateBase.h:393
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:331
The "enum" keyword.
Definition: Type.h:4861
void DeclareImplicitDeductionGuides(TemplateDecl *Template, SourceLocation Loc)
Declare implicit deduction guides for a class template if we&#39;ve not already done so.
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:1009
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
bool isVirtualSpecified() const
Definition: DeclSpec.h:576
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:129
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2250
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
iterator end() const
Definition: Lookup.h:325
A template-id, e.g., f<int>.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:266
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
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&#39;s template argument list representation into our form.
Defines the clang::TargetInfo interface.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
SourceLocation getNameLoc() const
Definition: TypeLoc.h:518
bool isInlineSpecified() const
Definition: DeclSpec.h:569
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1645
static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D, SourceLocation InstLoc, bool WasQualifiedName)
Check the scope of an explicit instantiation.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:275
ExprResult ExprError()
Definition: Ownership.h:283
Decl * SubstDecl(Decl *D, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs)
StringRef getImmediateMacroName(SourceLocation Loc)
Retrieve the name of the immediate macro expansion.
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:930
CanQualType IntTy
Definition: ASTContext.h:1013
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
SourceLocation getExplicitSpecLoc() const
Definition: DeclSpec.h:580
static Expr * formAssociatedConstraints(TemplateParameterList *Params, FunctionDecl *FD)
[temp.constr.decl]p2: A template&#39;s associated constraints are defined as a single constraint-expressi...
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1942
The name refers to a variable template whose specialization produces a variable.
Definition: TemplateKinds.h:33
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:716
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:257
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:974
Represents an extended address space qualifier where the input address space value is dependent...
Definition: Type.h:2942
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4654
NamedDecl * getMostRecentDecl()
Definition: Decl.h:445
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2125
bool isPointerType() const
Definition: Type.h:6113
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:3246
SourceLocation getTemplateNameLoc() const
Definition: TemplateBase.h:538
void setInheritedDefaultArgument(const ASTContext &C, TemplateTemplateParmDecl *Prev)
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, const TemplateArgumentListInfo &Args) const
TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, bool AllowDeducedTST=false)
Perform substitution on the type T with a given set of template arguments.
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1134
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:572
void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc)
QualType getType() const
Definition: Decl.h:648
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:114
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:328
static bool DependsOnTemplateParameters(QualType T, TemplateParameterList *Params)
Determines whether a given type depends on the given parameter list.
Wrapper for template type parameters.
Definition: TypeLoc.h:733
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)
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:299
ASTContext & Context
Definition: Sema.h:319
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2899
This represents a decl that may have a name.
Definition: Decl.h:248
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:556
bool isTranslationUnit() const
Definition: DeclBase.h:1413
void dropAttr()
Definition: DeclBase.h:509
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
Definition: Expr.h:1088
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:75
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:458
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:2827
void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used)
Mark which template parameters can be deduced from a given template argument list.
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1669
No keyword precedes the qualified type name.
Definition: Type.h:4887
APSInt & getInt()
Definition: APValue.h:252
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:281
VarTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member variable template partial specialization from which this particular variable temp...
iterator begin() const
Definition: Lookup.h:324
QualType getElementType() const
Definition: Type.h:3115
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
Definition: DeclTemplate.h:648
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:595
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
SourceLocation getRAngleLoc() const
Definition: TemplateBase.h:569
unsigned NumArgs
NumArgs - The number of template arguments.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Lookup.h:513
The global specifier &#39;::&#39;. There is no stored value.
static void noteNonDeducibleParameters(Sema &S, TemplateParameterList *TemplateParams, const llvm::SmallBitVector &DeducibleParams)
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:288
void setType(QualType newType)
Definition: Decl.h:649
SourceLocation getBegin() const
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:176
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
Definition: Decl.h:730
void setDeletedAsWritten(bool D=true)
Definition: Decl.h:2127
bool isDependent() const
Determines whether this is a dependent template name.
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2728
Defines enum values for all the target-independent builtin functions.
Declaration of a template function.
Definition: DeclTemplate.h:968
void clear()
Clears out any current state.
Definition: Lookup.h:543
bool IsInsideALocalClassWithinATemplateFunction()
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2012
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateDecl *Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
Attr - This represents one attribute.
Definition: Attr.h:43
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:750
SourceLocation getLocation() const
Definition: DeclBase.h:419
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type...
Definition: Type.h:1741
static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc, TemplateDecl *TD, const TemplateParmDecl *D, TemplateArgumentListInfo &Args)
Diagnose a missing template argument.
QualType getPointeeType() const
Definition: Type.h:2632
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
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.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1079
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:1072
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:706