clang  8.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.getBeginLoc(), 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.getBeginLoc(), diag::err_template_kw_missing)
543  << "" << NameInfo.getName().getAsString() << SourceRange(Less, Greater);
544  return;
545  }
546 
547  // Try to correct the name by looking for templates and C++ named casts.
548  struct TemplateCandidateFilter : CorrectionCandidateCallback {
549  TemplateCandidateFilter() {
550  WantTypeSpecifiers = false;
551  WantExpressionKeywords = false;
552  WantRemainingKeywords = false;
553  WantCXXNamedCasts = true;
554  };
555  bool ValidateCandidate(const TypoCorrection &Candidate) override {
556  if (auto *ND = Candidate.getCorrectionDecl())
557  return isAcceptableTemplateName(ND->getASTContext(), ND, true);
558  return Candidate.isKeyword();
559  }
560  };
561 
562  DeclarationName Name = NameInfo.getName();
563  if (TypoCorrection Corrected =
564  CorrectTypo(NameInfo, LookupKind, S, &SS,
565  llvm::make_unique<TemplateCandidateFilter>(),
566  CTK_ErrorRecovery, LookupCtx)) {
567  auto *ND = Corrected.getFoundDecl();
568  if (ND)
569  ND = isAcceptableTemplateName(Context, ND,
570  /*AllowFunctionTemplates*/ true);
571  if (ND || Corrected.isKeyword()) {
572  if (LookupCtx) {
573  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
574  bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
575  Name.getAsString() == CorrectedStr;
576  diagnoseTypo(Corrected,
577  PDiag(diag::err_non_template_in_member_template_id_suggest)
578  << Name << LookupCtx << DroppedSpecifier
579  << SS.getRange(), false);
580  } else {
581  diagnoseTypo(Corrected,
582  PDiag(diag::err_non_template_in_template_id_suggest)
583  << Name, false);
584  }
585  if (Found)
586  Diag(Found->getLocation(),
587  diag::note_non_template_in_template_id_found);
588  return;
589  }
590  }
591 
592  Diag(NameInfo.getLoc(), diag::err_non_template_in_template_id)
593  << Name << SourceRange(Less, Greater);
594  if (Found)
595  Diag(Found->getLocation(), diag::note_non_template_in_template_id_found);
596 }
597 
598 /// ActOnDependentIdExpression - Handle a dependent id-expression that
599 /// was just parsed. This is only possible with an explicit scope
600 /// specifier naming a dependent type.
603  SourceLocation TemplateKWLoc,
604  const DeclarationNameInfo &NameInfo,
605  bool isAddressOfOperand,
606  const TemplateArgumentListInfo *TemplateArgs) {
607  DeclContext *DC = getFunctionLevelDeclContext();
608 
609  // C++11 [expr.prim.general]p12:
610  // An id-expression that denotes a non-static data member or non-static
611  // member function of a class can only be used:
612  // (...)
613  // - if that id-expression denotes a non-static data member and it
614  // appears in an unevaluated operand.
615  //
616  // If this might be the case, form a DependentScopeDeclRefExpr instead of a
617  // CXXDependentScopeMemberExpr. The former can instantiate to either
618  // DeclRefExpr or MemberExpr depending on lookup results, while the latter is
619  // always a MemberExpr.
620  bool MightBeCxx11UnevalField =
621  getLangOpts().CPlusPlus11 && isUnevaluatedContext();
622 
623  // Check if the nested name specifier is an enum type.
624  bool IsEnum = false;
625  if (NestedNameSpecifier *NNS = SS.getScopeRep())
626  IsEnum = dyn_cast_or_null<EnumType>(NNS->getAsType());
627 
628  if (!MightBeCxx11UnevalField && !isAddressOfOperand && !IsEnum &&
629  isa<CXXMethodDecl>(DC) && cast<CXXMethodDecl>(DC)->isInstance()) {
630  QualType ThisType = cast<CXXMethodDecl>(DC)->getThisType();
631 
632  // Since the 'this' expression is synthesized, we don't need to
633  // perform the double-lookup check.
634  NamedDecl *FirstQualifierInScope = nullptr;
635 
637  Context, /*This*/ nullptr, ThisType, /*IsArrow*/ true,
638  /*Op*/ SourceLocation(), SS.getWithLocInContext(Context), TemplateKWLoc,
639  FirstQualifierInScope, NameInfo, TemplateArgs);
640  }
641 
642  return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
643 }
644 
647  SourceLocation TemplateKWLoc,
648  const DeclarationNameInfo &NameInfo,
649  const TemplateArgumentListInfo *TemplateArgs) {
651  Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
652  TemplateArgs);
653 }
654 
655 
656 /// Determine whether we would be unable to instantiate this template (because
657 /// it either has no definition, or is in the process of being instantiated).
659  NamedDecl *Instantiation,
660  bool InstantiatedFromMember,
661  const NamedDecl *Pattern,
662  const NamedDecl *PatternDef,
664  bool Complain /*= true*/) {
665  assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||
666  isa<VarDecl>(Instantiation));
667 
668  bool IsEntityBeingDefined = false;
669  if (const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
670  IsEntityBeingDefined = TD->isBeingDefined();
671 
672  if (PatternDef && !IsEntityBeingDefined) {
673  NamedDecl *SuggestedDef = nullptr;
674  if (!hasVisibleDefinition(const_cast<NamedDecl*>(PatternDef), &SuggestedDef,
675  /*OnlyNeedComplete*/false)) {
676  // If we're allowed to diagnose this and recover, do so.
677  bool Recover = Complain && !isSFINAEContext();
678  if (Complain)
679  diagnoseMissingImport(PointOfInstantiation, SuggestedDef,
681  return !Recover;
682  }
683  return false;
684  }
685 
686  if (!Complain || (PatternDef && PatternDef->isInvalidDecl()))
687  return true;
688 
690  QualType InstantiationTy;
691  if (TagDecl *TD = dyn_cast<TagDecl>(Instantiation))
692  InstantiationTy = Context.getTypeDeclType(TD);
693  if (PatternDef) {
694  Diag(PointOfInstantiation,
695  diag::err_template_instantiate_within_definition)
696  << /*implicit|explicit*/(TSK != TSK_ImplicitInstantiation)
697  << InstantiationTy;
698  // Not much point in noting the template declaration here, since
699  // we're lexically inside it.
700  Instantiation->setInvalidDecl();
701  } else if (InstantiatedFromMember) {
702  if (isa<FunctionDecl>(Instantiation)) {
703  Diag(PointOfInstantiation,
704  diag::err_explicit_instantiation_undefined_member)
705  << /*member function*/ 1 << Instantiation->getDeclName()
706  << Instantiation->getDeclContext();
707  Note = diag::note_explicit_instantiation_here;
708  } else {
709  assert(isa<TagDecl>(Instantiation) && "Must be a TagDecl!");
710  Diag(PointOfInstantiation,
711  diag::err_implicit_instantiate_member_undefined)
712  << InstantiationTy;
713  Note = diag::note_member_declared_at;
714  }
715  } else {
716  if (isa<FunctionDecl>(Instantiation)) {
717  Diag(PointOfInstantiation,
718  diag::err_explicit_instantiation_undefined_func_template)
719  << Pattern;
720  Note = diag::note_explicit_instantiation_here;
721  } else if (isa<TagDecl>(Instantiation)) {
722  Diag(PointOfInstantiation, diag::err_template_instantiate_undefined)
723  << (TSK != TSK_ImplicitInstantiation)
724  << InstantiationTy;
725  Note = diag::note_template_decl_here;
726  } else {
727  assert(isa<VarDecl>(Instantiation) && "Must be a VarDecl!");
728  if (isa<VarTemplateSpecializationDecl>(Instantiation)) {
729  Diag(PointOfInstantiation,
730  diag::err_explicit_instantiation_undefined_var_template)
731  << Instantiation;
732  Instantiation->setInvalidDecl();
733  } else
734  Diag(PointOfInstantiation,
735  diag::err_explicit_instantiation_undefined_member)
736  << /*static data member*/ 2 << Instantiation->getDeclName()
737  << Instantiation->getDeclContext();
738  Note = diag::note_explicit_instantiation_here;
739  }
740  }
741  if (Note) // Diagnostics were emitted.
742  Diag(Pattern->getLocation(), Note.getValue());
743 
744  // In general, Instantiation isn't marked invalid to get more than one
745  // error for multiple undefined instantiations. But the code that does
746  // explicit declaration -> explicit definition conversion can't handle
747  // invalid declarations, so mark as invalid in that case.
749  Instantiation->setInvalidDecl();
750  return true;
751 }
752 
753 /// DiagnoseTemplateParameterShadow - Produce a diagnostic complaining
754 /// that the template parameter 'PrevDecl' is being shadowed by a new
755 /// declaration at location Loc. Returns true to indicate that this is
756 /// an error, and false otherwise.
758  assert(PrevDecl->isTemplateParameter() && "Not a template parameter");
759 
760  // Microsoft Visual C++ permits template parameters to be shadowed.
761  if (getLangOpts().MicrosoftExt)
762  return;
763 
764  // C++ [temp.local]p4:
765  // A template-parameter shall not be redeclared within its
766  // scope (including nested scopes).
767  Diag(Loc, diag::err_template_param_shadow)
768  << cast<NamedDecl>(PrevDecl)->getDeclName();
769  Diag(PrevDecl->getLocation(), diag::note_template_param_here);
770 }
771 
772 /// AdjustDeclIfTemplate - If the given decl happens to be a template, reset
773 /// the parameter D to reference the templated declaration and return a pointer
774 /// to the template declaration. Otherwise, do nothing to D and return null.
776  if (TemplateDecl *Temp = dyn_cast_or_null<TemplateDecl>(D)) {
777  D = Temp->getTemplatedDecl();
778  return Temp;
779  }
780  return nullptr;
781 }
782 
784  SourceLocation EllipsisLoc) const {
785  assert(Kind == Template &&
786  "Only template template arguments can be pack expansions here");
787  assert(getAsTemplate().get().containsUnexpandedParameterPack() &&
788  "Template template argument pack expansion without packs");
789  ParsedTemplateArgument Result(*this);
790  Result.EllipsisLoc = EllipsisLoc;
791  return Result;
792 }
793 
795  const ParsedTemplateArgument &Arg) {
796 
797  switch (Arg.getKind()) {
799  TypeSourceInfo *DI;
800  QualType T = SemaRef.GetTypeFromParser(Arg.getAsType(), &DI);
801  if (!DI)
802  DI = SemaRef.Context.getTrivialTypeSourceInfo(T, Arg.getLocation());
803  return TemplateArgumentLoc(TemplateArgument(T), DI);
804  }
805 
807  Expr *E = static_cast<Expr *>(Arg.getAsExpr());
809  }
810 
812  TemplateName Template = Arg.getAsTemplate().get();
813  TemplateArgument TArg;
814  if (Arg.getEllipsisLoc().isValid())
815  TArg = TemplateArgument(Template, Optional<unsigned int>());
816  else
817  TArg = Template;
818  return TemplateArgumentLoc(TArg,
820  SemaRef.Context),
821  Arg.getLocation(),
822  Arg.getEllipsisLoc());
823  }
824  }
825 
826  llvm_unreachable("Unhandled parsed template argument");
827 }
828 
829 /// Translates template arguments as provided by the parser
830 /// into template arguments used by semantic analysis.
832  TemplateArgumentListInfo &TemplateArgs) {
833  for (unsigned I = 0, Last = TemplateArgsIn.size(); I != Last; ++I)
834  TemplateArgs.addArgument(translateTemplateArgument(*this,
835  TemplateArgsIn[I]));
836 }
837 
839  SourceLocation Loc,
840  IdentifierInfo *Name) {
841  NamedDecl *PrevDecl = SemaRef.LookupSingleName(
843  if (PrevDecl && PrevDecl->isTemplateParameter())
844  SemaRef.DiagnoseTemplateParameterShadow(Loc, PrevDecl);
845 }
846 
847 /// Convert a parsed type into a parsed template argument. This is mostly
848 /// trivial, except that we may have parsed a C++17 deduced class template
849 /// specialization type, in which case we should form a template template
850 /// argument instead of a type template argument.
852  TypeSourceInfo *TInfo;
853  QualType T = GetTypeFromParser(ParsedType.get(), &TInfo);
854  if (T.isNull())
855  return ParsedTemplateArgument();
856  assert(TInfo && "template argument with no location");
857 
858  // If we might have formed a deduced template specialization type, convert
859  // it to a template template argument.
860  if (getLangOpts().CPlusPlus17) {
861  TypeLoc TL = TInfo->getTypeLoc();
862  SourceLocation EllipsisLoc;
863  if (auto PET = TL.getAs<PackExpansionTypeLoc>()) {
864  EllipsisLoc = PET.getEllipsisLoc();
865  TL = PET.getPatternLoc();
866  }
867 
868  CXXScopeSpec SS;
869  if (auto ET = TL.getAs<ElaboratedTypeLoc>()) {
870  SS.Adopt(ET.getQualifierLoc());
871  TL = ET.getNamedTypeLoc();
872  }
873 
874  if (auto DTST = TL.getAs<DeducedTemplateSpecializationTypeLoc>()) {
875  TemplateName Name = DTST.getTypePtr()->getTemplateName();
876  if (SS.isSet())
877  Name = Context.getQualifiedTemplateName(SS.getScopeRep(),
878  /*HasTemplateKeyword*/ false,
879  Name.getAsTemplateDecl());
880  ParsedTemplateArgument Result(SS, TemplateTy::make(Name),
881  DTST.getTemplateNameLoc());
882  if (EllipsisLoc.isValid())
883  Result = Result.getTemplatePackExpansion(EllipsisLoc);
884  return Result;
885  }
886  }
887 
888  // This is a normal type template argument. Note, if the type template
889  // argument is an injected-class-name for a template, it has a dual nature
890  // and can be used as either a type or a template. We handle that in
891  // convertTypeTemplateArgumentToTemplate.
893  ParsedType.get().getAsOpaquePtr(),
894  TInfo->getTypeLoc().getBeginLoc());
895 }
896 
897 /// ActOnTypeParameter - Called when a C++ template type parameter
898 /// (e.g., "typename T") has been parsed. Typename specifies whether
899 /// the keyword "typename" was used to declare the type parameter
900 /// (otherwise, "class" was used), and KeyLoc is the location of the
901 /// "class" or "typename" keyword. ParamName is the name of the
902 /// parameter (NULL indicates an unnamed template parameter) and
903 /// ParamNameLoc is the location of the parameter name (if any).
904 /// If the type parameter has a default argument, it will be added
905 /// later via ActOnTypeParameterDefault.
907  SourceLocation EllipsisLoc,
908  SourceLocation KeyLoc,
909  IdentifierInfo *ParamName,
910  SourceLocation ParamNameLoc,
911  unsigned Depth, unsigned Position,
912  SourceLocation EqualLoc,
913  ParsedType DefaultArg) {
914  assert(S->isTemplateParamScope() &&
915  "Template type parameter not in template parameter scope!");
916 
917  SourceLocation Loc = ParamNameLoc;
918  if (!ParamName)
919  Loc = KeyLoc;
920 
921  bool IsParameterPack = EllipsisLoc.isValid();
922  TemplateTypeParmDecl *Param
924  KeyLoc, Loc, Depth, Position, ParamName,
925  Typename, IsParameterPack);
926  Param->setAccess(AS_public);
927 
928  if (ParamName) {
929  maybeDiagnoseTemplateParameterShadow(*this, S, ParamNameLoc, ParamName);
930 
931  // Add the template parameter into the current scope.
932  S->AddDecl(Param);
933  IdResolver.AddDecl(Param);
934  }
935 
936  // C++0x [temp.param]p9:
937  // A default template-argument may be specified for any kind of
938  // template-parameter that is not a template parameter pack.
939  if (DefaultArg && IsParameterPack) {
940  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
941  DefaultArg = nullptr;
942  }
943 
944  // Handle the default argument, if provided.
945  if (DefaultArg) {
946  TypeSourceInfo *DefaultTInfo;
947  GetTypeFromParser(DefaultArg, &DefaultTInfo);
948 
949  assert(DefaultTInfo && "expected source information for type");
950 
951  // Check for unexpanded parameter packs.
952  if (DiagnoseUnexpandedParameterPack(Loc, DefaultTInfo,
953  UPPC_DefaultArgument))
954  return Param;
955 
956  // Check the template argument itself.
957  if (CheckTemplateArgument(Param, DefaultTInfo)) {
958  Param->setInvalidDecl();
959  return Param;
960  }
961 
962  Param->setDefaultArgument(DefaultTInfo);
963  }
964 
965  return Param;
966 }
967 
968 /// Check that the type of a non-type template parameter is
969 /// well-formed.
970 ///
971 /// \returns the (possibly-promoted) parameter type if valid;
972 /// otherwise, produces a diagnostic and returns a NULL type.
974  SourceLocation Loc) {
975  if (TSI->getType()->isUndeducedType()) {
976  // C++17 [temp.dep.expr]p3:
977  // An id-expression is type-dependent if it contains
978  // - an identifier associated by name lookup with a non-type
979  // template-parameter declared with a type that contains a
980  // placeholder type (7.1.7.4),
981  TSI = SubstAutoTypeSourceInfo(TSI, Context.DependentTy);
982  }
983 
984  return CheckNonTypeTemplateParameterType(TSI->getType(), Loc);
985 }
986 
988  SourceLocation Loc) {
989  // We don't allow variably-modified types as the type of non-type template
990  // parameters.
991  if (T->isVariablyModifiedType()) {
992  Diag(Loc, diag::err_variably_modified_nontype_template_param)
993  << T;
994  return QualType();
995  }
996 
997  // C++ [temp.param]p4:
998  //
999  // A non-type template-parameter shall have one of the following
1000  // (optionally cv-qualified) types:
1001  //
1002  // -- integral or enumeration type,
1003  if (T->isIntegralOrEnumerationType() ||
1004  // -- pointer to object or pointer to function,
1005  T->isPointerType() ||
1006  // -- reference to object or reference to function,
1007  T->isReferenceType() ||
1008  // -- pointer to member,
1009  T->isMemberPointerType() ||
1010  // -- std::nullptr_t.
1011  T->isNullPtrType() ||
1012  // If T is a dependent type, we can't do the check now, so we
1013  // assume that it is well-formed.
1014  T->isDependentType() ||
1015  // Allow use of auto in template parameter declarations.
1016  T->isUndeducedType()) {
1017  // C++ [temp.param]p5: The top-level cv-qualifiers on the template-parameter
1018  // are ignored when determining its type.
1019  return T.getUnqualifiedType();
1020  }
1021 
1022  // C++ [temp.param]p8:
1023  //
1024  // A non-type template-parameter of type "array of T" or
1025  // "function returning T" is adjusted to be of type "pointer to
1026  // T" or "pointer to function returning T", respectively.
1027  else if (T->isArrayType() || T->isFunctionType())
1028  return Context.getDecayedType(T);
1029 
1030  Diag(Loc, diag::err_template_nontype_parm_bad_type)
1031  << T;
1032 
1033  return QualType();
1034 }
1035 
1037  unsigned Depth,
1038  unsigned Position,
1039  SourceLocation EqualLoc,
1040  Expr *Default) {
1041  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
1042 
1043  // Check that we have valid decl-specifiers specified.
1044  auto CheckValidDeclSpecifiers = [this, &D] {
1045  // C++ [temp.param]
1046  // p1
1047  // template-parameter:
1048  // ...
1049  // parameter-declaration
1050  // p2
1051  // ... A storage class shall not be specified in a template-parameter
1052  // declaration.
1053  // [dcl.typedef]p1:
1054  // The typedef specifier [...] shall not be used in the decl-specifier-seq
1055  // of a parameter-declaration
1056  const DeclSpec &DS = D.getDeclSpec();
1057  auto EmitDiag = [this](SourceLocation Loc) {
1058  Diag(Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
1059  << FixItHint::CreateRemoval(Loc);
1060  };
1062  EmitDiag(DS.getStorageClassSpecLoc());
1063 
1065  EmitDiag(DS.getThreadStorageClassSpecLoc());
1066 
1067  // [dcl.inline]p1:
1068  // The inline specifier can be applied only to the declaration or
1069  // definition of a variable or function.
1070 
1071  if (DS.isInlineSpecified())
1072  EmitDiag(DS.getInlineSpecLoc());
1073 
1074  // [dcl.constexpr]p1:
1075  // The constexpr specifier shall be applied only to the definition of a
1076  // variable or variable template or the declaration of a function or
1077  // function template.
1078 
1079  if (DS.isConstexprSpecified())
1080  EmitDiag(DS.getConstexprSpecLoc());
1081 
1082  // [dcl.fct.spec]p1:
1083  // Function-specifiers can be used only in function declarations.
1084 
1085  if (DS.isVirtualSpecified())
1086  EmitDiag(DS.getVirtualSpecLoc());
1087 
1088  if (DS.isExplicitSpecified())
1089  EmitDiag(DS.getExplicitSpecLoc());
1090 
1091  if (DS.isNoreturnSpecified())
1092  EmitDiag(DS.getNoreturnSpecLoc());
1093  };
1094 
1095  CheckValidDeclSpecifiers();
1096 
1097  if (TInfo->getType()->isUndeducedType()) {
1098  Diag(D.getIdentifierLoc(),
1099  diag::warn_cxx14_compat_template_nontype_parm_auto_type)
1100  << QualType(TInfo->getType()->getContainedAutoType(), 0);
1101  }
1102 
1103  assert(S->isTemplateParamScope() &&
1104  "Non-type template parameter not in template parameter scope!");
1105  bool Invalid = false;
1106 
1107  QualType T = CheckNonTypeTemplateParameterType(TInfo, D.getIdentifierLoc());
1108  if (T.isNull()) {
1109  T = Context.IntTy; // Recover with an 'int' type.
1110  Invalid = true;
1111  }
1112 
1113  IdentifierInfo *ParamName = D.getIdentifier();
1114  bool IsParameterPack = D.hasEllipsis();
1116  Context, Context.getTranslationUnitDecl(), D.getBeginLoc(),
1117  D.getIdentifierLoc(), Depth, Position, ParamName, T, IsParameterPack,
1118  TInfo);
1119  Param->setAccess(AS_public);
1120 
1121  if (Invalid)
1122  Param->setInvalidDecl();
1123 
1124  if (ParamName) {
1126  ParamName);
1127 
1128  // Add the template parameter into the current scope.
1129  S->AddDecl(Param);
1130  IdResolver.AddDecl(Param);
1131  }
1132 
1133  // C++0x [temp.param]p9:
1134  // A default template-argument may be specified for any kind of
1135  // template-parameter that is not a template parameter pack.
1136  if (Default && IsParameterPack) {
1137  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1138  Default = nullptr;
1139  }
1140 
1141  // Check the well-formedness of the default template argument, if provided.
1142  if (Default) {
1143  // Check for unexpanded parameter packs.
1144  if (DiagnoseUnexpandedParameterPack(Default, UPPC_DefaultArgument))
1145  return Param;
1146 
1147  TemplateArgument Converted;
1148  ExprResult DefaultRes =
1149  CheckTemplateArgument(Param, Param->getType(), Default, Converted);
1150  if (DefaultRes.isInvalid()) {
1151  Param->setInvalidDecl();
1152  return Param;
1153  }
1154  Default = DefaultRes.get();
1155 
1156  Param->setDefaultArgument(Default);
1157  }
1158 
1159  return Param;
1160 }
1161 
1162 /// ActOnTemplateTemplateParameter - Called when a C++ template template
1163 /// parameter (e.g. T in template <template <typename> class T> class array)
1164 /// has been parsed. S is the current scope.
1166  SourceLocation TmpLoc,
1167  TemplateParameterList *Params,
1168  SourceLocation EllipsisLoc,
1169  IdentifierInfo *Name,
1170  SourceLocation NameLoc,
1171  unsigned Depth,
1172  unsigned Position,
1173  SourceLocation EqualLoc,
1174  ParsedTemplateArgument Default) {
1175  assert(S->isTemplateParamScope() &&
1176  "Template template parameter not in template parameter scope!");
1177 
1178  // Construct the parameter object.
1179  bool IsParameterPack = EllipsisLoc.isValid();
1180  TemplateTemplateParmDecl *Param =
1182  NameLoc.isInvalid()? TmpLoc : NameLoc,
1183  Depth, Position, IsParameterPack,
1184  Name, Params);
1185  Param->setAccess(AS_public);
1186 
1187  // If the template template parameter has a name, then link the identifier
1188  // into the scope and lookup mechanisms.
1189  if (Name) {
1190  maybeDiagnoseTemplateParameterShadow(*this, S, NameLoc, Name);
1191 
1192  S->AddDecl(Param);
1193  IdResolver.AddDecl(Param);
1194  }
1195 
1196  if (Params->size() == 0) {
1197  Diag(Param->getLocation(), diag::err_template_template_parm_no_parms)
1198  << SourceRange(Params->getLAngleLoc(), Params->getRAngleLoc());
1199  Param->setInvalidDecl();
1200  }
1201 
1202  // C++0x [temp.param]p9:
1203  // A default template-argument may be specified for any kind of
1204  // template-parameter that is not a template parameter pack.
1205  if (IsParameterPack && !Default.isInvalid()) {
1206  Diag(EqualLoc, diag::err_template_param_pack_default_arg);
1207  Default = ParsedTemplateArgument();
1208  }
1209 
1210  if (!Default.isInvalid()) {
1211  // Check only that we have a template template argument. We don't want to
1212  // try to check well-formedness now, because our template template parameter
1213  // might have dependent types in its template parameters, which we wouldn't
1214  // be able to match now.
1215  //
1216  // If none of the template template parameter's template arguments mention
1217  // other template parameters, we could actually perform more checking here.
1218  // However, it isn't worth doing.
1219  TemplateArgumentLoc DefaultArg = translateTemplateArgument(*this, Default);
1220  if (DefaultArg.getArgument().getAsTemplate().isNull()) {
1221  Diag(DefaultArg.getLocation(), diag::err_template_arg_not_valid_template)
1222  << DefaultArg.getSourceRange();
1223  return Param;
1224  }
1225 
1226  // Check for unexpanded parameter packs.
1227  if (DiagnoseUnexpandedParameterPack(DefaultArg.getLocation(),
1228  DefaultArg.getArgument().getAsTemplate(),
1229  UPPC_DefaultArgument))
1230  return Param;
1231 
1232  Param->setDefaultArgument(Context, DefaultArg);
1233  }
1234 
1235  return Param;
1236 }
1237 
1238 /// ActOnTemplateParameterList - Builds a TemplateParameterList, optionally
1239 /// constrained by RequiresClause, that contains the template parameters in
1240 /// Params.
1243  SourceLocation ExportLoc,
1244  SourceLocation TemplateLoc,
1245  SourceLocation LAngleLoc,
1246  ArrayRef<NamedDecl *> Params,
1247  SourceLocation RAngleLoc,
1248  Expr *RequiresClause) {
1249  if (ExportLoc.isValid())
1250  Diag(ExportLoc, diag::warn_template_export_unsupported);
1251 
1253  Context, TemplateLoc, LAngleLoc,
1254  llvm::makeArrayRef(Params.data(), Params.size()),
1255  RAngleLoc, RequiresClause);
1256 }
1257 
1259  const CXXScopeSpec &SS) {
1260  if (SS.isSet())
1262 }
1263 
1265  Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
1266  CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
1267  const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,
1268  AccessSpecifier AS, SourceLocation ModulePrivateLoc,
1269  SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists,
1270  TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody) {
1271  assert(TemplateParams && TemplateParams->size() > 0 &&
1272  "No template parameters");
1273  assert(TUK != TUK_Reference && "Can only declare or define class templates");
1274  bool Invalid = false;
1275 
1276  // Check that we can declare a template here.
1277  if (CheckTemplateDeclScope(S, TemplateParams))
1278  return true;
1279 
1281  assert(Kind != TTK_Enum && "can't build template of enumerated type");
1282 
1283  // There is no such thing as an unnamed class template.
1284  if (!Name) {
1285  Diag(KWLoc, diag::err_template_unnamed_class);
1286  return true;
1287  }
1288 
1289  // Find any previous declaration with this name. For a friend with no
1290  // scope explicitly specified, we only look for tag declarations (per
1291  // C++11 [basic.lookup.elab]p2).
1292  DeclContext *SemanticContext;
1293  LookupResult Previous(*this, Name, NameLoc,
1294  (SS.isEmpty() && TUK == TUK_Friend)
1295  ? LookupTagName : LookupOrdinaryName,
1296  forRedeclarationInCurContext());
1297  if (SS.isNotEmpty() && !SS.isInvalid()) {
1298  SemanticContext = computeDeclContext(SS, true);
1299  if (!SemanticContext) {
1300  // FIXME: Horrible, horrible hack! We can't currently represent this
1301  // in the AST, and historically we have just ignored such friend
1302  // class templates, so don't complain here.
1303  Diag(NameLoc, TUK == TUK_Friend
1304  ? diag::warn_template_qualified_friend_ignored
1305  : diag::err_template_qualified_declarator_no_match)
1306  << SS.getScopeRep() << SS.getRange();
1307  return TUK != TUK_Friend;
1308  }
1309 
1310  if (RequireCompleteDeclContext(SS, SemanticContext))
1311  return true;
1312 
1313  // If we're adding a template to a dependent context, we may need to
1314  // rebuilding some of the types used within the template parameter list,
1315  // now that we know what the current instantiation is.
1316  if (SemanticContext->isDependentContext()) {
1317  ContextRAII SavedContext(*this, SemanticContext);
1318  if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
1319  Invalid = true;
1320  } else if (TUK != TUK_Friend && TUK != TUK_Reference)
1321  diagnoseQualifiedDeclaration(SS, SemanticContext, Name, NameLoc, false);
1322 
1323  LookupQualifiedName(Previous, SemanticContext);
1324  } else {
1325  SemanticContext = CurContext;
1326 
1327  // C++14 [class.mem]p14:
1328  // If T is the name of a class, then each of the following shall have a
1329  // name different from T:
1330  // -- every member template of class T
1331  if (TUK != TUK_Friend &&
1332  DiagnoseClassNameShadow(SemanticContext,
1333  DeclarationNameInfo(Name, NameLoc)))
1334  return true;
1335 
1336  LookupName(Previous, S);
1337  }
1338 
1339  if (Previous.isAmbiguous())
1340  return true;
1341 
1342  NamedDecl *PrevDecl = nullptr;
1343  if (Previous.begin() != Previous.end())
1344  PrevDecl = (*Previous.begin())->getUnderlyingDecl();
1345 
1346  if (PrevDecl && PrevDecl->isTemplateParameter()) {
1347  // Maybe we will complain about the shadowed template parameter.
1348  DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
1349  // Just pretend that we didn't see the previous declaration.
1350  PrevDecl = nullptr;
1351  }
1352 
1353  // If there is a previous declaration with the same name, check
1354  // whether this is a valid redeclaration.
1355  ClassTemplateDecl *PrevClassTemplate =
1356  dyn_cast_or_null<ClassTemplateDecl>(PrevDecl);
1357 
1358  // We may have found the injected-class-name of a class template,
1359  // class template partial specialization, or class template specialization.
1360  // In these cases, grab the template that is being defined or specialized.
1361  if (!PrevClassTemplate && PrevDecl && isa<CXXRecordDecl>(PrevDecl) &&
1362  cast<CXXRecordDecl>(PrevDecl)->isInjectedClassName()) {
1363  PrevDecl = cast<CXXRecordDecl>(PrevDecl->getDeclContext());
1364  PrevClassTemplate
1365  = cast<CXXRecordDecl>(PrevDecl)->getDescribedClassTemplate();
1366  if (!PrevClassTemplate && isa<ClassTemplateSpecializationDecl>(PrevDecl)) {
1367  PrevClassTemplate
1368  = cast<ClassTemplateSpecializationDecl>(PrevDecl)
1369  ->getSpecializedTemplate();
1370  }
1371  }
1372 
1373  if (TUK == TUK_Friend) {
1374  // C++ [namespace.memdef]p3:
1375  // [...] When looking for a prior declaration of a class or a function
1376  // declared as a friend, and when the name of the friend class or
1377  // function is neither a qualified name nor a template-id, scopes outside
1378  // the innermost enclosing namespace scope are not considered.
1379  if (!SS.isSet()) {
1380  DeclContext *OutermostContext = CurContext;
1381  while (!OutermostContext->isFileContext())
1382  OutermostContext = OutermostContext->getLookupParent();
1383 
1384  if (PrevDecl &&
1385  (OutermostContext->Equals(PrevDecl->getDeclContext()) ||
1386  OutermostContext->Encloses(PrevDecl->getDeclContext()))) {
1387  SemanticContext = PrevDecl->getDeclContext();
1388  } else {
1389  // Declarations in outer scopes don't matter. However, the outermost
1390  // context we computed is the semantic context for our new
1391  // declaration.
1392  PrevDecl = PrevClassTemplate = nullptr;
1393  SemanticContext = OutermostContext;
1394 
1395  // Check that the chosen semantic context doesn't already contain a
1396  // declaration of this name as a non-tag type.
1397  Previous.clear(LookupOrdinaryName);
1398  DeclContext *LookupContext = SemanticContext;
1399  while (LookupContext->isTransparentContext())
1400  LookupContext = LookupContext->getLookupParent();
1401  LookupQualifiedName(Previous, LookupContext);
1402 
1403  if (Previous.isAmbiguous())
1404  return true;
1405 
1406  if (Previous.begin() != Previous.end())
1407  PrevDecl = (*Previous.begin())->getUnderlyingDecl();
1408  }
1409  }
1410  } else if (PrevDecl &&
1411  !isDeclInScope(Previous.getRepresentativeDecl(), SemanticContext,
1412  S, SS.isValid()))
1413  PrevDecl = PrevClassTemplate = nullptr;
1414 
1415  if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
1416  PrevDecl ? Previous.getRepresentativeDecl() : nullptr)) {
1417  if (SS.isEmpty() &&
1418  !(PrevClassTemplate &&
1419  PrevClassTemplate->getDeclContext()->getRedeclContext()->Equals(
1420  SemanticContext->getRedeclContext()))) {
1421  Diag(KWLoc, diag::err_using_decl_conflict_reverse);
1422  Diag(Shadow->getTargetDecl()->getLocation(),
1423  diag::note_using_decl_target);
1424  Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
1425  // Recover by ignoring the old declaration.
1426  PrevDecl = PrevClassTemplate = nullptr;
1427  }
1428  }
1429 
1430  // TODO Memory management; associated constraints are not always stored.
1431  Expr *const CurAC = formAssociatedConstraints(TemplateParams, nullptr);
1432 
1433  if (PrevClassTemplate) {
1434  // Ensure that the template parameter lists are compatible. Skip this check
1435  // for a friend in a dependent context: the template parameter list itself
1436  // could be dependent.
1437  if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1438  !TemplateParameterListsAreEqual(TemplateParams,
1439  PrevClassTemplate->getTemplateParameters(),
1440  /*Complain=*/true,
1441  TPL_TemplateMatch))
1442  return true;
1443 
1444  // Check for matching associated constraints on redeclarations.
1445  const Expr *const PrevAC = PrevClassTemplate->getAssociatedConstraints();
1446  const bool RedeclACMismatch = [&] {
1447  if (!(CurAC || PrevAC))
1448  return false; // Nothing to check; no mismatch.
1449  if (CurAC && PrevAC) {
1450  llvm::FoldingSetNodeID CurACInfo, PrevACInfo;
1451  CurAC->Profile(CurACInfo, Context, /*Canonical=*/true);
1452  PrevAC->Profile(PrevACInfo, Context, /*Canonical=*/true);
1453  if (CurACInfo == PrevACInfo)
1454  return false; // All good; no mismatch.
1455  }
1456  return true;
1457  }();
1458 
1459  if (RedeclACMismatch) {
1460  Diag(CurAC ? CurAC->getBeginLoc() : NameLoc,
1461  diag::err_template_different_associated_constraints);
1462  Diag(PrevAC ? PrevAC->getBeginLoc() : PrevClassTemplate->getLocation(),
1463  diag::note_template_prev_declaration)
1464  << /*declaration*/ 0;
1465  return true;
1466  }
1467 
1468  // C++ [temp.class]p4:
1469  // In a redeclaration, partial specialization, explicit
1470  // specialization or explicit instantiation of a class template,
1471  // the class-key shall agree in kind with the original class
1472  // template declaration (7.1.5.3).
1473  RecordDecl *PrevRecordDecl = PrevClassTemplate->getTemplatedDecl();
1474  if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind,
1475  TUK == TUK_Definition, KWLoc, Name)) {
1476  Diag(KWLoc, diag::err_use_with_wrong_tag)
1477  << Name
1478  << FixItHint::CreateReplacement(KWLoc, PrevRecordDecl->getKindName());
1479  Diag(PrevRecordDecl->getLocation(), diag::note_previous_use);
1480  Kind = PrevRecordDecl->getTagKind();
1481  }
1482 
1483  // Check for redefinition of this class template.
1484  if (TUK == TUK_Definition) {
1485  if (TagDecl *Def = PrevRecordDecl->getDefinition()) {
1486  // If we have a prior definition that is not visible, treat this as
1487  // simply making that previous definition visible.
1488  NamedDecl *Hidden = nullptr;
1489  if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
1490  SkipBody->ShouldSkip = true;
1491  SkipBody->Previous = Def;
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  } else {
1498  Diag(NameLoc, diag::err_redefinition) << Name;
1499  Diag(Def->getLocation(), diag::note_previous_definition);
1500  // FIXME: Would it make sense to try to "forget" the previous
1501  // definition, as part of error recovery?
1502  return true;
1503  }
1504  }
1505  }
1506  } else if (PrevDecl) {
1507  // C++ [temp]p5:
1508  // A class template shall not have the same name as any other
1509  // template, class, function, object, enumeration, enumerator,
1510  // namespace, or type in the same scope (3.3), except as specified
1511  // in (14.5.4).
1512  Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
1513  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
1514  return true;
1515  }
1516 
1517  // Check the template parameter list of this declaration, possibly
1518  // merging in the template parameter list from the previous class
1519  // template declaration. Skip this check for a friend in a dependent
1520  // context, because the template parameter list might be dependent.
1521  if (!(TUK == TUK_Friend && CurContext->isDependentContext()) &&
1522  CheckTemplateParameterList(
1523  TemplateParams,
1524  PrevClassTemplate
1525  ? PrevClassTemplate->getMostRecentDecl()->getTemplateParameters()
1526  : nullptr,
1527  (SS.isSet() && SemanticContext && SemanticContext->isRecord() &&
1528  SemanticContext->isDependentContext())
1529  ? TPC_ClassTemplateMember
1530  : TUK == TUK_Friend ? TPC_FriendClassTemplate : TPC_ClassTemplate,
1531  SkipBody))
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(*this, 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 && (!SkipBody || !SkipBody->ShouldSkip)) {
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 && (!SkipBody || !SkipBody->ShouldSkip))
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  if (SkipBody && SkipBody->ShouldSkip)
1659  return SkipBody->Previous;
1660 
1661  return NewTemplate;
1662 }
1663 
1664 namespace {
1665 /// Tree transform to "extract" a transformed type from a class template's
1666 /// constructor to a deduction guide.
1667 class ExtractTypeForDeductionGuide
1668  : public TreeTransform<ExtractTypeForDeductionGuide> {
1669 public:
1671  ExtractTypeForDeductionGuide(Sema &SemaRef) : Base(SemaRef) {}
1672 
1673  TypeSourceInfo *transform(TypeSourceInfo *TSI) { return TransformType(TSI); }
1674 
1675  QualType TransformTypedefType(TypeLocBuilder &TLB, TypedefTypeLoc TL) {
1676  return TransformType(
1677  TLB,
1679  }
1680 };
1681 
1682 /// Transform to convert portions of a constructor declaration into the
1683 /// corresponding deduction guide, per C++1z [over.match.class.deduct]p1.
1684 struct ConvertConstructorToDeductionGuideTransform {
1685  ConvertConstructorToDeductionGuideTransform(Sema &S,
1686  ClassTemplateDecl *Template)
1687  : SemaRef(S), Template(Template) {}
1688 
1689  Sema &SemaRef;
1690  ClassTemplateDecl *Template;
1691 
1692  DeclContext *DC = Template->getDeclContext();
1693  CXXRecordDecl *Primary = Template->getTemplatedDecl();
1694  DeclarationName DeductionGuideName =
1696 
1697  QualType DeducedType = SemaRef.Context.getTypeDeclType(Primary);
1698 
1699  // Index adjustment to apply to convert depth-1 template parameters into
1700  // depth-0 template parameters.
1701  unsigned Depth1IndexAdjustment = Template->getTemplateParameters()->size();
1702 
1703  /// Transform a constructor declaration into a deduction guide.
1704  NamedDecl *transformConstructor(FunctionTemplateDecl *FTD,
1705  CXXConstructorDecl *CD) {
1707 
1708  LocalInstantiationScope Scope(SemaRef);
1709 
1710  // C++ [over.match.class.deduct]p1:
1711  // -- For each constructor of the class template designated by the
1712  // template-name, a function template with the following properties:
1713 
1714  // -- The template parameters are the template parameters of the class
1715  // template followed by the template parameters (including default
1716  // template arguments) of the constructor, if any.
1717  TemplateParameterList *TemplateParams = Template->getTemplateParameters();
1718  if (FTD) {
1719  TemplateParameterList *InnerParams = FTD->getTemplateParameters();
1720  SmallVector<NamedDecl *, 16> AllParams;
1721  AllParams.reserve(TemplateParams->size() + InnerParams->size());
1722  AllParams.insert(AllParams.begin(),
1723  TemplateParams->begin(), TemplateParams->end());
1724  SubstArgs.reserve(InnerParams->size());
1725 
1726  // Later template parameters could refer to earlier ones, so build up
1727  // a list of substituted template arguments as we go.
1728  for (NamedDecl *Param : *InnerParams) {
1730  Args.addOuterTemplateArguments(SubstArgs);
1731  Args.addOuterRetainedLevel();
1732  NamedDecl *NewParam = transformTemplateParameter(Param, Args);
1733  if (!NewParam)
1734  return nullptr;
1735  AllParams.push_back(NewParam);
1736  SubstArgs.push_back(SemaRef.Context.getCanonicalTemplateArgument(
1737  SemaRef.Context.getInjectedTemplateArg(NewParam)));
1738  }
1739  TemplateParams = TemplateParameterList::Create(
1740  SemaRef.Context, InnerParams->getTemplateLoc(),
1741  InnerParams->getLAngleLoc(), AllParams, InnerParams->getRAngleLoc(),
1742  /*FIXME: RequiresClause*/ nullptr);
1743  }
1744 
1745  // If we built a new template-parameter-list, track that we need to
1746  // substitute references to the old parameters into references to the
1747  // new ones.
1749  if (FTD) {
1750  Args.addOuterTemplateArguments(SubstArgs);
1751  Args.addOuterRetainedLevel();
1752  }
1753 
1756  assert(FPTL && "no prototype for constructor declaration");
1757 
1758  // Transform the type of the function, adjusting the return type and
1759  // replacing references to the old parameters with references to the
1760  // new ones.
1761  TypeLocBuilder TLB;
1763  QualType NewType = transformFunctionProtoType(TLB, FPTL, Params, Args);
1764  if (NewType.isNull())
1765  return nullptr;
1766  TypeSourceInfo *NewTInfo = TLB.getTypeSourceInfo(SemaRef.Context, NewType);
1767 
1768  return buildDeductionGuide(TemplateParams, CD->isExplicit(), NewTInfo,
1769  CD->getBeginLoc(), CD->getLocation(),
1770  CD->getEndLoc());
1771  }
1772 
1773  /// Build a deduction guide with the specified parameter types.
1774  NamedDecl *buildSimpleDeductionGuide(MutableArrayRef<QualType> ParamTypes) {
1775  SourceLocation Loc = Template->getLocation();
1776 
1777  // Build the requested type.
1779  EPI.HasTrailingReturn = true;
1780  QualType Result = SemaRef.BuildFunctionType(DeducedType, ParamTypes, Loc,
1781  DeductionGuideName, EPI);
1782  TypeSourceInfo *TSI = SemaRef.Context.getTrivialTypeSourceInfo(Result, Loc);
1783 
1784  FunctionProtoTypeLoc FPTL =
1786 
1787  // Build the parameters, needed during deduction / substitution.
1789  for (auto T : ParamTypes) {
1790  ParmVarDecl *NewParam = ParmVarDecl::Create(
1791  SemaRef.Context, DC, Loc, Loc, nullptr, T,
1792  SemaRef.Context.getTrivialTypeSourceInfo(T, Loc), SC_None, nullptr);
1793  NewParam->setScopeInfo(0, Params.size());
1794  FPTL.setParam(Params.size(), NewParam);
1795  Params.push_back(NewParam);
1796  }
1797 
1798  return buildDeductionGuide(Template->getTemplateParameters(), false, TSI,
1799  Loc, Loc, Loc);
1800  }
1801 
1802 private:
1803  /// Transform a constructor template parameter into a deduction guide template
1804  /// parameter, rebuilding any internal references to earlier parameters and
1805  /// renumbering as we go.
1806  NamedDecl *transformTemplateParameter(NamedDecl *TemplateParam,
1808  if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(TemplateParam)) {
1809  // TemplateTypeParmDecl's index cannot be changed after creation, so
1810  // substitute it directly.
1811  auto *NewTTP = TemplateTypeParmDecl::Create(
1812  SemaRef.Context, DC, TTP->getBeginLoc(), TTP->getLocation(),
1813  /*Depth*/ 0, Depth1IndexAdjustment + TTP->getIndex(),
1814  TTP->getIdentifier(), TTP->wasDeclaredWithTypename(),
1815  TTP->isParameterPack());
1816  if (TTP->hasDefaultArgument()) {
1817  TypeSourceInfo *InstantiatedDefaultArg =
1818  SemaRef.SubstType(TTP->getDefaultArgumentInfo(), Args,
1819  TTP->getDefaultArgumentLoc(), TTP->getDeclName());
1820  if (InstantiatedDefaultArg)
1821  NewTTP->setDefaultArgument(InstantiatedDefaultArg);
1822  }
1823  SemaRef.CurrentInstantiationScope->InstantiatedLocal(TemplateParam,
1824  NewTTP);
1825  return NewTTP;
1826  }
1827 
1828  if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TemplateParam))
1829  return transformTemplateParameterImpl(TTP, Args);
1830 
1831  return transformTemplateParameterImpl(
1832  cast<NonTypeTemplateParmDecl>(TemplateParam), Args);
1833  }
1834  template<typename TemplateParmDecl>
1835  TemplateParmDecl *
1836  transformTemplateParameterImpl(TemplateParmDecl *OldParam,
1838  // Ask the template instantiator to do the heavy lifting for us, then adjust
1839  // the index of the parameter once it's done.
1840  auto *NewParam =
1841  cast_or_null<TemplateParmDecl>(SemaRef.SubstDecl(OldParam, DC, Args));
1842  assert(NewParam->getDepth() == 0 && "unexpected template param depth");
1843  NewParam->setPosition(NewParam->getPosition() + Depth1IndexAdjustment);
1844  return NewParam;
1845  }
1846 
1847  QualType transformFunctionProtoType(TypeLocBuilder &TLB,
1851  SmallVector<QualType, 4> ParamTypes;
1852  const FunctionProtoType *T = TL.getTypePtr();
1853 
1854  // -- The types of the function parameters are those of the constructor.
1855  for (auto *OldParam : TL.getParams()) {
1856  ParmVarDecl *NewParam = transformFunctionTypeParam(OldParam, Args);
1857  if (!NewParam)
1858  return QualType();
1859  ParamTypes.push_back(NewParam->getType());
1860  Params.push_back(NewParam);
1861  }
1862 
1863  // -- The return type is the class template specialization designated by
1864  // the template-name and template arguments corresponding to the
1865  // template parameters obtained from the class template.
1866  //
1867  // We use the injected-class-name type of the primary template instead.
1868  // This has the convenient property that it is different from any type that
1869  // the user can write in a deduction-guide (because they cannot enter the
1870  // context of the template), so implicit deduction guides can never collide
1871  // with explicit ones.
1872  QualType ReturnType = DeducedType;
1873  TLB.pushTypeSpec(ReturnType).setNameLoc(Primary->getLocation());
1874 
1875  // Resolving a wording defect, we also inherit the variadicness of the
1876  // constructor.
1878  EPI.Variadic = T->isVariadic();
1879  EPI.HasTrailingReturn = true;
1880 
1881  QualType Result = SemaRef.BuildFunctionType(
1882  ReturnType, ParamTypes, TL.getBeginLoc(), DeductionGuideName, EPI);
1883  if (Result.isNull())
1884  return QualType();
1885 
1886  FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
1888  NewTL.setLParenLoc(TL.getLParenLoc());
1889  NewTL.setRParenLoc(TL.getRParenLoc());
1891  NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
1892  for (unsigned I = 0, E = NewTL.getNumParams(); I != E; ++I)
1893  NewTL.setParam(I, Params[I]);
1894 
1895  return Result;
1896  }
1897 
1898  ParmVarDecl *
1899  transformFunctionTypeParam(ParmVarDecl *OldParam,
1901  TypeSourceInfo *OldDI = OldParam->getTypeSourceInfo();
1902  TypeSourceInfo *NewDI;
1903  if (auto PackTL = OldDI->getTypeLoc().getAs<PackExpansionTypeLoc>()) {
1904  // Expand out the one and only element in each inner pack.
1905  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, 0);
1906  NewDI =
1907  SemaRef.SubstType(PackTL.getPatternLoc(), Args,
1908  OldParam->getLocation(), OldParam->getDeclName());
1909  if (!NewDI) return nullptr;
1910  NewDI =
1911  SemaRef.CheckPackExpansion(NewDI, PackTL.getEllipsisLoc(),
1912  PackTL.getTypePtr()->getNumExpansions());
1913  } else
1914  NewDI = SemaRef.SubstType(OldDI, Args, OldParam->getLocation(),
1915  OldParam->getDeclName());
1916  if (!NewDI)
1917  return nullptr;
1918 
1919  // Extract the type. This (for instance) replaces references to typedef
1920  // members of the current instantiations with the definitions of those
1921  // typedefs, avoiding triggering instantiation of the deduced type during
1922  // deduction.
1923  NewDI = ExtractTypeForDeductionGuide(SemaRef).transform(NewDI);
1924 
1925  // Resolving a wording defect, we also inherit default arguments from the
1926  // constructor.
1927  ExprResult NewDefArg;
1928  if (OldParam->hasDefaultArg()) {
1929  NewDefArg = SemaRef.SubstExpr(OldParam->getDefaultArg(), Args);
1930  if (NewDefArg.isInvalid())
1931  return nullptr;
1932  }
1933 
1934  ParmVarDecl *NewParam = ParmVarDecl::Create(SemaRef.Context, DC,
1935  OldParam->getInnerLocStart(),
1936  OldParam->getLocation(),
1937  OldParam->getIdentifier(),
1938  NewDI->getType(),
1939  NewDI,
1940  OldParam->getStorageClass(),
1941  NewDefArg.get());
1942  NewParam->setScopeInfo(OldParam->getFunctionScopeDepth(),
1943  OldParam->getFunctionScopeIndex());
1944  SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldParam, NewParam);
1945  return NewParam;
1946  }
1947 
1948  NamedDecl *buildDeductionGuide(TemplateParameterList *TemplateParams,
1949  bool Explicit, TypeSourceInfo *TInfo,
1950  SourceLocation LocStart, SourceLocation Loc,
1951  SourceLocation LocEnd) {
1952  DeclarationNameInfo Name(DeductionGuideName, Loc);
1953  ArrayRef<ParmVarDecl *> Params =
1954  TInfo->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams();
1955 
1956  // Build the implicit deduction guide template.
1957  auto *Guide =
1958  CXXDeductionGuideDecl::Create(SemaRef.Context, DC, LocStart, Explicit,
1959  Name, TInfo->getType(), TInfo, LocEnd);
1960  Guide->setImplicit();
1961  Guide->setParams(Params);
1962 
1963  for (auto *Param : Params)
1964  Param->setDeclContext(Guide);
1965 
1966  auto *GuideTemplate = FunctionTemplateDecl::Create(
1967  SemaRef.Context, DC, Loc, DeductionGuideName, TemplateParams, Guide);
1968  GuideTemplate->setImplicit();
1969  Guide->setDescribedFunctionTemplate(GuideTemplate);
1970 
1971  if (isa<CXXRecordDecl>(DC)) {
1972  Guide->setAccess(AS_public);
1973  GuideTemplate->setAccess(AS_public);
1974  }
1975 
1976  DC->addDecl(GuideTemplate);
1977  return GuideTemplate;
1978  }
1979 };
1980 }
1981 
1983  SourceLocation Loc) {
1984  DeclContext *DC = Template->getDeclContext();
1985  if (DC->isDependentContext())
1986  return;
1987 
1988  ConvertConstructorToDeductionGuideTransform Transform(
1989  *this, cast<ClassTemplateDecl>(Template));
1990  if (!isCompleteType(Loc, Transform.DeducedType))
1991  return;
1992 
1993  // Check whether we've already declared deduction guides for this template.
1994  // FIXME: Consider storing a flag on the template to indicate this.
1995  auto Existing = DC->lookup(Transform.DeductionGuideName);
1996  for (auto *D : Existing)
1997  if (D->isImplicit())
1998  return;
1999 
2000  // In case we were expanding a pack when we attempted to declare deduction
2001  // guides, turn off pack expansion for everything we're about to do.
2002  ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
2003  // Create a template instantiation record to track the "instantiation" of
2004  // constructors into deduction guides.
2005  // FIXME: Add a kind for this to give more meaningful diagnostics. But can
2006  // this substitution process actually fail?
2007  InstantiatingTemplate BuildingDeductionGuides(*this, Loc, Template);
2008  if (BuildingDeductionGuides.isInvalid())
2009  return;
2010 
2011  // Convert declared constructors into deduction guide templates.
2012  // FIXME: Skip constructors for which deduction must necessarily fail (those
2013  // for which some class template parameter without a default argument never
2014  // appears in a deduced context).
2015  bool AddedAny = false;
2016  for (NamedDecl *D : LookupConstructors(Transform.Primary)) {
2017  D = D->getUnderlyingDecl();
2018  if (D->isInvalidDecl() || D->isImplicit())
2019  continue;
2020  D = cast<NamedDecl>(D->getCanonicalDecl());
2021 
2022  auto *FTD = dyn_cast<FunctionTemplateDecl>(D);
2023  auto *CD =
2024  dyn_cast_or_null<CXXConstructorDecl>(FTD ? FTD->getTemplatedDecl() : D);
2025  // Class-scope explicit specializations (MS extension) do not result in
2026  // deduction guides.
2027  if (!CD || (!FTD && CD->isFunctionTemplateSpecialization()))
2028  continue;
2029 
2030  Transform.transformConstructor(FTD, CD);
2031  AddedAny = true;
2032  }
2033 
2034  // C++17 [over.match.class.deduct]
2035  // -- If C is not defined or does not declare any constructors, an
2036  // additional function template derived as above from a hypothetical
2037  // constructor C().
2038  if (!AddedAny)
2039  Transform.buildSimpleDeductionGuide(None);
2040 
2041  // -- An additional function template derived as above from a hypothetical
2042  // constructor C(C), called the copy deduction candidate.
2043  cast<CXXDeductionGuideDecl>(
2044  cast<FunctionTemplateDecl>(
2045  Transform.buildSimpleDeductionGuide(Transform.DeducedType))
2046  ->getTemplatedDecl())
2047  ->setIsCopyDeductionCandidate();
2048 }
2049 
2050 /// Diagnose the presence of a default template argument on a
2051 /// template parameter, which is ill-formed in certain contexts.
2052 ///
2053 /// \returns true if the default template argument should be dropped.
2056  SourceLocation ParamLoc,
2057  SourceRange DefArgRange) {
2058  switch (TPC) {
2060  case Sema::TPC_VarTemplate:
2062  return false;
2063 
2066  // C++ [temp.param]p9:
2067  // A default template-argument shall not be specified in a
2068  // function template declaration or a function template
2069  // definition [...]
2070  // If a friend function template declaration specifies a default
2071  // template-argument, that declaration shall be a definition and shall be
2072  // the only declaration of the function template in the translation unit.
2073  // (C++98/03 doesn't have this wording; see DR226).
2074  S.Diag(ParamLoc, S.getLangOpts().CPlusPlus11 ?
2075  diag::warn_cxx98_compat_template_parameter_default_in_function_template
2076  : diag::ext_template_parameter_default_in_function_template)
2077  << DefArgRange;
2078  return false;
2079 
2081  // C++0x [temp.param]p9:
2082  // A default template-argument shall not be specified in the
2083  // template-parameter-lists of the definition of a member of a
2084  // class template that appears outside of the member's class.
2085  S.Diag(ParamLoc, diag::err_template_parameter_default_template_member)
2086  << DefArgRange;
2087  return true;
2088 
2091  // C++ [temp.param]p9:
2092  // A default template-argument shall not be specified in a
2093  // friend template declaration.
2094  S.Diag(ParamLoc, diag::err_template_parameter_default_friend_template)
2095  << DefArgRange;
2096  return true;
2097 
2098  // FIXME: C++0x [temp.param]p9 allows default template-arguments
2099  // for friend function templates if there is only a single
2100  // declaration (and it is a definition). Strange!
2101  }
2102 
2103  llvm_unreachable("Invalid TemplateParamListContext!");
2104 }
2105 
2106 /// Check for unexpanded parameter packs within the template parameters
2107 /// of a template template parameter, recursively.
2109  TemplateTemplateParmDecl *TTP) {
2110  // A template template parameter which is a parameter pack is also a pack
2111  // expansion.
2112  if (TTP->isParameterPack())
2113  return false;
2114 
2116  for (unsigned I = 0, N = Params->size(); I != N; ++I) {
2117  NamedDecl *P = Params->getParam(I);
2118  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
2119  if (!NTTP->isParameterPack() &&
2120  S.DiagnoseUnexpandedParameterPack(NTTP->getLocation(),
2121  NTTP->getTypeSourceInfo(),
2123  return true;
2124 
2125  continue;
2126  }
2127 
2128  if (TemplateTemplateParmDecl *InnerTTP
2129  = dyn_cast<TemplateTemplateParmDecl>(P))
2130  if (DiagnoseUnexpandedParameterPacks(S, InnerTTP))
2131  return true;
2132  }
2133 
2134  return false;
2135 }
2136 
2137 /// Checks the validity of a template parameter list, possibly
2138 /// considering the template parameter list from a previous
2139 /// declaration.
2140 ///
2141 /// If an "old" template parameter list is provided, it must be
2142 /// equivalent (per TemplateParameterListsAreEqual) to the "new"
2143 /// template parameter list.
2144 ///
2145 /// \param NewParams Template parameter list for a new template
2146 /// declaration. This template parameter list will be updated with any
2147 /// default arguments that are carried through from the previous
2148 /// template parameter list.
2149 ///
2150 /// \param OldParams If provided, template parameter list from a
2151 /// previous declaration of the same template. Default template
2152 /// arguments will be merged from the old template parameter list to
2153 /// the new template parameter list.
2154 ///
2155 /// \param TPC Describes the context in which we are checking the given
2156 /// template parameter list.
2157 ///
2158 /// \param SkipBody If we might have already made a prior merged definition
2159 /// of this template visible, the corresponding body-skipping information.
2160 /// Default argument redefinition is not an error when skipping such a body,
2161 /// because (under the ODR) we can assume the default arguments are the same
2162 /// as the prior merged definition.
2163 ///
2164 /// \returns true if an error occurred, false otherwise.
2166  TemplateParameterList *OldParams,
2168  SkipBodyInfo *SkipBody) {
2169  bool Invalid = false;
2170 
2171  // C++ [temp.param]p10:
2172  // The set of default template-arguments available for use with a
2173  // template declaration or definition is obtained by merging the
2174  // default arguments from the definition (if in scope) and all
2175  // declarations in scope in the same way default function
2176  // arguments are (8.3.6).
2177  bool SawDefaultArgument = false;
2178  SourceLocation PreviousDefaultArgLoc;
2179 
2180  // Dummy initialization to avoid warnings.
2181  TemplateParameterList::iterator OldParam = NewParams->end();
2182  if (OldParams)
2183  OldParam = OldParams->begin();
2184 
2185  bool RemoveDefaultArguments = false;
2186  for (TemplateParameterList::iterator NewParam = NewParams->begin(),
2187  NewParamEnd = NewParams->end();
2188  NewParam != NewParamEnd; ++NewParam) {
2189  // Variables used to diagnose redundant default arguments
2190  bool RedundantDefaultArg = false;
2191  SourceLocation OldDefaultLoc;
2192  SourceLocation NewDefaultLoc;
2193 
2194  // Variable used to diagnose missing default arguments
2195  bool MissingDefaultArg = false;
2196 
2197  // Variable used to diagnose non-final parameter packs
2198  bool SawParameterPack = false;
2199 
2200  if (TemplateTypeParmDecl *NewTypeParm
2201  = dyn_cast<TemplateTypeParmDecl>(*NewParam)) {
2202  // Check the presence of a default argument here.
2203  if (NewTypeParm->hasDefaultArgument() &&
2205  NewTypeParm->getLocation(),
2206  NewTypeParm->getDefaultArgumentInfo()->getTypeLoc()
2207  .getSourceRange()))
2208  NewTypeParm->removeDefaultArgument();
2209 
2210  // Merge default arguments for template type parameters.
2211  TemplateTypeParmDecl *OldTypeParm
2212  = OldParams? cast<TemplateTypeParmDecl>(*OldParam) : nullptr;
2213  if (NewTypeParm->isParameterPack()) {
2214  assert(!NewTypeParm->hasDefaultArgument() &&
2215  "Parameter packs can't have a default argument!");
2216  SawParameterPack = true;
2217  } else if (OldTypeParm && hasVisibleDefaultArgument(OldTypeParm) &&
2218  NewTypeParm->hasDefaultArgument() &&
2219  (!SkipBody || !SkipBody->ShouldSkip)) {
2220  OldDefaultLoc = OldTypeParm->getDefaultArgumentLoc();
2221  NewDefaultLoc = NewTypeParm->getDefaultArgumentLoc();
2222  SawDefaultArgument = true;
2223  RedundantDefaultArg = true;
2224  PreviousDefaultArgLoc = NewDefaultLoc;
2225  } else if (OldTypeParm && OldTypeParm->hasDefaultArgument()) {
2226  // Merge the default argument from the old declaration to the
2227  // new declaration.
2228  NewTypeParm->setInheritedDefaultArgument(Context, OldTypeParm);
2229  PreviousDefaultArgLoc = OldTypeParm->getDefaultArgumentLoc();
2230  } else if (NewTypeParm->hasDefaultArgument()) {
2231  SawDefaultArgument = true;
2232  PreviousDefaultArgLoc = NewTypeParm->getDefaultArgumentLoc();
2233  } else if (SawDefaultArgument)
2234  MissingDefaultArg = true;
2235  } else if (NonTypeTemplateParmDecl *NewNonTypeParm
2236  = dyn_cast<NonTypeTemplateParmDecl>(*NewParam)) {
2237  // Check for unexpanded parameter packs.
2238  if (!NewNonTypeParm->isParameterPack() &&
2239  DiagnoseUnexpandedParameterPack(NewNonTypeParm->getLocation(),
2240  NewNonTypeParm->getTypeSourceInfo(),
2241  UPPC_NonTypeTemplateParameterType)) {
2242  Invalid = true;
2243  continue;
2244  }
2245 
2246  // Check the presence of a default argument here.
2247  if (NewNonTypeParm->hasDefaultArgument() &&
2249  NewNonTypeParm->getLocation(),
2250  NewNonTypeParm->getDefaultArgument()->getSourceRange())) {
2251  NewNonTypeParm->removeDefaultArgument();
2252  }
2253 
2254  // Merge default arguments for non-type template parameters
2255  NonTypeTemplateParmDecl *OldNonTypeParm
2256  = OldParams? cast<NonTypeTemplateParmDecl>(*OldParam) : nullptr;
2257  if (NewNonTypeParm->isParameterPack()) {
2258  assert(!NewNonTypeParm->hasDefaultArgument() &&
2259  "Parameter packs can't have a default argument!");
2260  if (!NewNonTypeParm->isPackExpansion())
2261  SawParameterPack = true;
2262  } else if (OldNonTypeParm && hasVisibleDefaultArgument(OldNonTypeParm) &&
2263  NewNonTypeParm->hasDefaultArgument() &&
2264  (!SkipBody || !SkipBody->ShouldSkip)) {
2265  OldDefaultLoc = OldNonTypeParm->getDefaultArgumentLoc();
2266  NewDefaultLoc = NewNonTypeParm->getDefaultArgumentLoc();
2267  SawDefaultArgument = true;
2268  RedundantDefaultArg = true;
2269  PreviousDefaultArgLoc = NewDefaultLoc;
2270  } else if (OldNonTypeParm && OldNonTypeParm->hasDefaultArgument()) {
2271  // Merge the default argument from the old declaration to the
2272  // new declaration.
2273  NewNonTypeParm->setInheritedDefaultArgument(Context, OldNonTypeParm);
2274  PreviousDefaultArgLoc = OldNonTypeParm->getDefaultArgumentLoc();
2275  } else if (NewNonTypeParm->hasDefaultArgument()) {
2276  SawDefaultArgument = true;
2277  PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
2278  } else if (SawDefaultArgument)
2279  MissingDefaultArg = true;
2280  } else {
2281  TemplateTemplateParmDecl *NewTemplateParm
2282  = cast<TemplateTemplateParmDecl>(*NewParam);
2283 
2284  // Check for unexpanded parameter packs, recursively.
2285  if (::DiagnoseUnexpandedParameterPacks(*this, NewTemplateParm)) {
2286  Invalid = true;
2287  continue;
2288  }
2289 
2290  // Check the presence of a default argument here.
2291  if (NewTemplateParm->hasDefaultArgument() &&
2293  NewTemplateParm->getLocation(),
2294  NewTemplateParm->getDefaultArgument().getSourceRange()))
2295  NewTemplateParm->removeDefaultArgument();
2296 
2297  // Merge default arguments for template template parameters
2298  TemplateTemplateParmDecl *OldTemplateParm
2299  = OldParams? cast<TemplateTemplateParmDecl>(*OldParam) : nullptr;
2300  if (NewTemplateParm->isParameterPack()) {
2301  assert(!NewTemplateParm->hasDefaultArgument() &&
2302  "Parameter packs can't have a default argument!");
2303  if (!NewTemplateParm->isPackExpansion())
2304  SawParameterPack = true;
2305  } else if (OldTemplateParm &&
2306  hasVisibleDefaultArgument(OldTemplateParm) &&
2307  NewTemplateParm->hasDefaultArgument() &&
2308  (!SkipBody || !SkipBody->ShouldSkip)) {
2309  OldDefaultLoc = OldTemplateParm->getDefaultArgument().getLocation();
2310  NewDefaultLoc = NewTemplateParm->getDefaultArgument().getLocation();
2311  SawDefaultArgument = true;
2312  RedundantDefaultArg = true;
2313  PreviousDefaultArgLoc = NewDefaultLoc;
2314  } else if (OldTemplateParm && OldTemplateParm->hasDefaultArgument()) {
2315  // Merge the default argument from the old declaration to the
2316  // new declaration.
2317  NewTemplateParm->setInheritedDefaultArgument(Context, OldTemplateParm);
2318  PreviousDefaultArgLoc
2319  = OldTemplateParm->getDefaultArgument().getLocation();
2320  } else if (NewTemplateParm->hasDefaultArgument()) {
2321  SawDefaultArgument = true;
2322  PreviousDefaultArgLoc
2323  = NewTemplateParm->getDefaultArgument().getLocation();
2324  } else if (SawDefaultArgument)
2325  MissingDefaultArg = true;
2326  }
2327 
2328  // C++11 [temp.param]p11:
2329  // If a template parameter of a primary class template or alias template
2330  // is a template parameter pack, it shall be the last template parameter.
2331  if (SawParameterPack && (NewParam + 1) != NewParamEnd &&
2332  (TPC == TPC_ClassTemplate || TPC == TPC_VarTemplate ||
2333  TPC == TPC_TypeAliasTemplate)) {
2334  Diag((*NewParam)->getLocation(),
2335  diag::err_template_param_pack_must_be_last_template_parameter);
2336  Invalid = true;
2337  }
2338 
2339  if (RedundantDefaultArg) {
2340  // C++ [temp.param]p12:
2341  // A template-parameter shall not be given default arguments
2342  // by two different declarations in the same scope.
2343  Diag(NewDefaultLoc, diag::err_template_param_default_arg_redefinition);
2344  Diag(OldDefaultLoc, diag::note_template_param_prev_default_arg);
2345  Invalid = true;
2346  } else if (MissingDefaultArg && TPC != TPC_FunctionTemplate) {
2347  // C++ [temp.param]p11:
2348  // If a template-parameter of a class template has a default
2349  // template-argument, each subsequent template-parameter shall either
2350  // have a default template-argument supplied or be a template parameter
2351  // pack.
2352  Diag((*NewParam)->getLocation(),
2353  diag::err_template_param_default_arg_missing);
2354  Diag(PreviousDefaultArgLoc, diag::note_template_param_prev_default_arg);
2355  Invalid = true;
2356  RemoveDefaultArguments = true;
2357  }
2358 
2359  // If we have an old template parameter list that we're merging
2360  // in, move on to the next parameter.
2361  if (OldParams)
2362  ++OldParam;
2363  }
2364 
2365  // We were missing some default arguments at the end of the list, so remove
2366  // all of the default arguments.
2367  if (RemoveDefaultArguments) {
2368  for (TemplateParameterList::iterator NewParam = NewParams->begin(),
2369  NewParamEnd = NewParams->end();
2370  NewParam != NewParamEnd; ++NewParam) {
2371  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*NewParam))
2372  TTP->removeDefaultArgument();
2373  else if (NonTypeTemplateParmDecl *NTTP
2374  = dyn_cast<NonTypeTemplateParmDecl>(*NewParam))
2375  NTTP->removeDefaultArgument();
2376  else
2377  cast<TemplateTemplateParmDecl>(*NewParam)->removeDefaultArgument();
2378  }
2379  }
2380 
2381  return Invalid;
2382 }
2383 
2384 namespace {
2385 
2386 /// A class which looks for a use of a certain level of template
2387 /// parameter.
2388 struct DependencyChecker : RecursiveASTVisitor<DependencyChecker> {
2390 
2391  unsigned Depth;
2392 
2393  // Whether we're looking for a use of a template parameter that makes the
2394  // overall construct type-dependent / a dependent type. This is strictly
2395  // best-effort for now; we may fail to match at all for a dependent type
2396  // in some cases if this is set.
2397  bool IgnoreNonTypeDependent;
2398 
2399  bool Match;
2400  SourceLocation MatchLoc;
2401 
2402  DependencyChecker(unsigned Depth, bool IgnoreNonTypeDependent)
2403  : Depth(Depth), IgnoreNonTypeDependent(IgnoreNonTypeDependent),
2404  Match(false) {}
2405 
2406  DependencyChecker(TemplateParameterList *Params, bool IgnoreNonTypeDependent)
2407  : IgnoreNonTypeDependent(IgnoreNonTypeDependent), Match(false) {
2408  NamedDecl *ND = Params->getParam(0);
2409  if (TemplateTypeParmDecl *PD = dyn_cast<TemplateTypeParmDecl>(ND)) {
2410  Depth = PD->getDepth();
2411  } else if (NonTypeTemplateParmDecl *PD =
2412  dyn_cast<NonTypeTemplateParmDecl>(ND)) {
2413  Depth = PD->getDepth();
2414  } else {
2415  Depth = cast<TemplateTemplateParmDecl>(ND)->getDepth();
2416  }
2417  }
2418 
2419  bool Matches(unsigned ParmDepth, SourceLocation Loc = SourceLocation()) {
2420  if (ParmDepth >= Depth) {
2421  Match = true;
2422  MatchLoc = Loc;
2423  return true;
2424  }
2425  return false;
2426  }
2427 
2428  bool TraverseStmt(Stmt *S, DataRecursionQueue *Q = nullptr) {
2429  // Prune out non-type-dependent expressions if requested. This can
2430  // sometimes result in us failing to find a template parameter reference
2431  // (if a value-dependent expression creates a dependent type), but this
2432  // mode is best-effort only.
2433  if (auto *E = dyn_cast_or_null<Expr>(S))
2434  if (IgnoreNonTypeDependent && !E->isTypeDependent())
2435  return true;
2436  return super::TraverseStmt(S, Q);
2437  }
2438 
2439  bool TraverseTypeLoc(TypeLoc TL) {
2440  if (IgnoreNonTypeDependent && !TL.isNull() &&
2441  !TL.getType()->isDependentType())
2442  return true;
2443  return super::TraverseTypeLoc(TL);
2444  }
2445 
2446  bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
2447  return !Matches(TL.getTypePtr()->getDepth(), TL.getNameLoc());
2448  }
2449 
2450  bool VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
2451  // For a best-effort search, keep looking until we find a location.
2452  return IgnoreNonTypeDependent || !Matches(T->getDepth());
2453  }
2454 
2455  bool TraverseTemplateName(TemplateName N) {
2456  if (TemplateTemplateParmDecl *PD =
2457  dyn_cast_or_null<TemplateTemplateParmDecl>(N.getAsTemplateDecl()))
2458  if (Matches(PD->getDepth()))
2459  return false;
2460  return super::TraverseTemplateName(N);
2461  }
2462 
2463  bool VisitDeclRefExpr(DeclRefExpr *E) {
2464  if (NonTypeTemplateParmDecl *PD =
2465  dyn_cast<NonTypeTemplateParmDecl>(E->getDecl()))
2466  if (Matches(PD->getDepth(), E->getExprLoc()))
2467  return false;
2468  return super::VisitDeclRefExpr(E);
2469  }
2470 
2471  bool VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
2472  return TraverseType(T->getReplacementType());
2473  }
2474 
2475  bool
2476  VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
2477  return TraverseTemplateArgument(T->getArgumentPack());
2478  }
2479 
2480  bool TraverseInjectedClassNameType(const InjectedClassNameType *T) {
2481  return TraverseType(T->getInjectedSpecializationType());
2482  }
2483 };
2484 } // end anonymous namespace
2485 
2486 /// Determines whether a given type depends on the given parameter
2487 /// list.
2488 static bool
2490  DependencyChecker Checker(Params, /*IgnoreNonTypeDependent*/false);
2491  Checker.TraverseType(T);
2492  return Checker.Match;
2493 }
2494 
2495 // Find the source range corresponding to the named type in the given
2496 // nested-name-specifier, if any.
2498  QualType T,
2499  const CXXScopeSpec &SS) {
2501  while (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier()) {
2502  if (const Type *CurType = NNS->getAsType()) {
2503  if (Context.hasSameUnqualifiedType(T, QualType(CurType, 0)))
2504  return NNSLoc.getTypeLoc().getSourceRange();
2505  } else
2506  break;
2507 
2508  NNSLoc = NNSLoc.getPrefix();
2509  }
2510 
2511  return SourceRange();
2512 }
2513 
2514 /// Match the given template parameter lists to the given scope
2515 /// specifier, returning the template parameter list that applies to the
2516 /// name.
2517 ///
2518 /// \param DeclStartLoc the start of the declaration that has a scope
2519 /// specifier or a template parameter list.
2520 ///
2521 /// \param DeclLoc The location of the declaration itself.
2522 ///
2523 /// \param SS the scope specifier that will be matched to the given template
2524 /// parameter lists. This scope specifier precedes a qualified name that is
2525 /// being declared.
2526 ///
2527 /// \param TemplateId The template-id following the scope specifier, if there
2528 /// is one. Used to check for a missing 'template<>'.
2529 ///
2530 /// \param ParamLists the template parameter lists, from the outermost to the
2531 /// innermost template parameter lists.
2532 ///
2533 /// \param IsFriend Whether to apply the slightly different rules for
2534 /// matching template parameters to scope specifiers in friend
2535 /// declarations.
2536 ///
2537 /// \param IsMemberSpecialization will be set true if the scope specifier
2538 /// denotes a fully-specialized type, and therefore this is a declaration of
2539 /// a member specialization.
2540 ///
2541 /// \returns the template parameter list, if any, that corresponds to the
2542 /// name that is preceded by the scope specifier @p SS. This template
2543 /// parameter list may have template parameters (if we're declaring a
2544 /// template) or may have no template parameters (if we're declaring a
2545 /// template specialization), or may be NULL (if what we're declaring isn't
2546 /// itself a template).
2548  SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS,
2549  TemplateIdAnnotation *TemplateId,
2550  ArrayRef<TemplateParameterList *> ParamLists, bool IsFriend,
2551  bool &IsMemberSpecialization, bool &Invalid) {
2552  IsMemberSpecialization = false;
2553  Invalid = false;
2554 
2555  // The sequence of nested types to which we will match up the template
2556  // parameter lists. We first build this list by starting with the type named
2557  // by the nested-name-specifier and walking out until we run out of types.
2558  SmallVector<QualType, 4> NestedTypes;
2559  QualType T;
2560  if (SS.getScopeRep()) {
2561  if (CXXRecordDecl *Record
2562  = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, true)))
2563  T = Context.getTypeDeclType(Record);
2564  else
2565  T = QualType(SS.getScopeRep()->getAsType(), 0);
2566  }
2567 
2568  // If we found an explicit specialization that prevents us from needing
2569  // 'template<>' headers, this will be set to the location of that
2570  // explicit specialization.
2571  SourceLocation ExplicitSpecLoc;
2572 
2573  while (!T.isNull()) {
2574  NestedTypes.push_back(T);
2575 
2576  // Retrieve the parent of a record type.
2577  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
2578  // If this type is an explicit specialization, we're done.
2580  = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
2581  if (!isa<ClassTemplatePartialSpecializationDecl>(Spec) &&
2582  Spec->getSpecializationKind() == TSK_ExplicitSpecialization) {
2583  ExplicitSpecLoc = Spec->getLocation();
2584  break;
2585  }
2586  } else if (Record->getTemplateSpecializationKind()
2588  ExplicitSpecLoc = Record->getLocation();
2589  break;
2590  }
2591 
2592  if (TypeDecl *Parent = dyn_cast<TypeDecl>(Record->getParent()))
2593  T = Context.getTypeDeclType(Parent);
2594  else
2595  T = QualType();
2596  continue;
2597  }
2598 
2599  if (const TemplateSpecializationType *TST
2601  if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2602  if (TypeDecl *Parent = dyn_cast<TypeDecl>(Template->getDeclContext()))
2603  T = Context.getTypeDeclType(Parent);
2604  else
2605  T = QualType();
2606  continue;
2607  }
2608  }
2609 
2610  // Look one step prior in a dependent template specialization type.
2611  if (const DependentTemplateSpecializationType *DependentTST
2613  if (NestedNameSpecifier *NNS = DependentTST->getQualifier())
2614  T = QualType(NNS->getAsType(), 0);
2615  else
2616  T = QualType();
2617  continue;
2618  }
2619 
2620  // Look one step prior in a dependent name type.
2621  if (const DependentNameType *DependentName = T->getAs<DependentNameType>()){
2622  if (NestedNameSpecifier *NNS = DependentName->getQualifier())
2623  T = QualType(NNS->getAsType(), 0);
2624  else
2625  T = QualType();
2626  continue;
2627  }
2628 
2629  // Retrieve the parent of an enumeration type.
2630  if (const EnumType *EnumT = T->getAs<EnumType>()) {
2631  // FIXME: Forward-declared enums require a TSK_ExplicitSpecialization
2632  // check here.
2633  EnumDecl *Enum = EnumT->getDecl();
2634 
2635  // Get to the parent type.
2636  if (TypeDecl *Parent = dyn_cast<TypeDecl>(Enum->getParent()))
2637  T = Context.getTypeDeclType(Parent);
2638  else
2639  T = QualType();
2640  continue;
2641  }
2642 
2643  T = QualType();
2644  }
2645  // Reverse the nested types list, since we want to traverse from the outermost
2646  // to the innermost while checking template-parameter-lists.
2647  std::reverse(NestedTypes.begin(), NestedTypes.end());
2648 
2649  // C++0x [temp.expl.spec]p17:
2650  // A member or a member template may be nested within many
2651  // enclosing class templates. In an explicit specialization for
2652  // such a member, the member declaration shall be preceded by a
2653  // template<> for each enclosing class template that is
2654  // explicitly specialized.
2655  bool SawNonEmptyTemplateParameterList = false;
2656 
2657  auto CheckExplicitSpecialization = [&](SourceRange Range, bool Recovery) {
2658  if (SawNonEmptyTemplateParameterList) {
2659  Diag(DeclLoc, diag::err_specialize_member_of_template)
2660  << !Recovery << Range;
2661  Invalid = true;
2662  IsMemberSpecialization = false;
2663  return true;
2664  }
2665 
2666  return false;
2667  };
2668 
2669  auto DiagnoseMissingExplicitSpecialization = [&] (SourceRange Range) {
2670  // Check that we can have an explicit specialization here.
2671  if (CheckExplicitSpecialization(Range, true))
2672  return true;
2673 
2674  // We don't have a template header, but we should.
2675  SourceLocation ExpectedTemplateLoc;
2676  if (!ParamLists.empty())
2677  ExpectedTemplateLoc = ParamLists[0]->getTemplateLoc();
2678  else
2679  ExpectedTemplateLoc = DeclStartLoc;
2680 
2681  Diag(DeclLoc, diag::err_template_spec_needs_header)
2682  << Range
2683  << FixItHint::CreateInsertion(ExpectedTemplateLoc, "template<> ");
2684  return false;
2685  };
2686 
2687  unsigned ParamIdx = 0;
2688  for (unsigned TypeIdx = 0, NumTypes = NestedTypes.size(); TypeIdx != NumTypes;
2689  ++TypeIdx) {
2690  T = NestedTypes[TypeIdx];
2691 
2692  // Whether we expect a 'template<>' header.
2693  bool NeedEmptyTemplateHeader = false;
2694 
2695  // Whether we expect a template header with parameters.
2696  bool NeedNonemptyTemplateHeader = false;
2697 
2698  // For a dependent type, the set of template parameters that we
2699  // expect to see.
2700  TemplateParameterList *ExpectedTemplateParams = nullptr;
2701 
2702  // C++0x [temp.expl.spec]p15:
2703  // A member or a member template may be nested within many enclosing
2704  // class templates. In an explicit specialization for such a member, the
2705  // member declaration shall be preceded by a template<> for each
2706  // enclosing class template that is explicitly specialized.
2707  if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) {
2709  = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record)) {
2710  ExpectedTemplateParams = Partial->getTemplateParameters();
2711  NeedNonemptyTemplateHeader = true;
2712  } else if (Record->isDependentType()) {
2713  if (Record->getDescribedClassTemplate()) {
2714  ExpectedTemplateParams = Record->getDescribedClassTemplate()
2715  ->getTemplateParameters();
2716  NeedNonemptyTemplateHeader = true;
2717  }
2718  } else if (ClassTemplateSpecializationDecl *Spec
2719  = dyn_cast<ClassTemplateSpecializationDecl>(Record)) {
2720  // C++0x [temp.expl.spec]p4:
2721  // Members of an explicitly specialized class template are defined
2722  // in the same manner as members of normal classes, and not using
2723  // the template<> syntax.
2724  if (Spec->getSpecializationKind() != TSK_ExplicitSpecialization)
2725  NeedEmptyTemplateHeader = true;
2726  else
2727  continue;
2728  } else if (Record->getTemplateSpecializationKind()) {
2729  if (Record->getTemplateSpecializationKind()
2731  TypeIdx == NumTypes - 1)
2732  IsMemberSpecialization = true;
2733 
2734  continue;
2735  }
2736  } else if (const TemplateSpecializationType *TST
2738  if (TemplateDecl *Template = TST->getTemplateName().getAsTemplateDecl()) {
2739  ExpectedTemplateParams = Template->getTemplateParameters();
2740  NeedNonemptyTemplateHeader = true;
2741  }
2742  } else if (T->getAs<DependentTemplateSpecializationType>()) {
2743  // FIXME: We actually could/should check the template arguments here
2744  // against the corresponding template parameter list.
2745  NeedNonemptyTemplateHeader = false;
2746  }
2747 
2748  // C++ [temp.expl.spec]p16:
2749  // In an explicit specialization declaration for a member of a class
2750  // template or a member template that ap- pears in namespace scope, the
2751  // member template and some of its enclosing class templates may remain
2752  // unspecialized, except that the declaration shall not explicitly
2753  // specialize a class member template if its en- closing class templates
2754  // are not explicitly specialized as well.
2755  if (ParamIdx < ParamLists.size()) {
2756  if (ParamLists[ParamIdx]->size() == 0) {
2757  if (CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
2758  false))
2759  return nullptr;
2760  } else
2761  SawNonEmptyTemplateParameterList = true;
2762  }
2763 
2764  if (NeedEmptyTemplateHeader) {
2765  // If we're on the last of the types, and we need a 'template<>' header
2766  // here, then it's a member specialization.
2767  if (TypeIdx == NumTypes - 1)
2768  IsMemberSpecialization = true;
2769 
2770  if (ParamIdx < ParamLists.size()) {
2771  if (ParamLists[ParamIdx]->size() > 0) {
2772  // The header has template parameters when it shouldn't. Complain.
2773  Diag(ParamLists[ParamIdx]->getTemplateLoc(),
2774  diag::err_template_param_list_matches_nontemplate)
2775  << T
2776  << SourceRange(ParamLists[ParamIdx]->getLAngleLoc(),
2777  ParamLists[ParamIdx]->getRAngleLoc())
2778  << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
2779  Invalid = true;
2780  return nullptr;
2781  }
2782 
2783  // Consume this template header.
2784  ++ParamIdx;
2785  continue;
2786  }
2787 
2788  if (!IsFriend)
2789  if (DiagnoseMissingExplicitSpecialization(
2790  getRangeOfTypeInNestedNameSpecifier(Context, T, SS)))
2791  return nullptr;
2792 
2793  continue;
2794  }
2795 
2796  if (NeedNonemptyTemplateHeader) {
2797  // In friend declarations we can have template-ids which don't
2798  // depend on the corresponding template parameter lists. But
2799  // assume that empty parameter lists are supposed to match this
2800  // template-id.
2801  if (IsFriend && T->isDependentType()) {
2802  if (ParamIdx < ParamLists.size() &&
2803  DependsOnTemplateParameters(T, ParamLists[ParamIdx]))
2804  ExpectedTemplateParams = nullptr;
2805  else
2806  continue;
2807  }
2808 
2809  if (ParamIdx < ParamLists.size()) {
2810  // Check the template parameter list, if we can.
2811  if (ExpectedTemplateParams &&
2812  !TemplateParameterListsAreEqual(ParamLists[ParamIdx],
2813  ExpectedTemplateParams,
2814  true, TPL_TemplateMatch))
2815  Invalid = true;
2816 
2817  if (!Invalid &&
2818  CheckTemplateParameterList(ParamLists[ParamIdx], nullptr,
2819  TPC_ClassTemplateMember))
2820  Invalid = true;
2821 
2822  ++ParamIdx;
2823  continue;
2824  }
2825 
2826  Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
2827  << T
2828  << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
2829  Invalid = true;
2830  continue;
2831  }
2832  }
2833 
2834  // If there were at least as many template-ids as there were template
2835  // parameter lists, then there are no template parameter lists remaining for
2836  // the declaration itself.
2837  if (ParamIdx >= ParamLists.size()) {
2838  if (TemplateId && !IsFriend) {
2839  // We don't have a template header for the declaration itself, but we
2840  // should.
2841  DiagnoseMissingExplicitSpecialization(SourceRange(TemplateId->LAngleLoc,
2842  TemplateId->RAngleLoc));
2843 
2844  // Fabricate an empty template parameter list for the invented header.
2846  SourceLocation(), None,
2847  SourceLocation(), nullptr);
2848  }
2849 
2850  return nullptr;
2851  }
2852 
2853  // If there were too many template parameter lists, complain about that now.
2854  if (ParamIdx < ParamLists.size() - 1) {
2855  bool HasAnyExplicitSpecHeader = false;
2856  bool AllExplicitSpecHeaders = true;
2857  for (unsigned I = ParamIdx, E = ParamLists.size() - 1; I != E; ++I) {
2858  if (ParamLists[I]->size() == 0)
2859  HasAnyExplicitSpecHeader = true;
2860  else
2861  AllExplicitSpecHeaders = false;
2862  }
2863 
2864  Diag(ParamLists[ParamIdx]->getTemplateLoc(),
2865  AllExplicitSpecHeaders ? diag::warn_template_spec_extra_headers
2866  : diag::err_template_spec_extra_headers)
2867  << SourceRange(ParamLists[ParamIdx]->getTemplateLoc(),
2868  ParamLists[ParamLists.size() - 2]->getRAngleLoc());
2869 
2870  // If there was a specialization somewhere, such that 'template<>' is
2871  // not required, and there were any 'template<>' headers, note where the
2872  // specialization occurred.
2873  if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader)
2874  Diag(ExplicitSpecLoc,
2875  diag::note_explicit_template_spec_does_not_need_header)
2876  << NestedTypes.back();
2877 
2878  // We have a template parameter list with no corresponding scope, which
2879  // means that the resulting template declaration can't be instantiated
2880  // properly (we'll end up with dependent nodes when we shouldn't).
2881  if (!AllExplicitSpecHeaders)
2882  Invalid = true;
2883  }
2884 
2885  // C++ [temp.expl.spec]p16:
2886  // In an explicit specialization declaration for a member of a class
2887  // template or a member template that ap- pears in namespace scope, the
2888  // member template and some of its enclosing class templates may remain
2889  // unspecialized, except that the declaration shall not explicitly
2890  // specialize a class member template if its en- closing class templates
2891  // are not explicitly specialized as well.
2892  if (ParamLists.back()->size() == 0 &&
2893  CheckExplicitSpecialization(ParamLists[ParamIdx]->getSourceRange(),
2894  false))
2895  return nullptr;
2896 
2897  // Return the last template parameter list, which corresponds to the
2898  // entity being declared.
2899  return ParamLists.back();
2900 }
2901 
2903  if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
2904  Diag(Template->getLocation(), diag::note_template_declared_here)
2905  << (isa<FunctionTemplateDecl>(Template)
2906  ? 0
2907  : isa<ClassTemplateDecl>(Template)
2908  ? 1
2909  : isa<VarTemplateDecl>(Template)
2910  ? 2
2911  : isa<TypeAliasTemplateDecl>(Template) ? 3 : 4)
2912  << Template->getDeclName();
2913  return;
2914  }
2915 
2917  for (OverloadedTemplateStorage::iterator I = OST->begin(),
2918  IEnd = OST->end();
2919  I != IEnd; ++I)
2920  Diag((*I)->getLocation(), diag::note_template_declared_here)
2921  << 0 << (*I)->getDeclName();
2922 
2923  return;
2924  }
2925 }
2926 
2927 static QualType
2929  const SmallVectorImpl<TemplateArgument> &Converted,
2930  SourceLocation TemplateLoc,
2931  TemplateArgumentListInfo &TemplateArgs) {
2932  ASTContext &Context = SemaRef.getASTContext();
2933  switch (BTD->getBuiltinTemplateKind()) {
2934  case BTK__make_integer_seq: {
2935  // Specializations of __make_integer_seq<S, T, N> are treated like
2936  // S<T, 0, ..., N-1>.
2937 
2938  // C++14 [inteseq.intseq]p1:
2939  // T shall be an integer type.
2940  if (!Converted[1].getAsType()->isIntegralType(Context)) {
2941  SemaRef.Diag(TemplateArgs[1].getLocation(),
2942  diag::err_integer_sequence_integral_element_type);
2943  return QualType();
2944  }
2945 
2946  // C++14 [inteseq.make]p1:
2947  // If N is negative the program is ill-formed.
2948  TemplateArgument NumArgsArg = Converted[2];
2949  llvm::APSInt NumArgs = NumArgsArg.getAsIntegral();
2950  if (NumArgs < 0) {
2951  SemaRef.Diag(TemplateArgs[2].getLocation(),
2952  diag::err_integer_sequence_negative_length);
2953  return QualType();
2954  }
2955 
2956  QualType ArgTy = NumArgsArg.getIntegralType();
2957  TemplateArgumentListInfo SyntheticTemplateArgs;
2958  // The type argument gets reused as the first template argument in the
2959  // synthetic template argument list.
2960  SyntheticTemplateArgs.addArgument(TemplateArgs[1]);
2961  // Expand N into 0 ... N-1.
2962  for (llvm::APSInt I(NumArgs.getBitWidth(), NumArgs.isUnsigned());
2963  I < NumArgs; ++I) {
2964  TemplateArgument TA(Context, I, ArgTy);
2965  SyntheticTemplateArgs.addArgument(SemaRef.getTrivialTemplateArgumentLoc(
2966  TA, ArgTy, TemplateArgs[2].getLocation()));
2967  }
2968  // The first template argument will be reused as the template decl that
2969  // our synthetic template arguments will be applied to.
2970  return SemaRef.CheckTemplateIdType(Converted[0].getAsTemplate(),
2971  TemplateLoc, SyntheticTemplateArgs);
2972  }
2973 
2975  // Specializations of
2976  // __type_pack_element<Index, T_1, ..., T_N>
2977  // are treated like T_Index.
2978  assert(Converted.size() == 2 &&
2979  "__type_pack_element should be given an index and a parameter pack");
2980 
2981  // If the Index is out of bounds, the program is ill-formed.
2982  TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
2983  llvm::APSInt Index = IndexArg.getAsIntegral();
2984  assert(Index >= 0 && "the index used with __type_pack_element should be of "
2985  "type std::size_t, and hence be non-negative");
2986  if (Index >= Ts.pack_size()) {
2987  SemaRef.Diag(TemplateArgs[0].getLocation(),
2988  diag::err_type_pack_element_out_of_bounds);
2989  return QualType();
2990  }
2991 
2992  // We simply return the type at index `Index`.
2993  auto Nth = std::next(Ts.pack_begin(), Index.getExtValue());
2994  return Nth->getAsType();
2995  }
2996  llvm_unreachable("unexpected BuiltinTemplateDecl!");
2997 }
2998 
2999 /// Determine whether this alias template is "enable_if_t".
3000 static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate) {
3001  return AliasTemplate->getName().equals("enable_if_t");
3002 }
3003 
3004 /// Collect all of the separable terms in the given condition, which
3005 /// might be a conjunction.
3006 ///
3007 /// FIXME: The right answer is to convert the logical expression into
3008 /// disjunctive normal form, so we can find the first failed term
3009 /// within each possible clause.
3010 static void collectConjunctionTerms(Expr *Clause,
3011  SmallVectorImpl<Expr *> &Terms) {
3012  if (auto BinOp = dyn_cast<BinaryOperator>(Clause->IgnoreParenImpCasts())) {
3013  if (BinOp->getOpcode() == BO_LAnd) {
3014  collectConjunctionTerms(BinOp->getLHS(), Terms);
3015  collectConjunctionTerms(BinOp->getRHS(), Terms);
3016  }
3017 
3018  return;
3019  }
3020 
3021  Terms.push_back(Clause);
3022 }
3023 
3024 // The ranges-v3 library uses an odd pattern of a top-level "||" with
3025 // a left-hand side that is value-dependent but never true. Identify
3026 // the idiom and ignore that term.
3028  // Top-level '||'.
3029  auto *BinOp = dyn_cast<BinaryOperator>(Cond->IgnoreParenImpCasts());
3030  if (!BinOp) return Cond;
3031 
3032  if (BinOp->getOpcode() != BO_LOr) return Cond;
3033 
3034  // With an inner '==' that has a literal on the right-hand side.
3035  Expr *LHS = BinOp->getLHS();
3036  auto *InnerBinOp = dyn_cast<BinaryOperator>(LHS->IgnoreParenImpCasts());
3037  if (!InnerBinOp) return Cond;
3038 
3039  if (InnerBinOp->getOpcode() != BO_EQ ||
3040  !isa<IntegerLiteral>(InnerBinOp->getRHS()))
3041  return Cond;
3042 
3043  // If the inner binary operation came from a macro expansion named
3044  // CONCEPT_REQUIRES or CONCEPT_REQUIRES_, return the right-hand side
3045  // of the '||', which is the real, user-provided condition.
3046  SourceLocation Loc = InnerBinOp->getExprLoc();
3047  if (!Loc.isMacroID()) return Cond;
3048 
3049  StringRef MacroName = PP.getImmediateMacroName(Loc);
3050  if (MacroName == "CONCEPT_REQUIRES" || MacroName == "CONCEPT_REQUIRES_")
3051  return BinOp->getRHS();
3052 
3053  return Cond;
3054 }
3055 
3056 namespace {
3057 
3058 // A PrinterHelper that prints more helpful diagnostics for some sub-expressions
3059 // within failing boolean expression, such as substituting template parameters
3060 // for actual types.
3061 class FailedBooleanConditionPrinterHelper : public PrinterHelper {
3062 public:
3063  explicit FailedBooleanConditionPrinterHelper(const PrintingPolicy &P)
3064  : Policy(P) {}
3065 
3066  bool handledStmt(Stmt *E, raw_ostream &OS) override {
3067  const auto *DR = dyn_cast<DeclRefExpr>(E);
3068  if (DR && DR->getQualifier()) {
3069  // If this is a qualified name, expand the template arguments in nested
3070  // qualifiers.
3071  DR->getQualifier()->print(OS, Policy, true);
3072  // Then print the decl itself.
3073  const ValueDecl *VD = DR->getDecl();
3074  OS << VD->getName();
3075  if (const auto *IV = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
3076  // This is a template variable, print the expanded template arguments.
3077  printTemplateArgumentList(OS, IV->getTemplateArgs().asArray(), Policy);
3078  }
3079  return true;
3080  }
3081  return false;
3082  }
3083 
3084 private:
3085  const PrintingPolicy Policy;
3086 };
3087 
3088 } // end anonymous namespace
3089 
3090 std::pair<Expr *, std::string>
3092  Cond = lookThroughRangesV3Condition(PP, Cond);
3093 
3094  // Separate out all of the terms in a conjunction.
3095  SmallVector<Expr *, 4> Terms;
3096  collectConjunctionTerms(Cond, Terms);
3097 
3098  // Determine which term failed.
3099  Expr *FailedCond = nullptr;
3100  for (Expr *Term : Terms) {
3101  Expr *TermAsWritten = Term->IgnoreParenImpCasts();
3102 
3103  // Literals are uninteresting.
3104  if (isa<CXXBoolLiteralExpr>(TermAsWritten) ||
3105  isa<IntegerLiteral>(TermAsWritten))
3106  continue;
3107 
3108  // The initialization of the parameter from the argument is
3109  // a constant-evaluated context.
3110  EnterExpressionEvaluationContext ConstantEvaluated(
3112 
3113  bool Succeeded;
3114  if (Term->EvaluateAsBooleanCondition(Succeeded, Context) &&
3115  !Succeeded) {
3116  FailedCond = TermAsWritten;
3117  break;
3118  }
3119  }
3120  if (!FailedCond)
3121  FailedCond = Cond->IgnoreParenImpCasts();
3122 
3123  std::string Description;
3124  {
3125  llvm::raw_string_ostream Out(Description);
3126  PrintingPolicy Policy = getPrintingPolicy();
3127  Policy.PrintCanonicalTypes = true;
3128  FailedBooleanConditionPrinterHelper Helper(Policy);
3129  FailedCond->printPretty(Out, &Helper, Policy, 0, "\n", nullptr);
3130  }
3131  return { FailedCond, Description };
3132 }
3133 
3135  SourceLocation TemplateLoc,
3136  TemplateArgumentListInfo &TemplateArgs) {
3139  if (DTN && DTN->isIdentifier())
3140  // When building a template-id where the template-name is dependent,
3141  // assume the template is a type template. Either our assumption is
3142  // correct, or the code is ill-formed and will be diagnosed when the
3143  // dependent name is substituted.
3145  DTN->getQualifier(),
3146  DTN->getIdentifier(),
3147  TemplateArgs);
3148 
3149  TemplateDecl *Template = Name.getAsTemplateDecl();
3150  if (!Template || isa<FunctionTemplateDecl>(Template) ||
3151  isa<VarTemplateDecl>(Template)) {
3152  // We might have a substituted template template parameter pack. If so,
3153  // build a template specialization type for it.
3155  return Context.getTemplateSpecializationType(Name, TemplateArgs);
3156 
3157  Diag(TemplateLoc, diag::err_template_id_not_a_type)
3158  << Name;
3159  NoteAllFoundTemplates(Name);
3160  return QualType();
3161  }
3162 
3163  // Check that the template argument list is well-formed for this
3164  // template.
3166  if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
3167  false, Converted))
3168  return QualType();
3169 
3170  QualType CanonType;
3171 
3172  bool InstantiationDependent = false;
3173  if (TypeAliasTemplateDecl *AliasTemplate =
3174  dyn_cast<TypeAliasTemplateDecl>(Template)) {
3175  // Find the canonical type for this type alias template specialization.
3176  TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
3177  if (Pattern->isInvalidDecl())
3178  return QualType();
3179 
3181  Converted);
3182 
3183  // Only substitute for the innermost template argument list.
3184  MultiLevelTemplateArgumentList TemplateArgLists;
3185  TemplateArgLists.addOuterTemplateArguments(&StackTemplateArgs);
3186  unsigned Depth = AliasTemplate->getTemplateParameters()->getDepth();
3187  for (unsigned I = 0; I < Depth; ++I)
3188  TemplateArgLists.addOuterTemplateArguments(None);
3189 
3191  InstantiatingTemplate Inst(*this, TemplateLoc, Template);
3192  if (Inst.isInvalid())
3193  return QualType();
3194 
3195  CanonType = SubstType(Pattern->getUnderlyingType(),
3196  TemplateArgLists, AliasTemplate->getLocation(),
3197  AliasTemplate->getDeclName());
3198  if (CanonType.isNull()) {
3199  // If this was enable_if and we failed to find the nested type
3200  // within enable_if in a SFINAE context, dig out the specific
3201  // enable_if condition that failed and present that instead.
3202  if (isEnableIfAliasTemplate(AliasTemplate)) {
3203  if (auto DeductionInfo = isSFINAEContext()) {
3204  if (*DeductionInfo &&
3205  (*DeductionInfo)->hasSFINAEDiagnostic() &&
3206  (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() ==
3207  diag::err_typename_nested_not_found_enable_if &&
3208  TemplateArgs[0].getArgument().getKind()
3210  Expr *FailedCond;
3211  std::string FailedDescription;
3212  std::tie(FailedCond, FailedDescription) =
3213  findFailedBooleanCondition(TemplateArgs[0].getSourceExpression());
3214 
3215  // Remove the old SFINAE diagnostic.
3216  PartialDiagnosticAt OldDiag =
3218  (*DeductionInfo)->takeSFINAEDiagnostic(OldDiag);
3219 
3220  // Add a new SFINAE diagnostic specifying which condition
3221  // failed.
3222  (*DeductionInfo)->addSFINAEDiagnostic(
3223  OldDiag.first,
3224  PDiag(diag::err_typename_nested_not_found_requirement)
3225  << FailedDescription
3226  << FailedCond->getSourceRange());
3227  }
3228  }
3229  }
3230 
3231  return QualType();
3232  }
3233  } else if (Name.isDependent() ||
3235  TemplateArgs, InstantiationDependent)) {
3236  // This class template specialization is a dependent
3237  // type. Therefore, its canonical type is another class template
3238  // specialization type that contains all of the converted
3239  // arguments in canonical form. This ensures that, e.g., A<T> and
3240  // A<T, T> have identical types when A is declared as:
3241  //
3242  // template<typename T, typename U = T> struct A;
3243  CanonType = Context.getCanonicalTemplateSpecializationType(Name, Converted);
3244 
3245  // This might work out to be a current instantiation, in which
3246  // case the canonical type needs to be the InjectedClassNameType.
3247  //
3248  // TODO: in theory this could be a simple hashtable lookup; most
3249  // changes to CurContext don't change the set of current
3250  // instantiations.
3251  if (isa<ClassTemplateDecl>(Template)) {
3252  for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getLookupParent()) {
3253  // If we get out to a namespace, we're done.
3254  if (Ctx->isFileContext()) break;
3255 
3256  // If this isn't a record, keep looking.
3257  CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx);
3258  if (!Record) continue;
3259 
3260  // Look for one of the two cases with InjectedClassNameTypes
3261  // and check whether it's the same template.
3262  if (!isa<ClassTemplatePartialSpecializationDecl>(Record) &&
3263  !Record->getDescribedClassTemplate())
3264  continue;
3265 
3266  // Fetch the injected class name type and check whether its
3267  // injected type is equal to the type we just built.
3268  QualType ICNT = Context.getTypeDeclType(Record);
3269  QualType Injected = cast<InjectedClassNameType>(ICNT)
3270  ->getInjectedSpecializationType();
3271 
3272  if (CanonType != Injected->getCanonicalTypeInternal())
3273  continue;
3274 
3275  // If so, the canonical type of this TST is the injected
3276  // class name type of the record we just found.
3277  assert(ICNT.isCanonical());
3278  CanonType = ICNT;
3279  break;
3280  }
3281  }
3282  } else if (ClassTemplateDecl *ClassTemplate
3283  = dyn_cast<ClassTemplateDecl>(Template)) {
3284  // Find the class template specialization declaration that
3285  // corresponds to these arguments.
3286  void *InsertPos = nullptr;
3288  = ClassTemplate->findSpecialization(Converted, InsertPos);
3289  if (!Decl) {
3290  // This is the first time we have referenced this class template
3291  // specialization. Create the canonical declaration and add it to
3292  // the set of specializations.
3294  Context, ClassTemplate->getTemplatedDecl()->getTagKind(),
3295  ClassTemplate->getDeclContext(),
3296  ClassTemplate->getTemplatedDecl()->getBeginLoc(),
3297  ClassTemplate->getLocation(), ClassTemplate, Converted, nullptr);
3298  ClassTemplate->AddSpecialization(Decl, InsertPos);
3299  if (ClassTemplate->isOutOfLine())
3300  Decl->setLexicalDeclContext(ClassTemplate->getLexicalDeclContext());
3301  }
3302 
3303  if (Decl->getSpecializationKind() == TSK_Undeclared) {
3304  MultiLevelTemplateArgumentList TemplateArgLists;
3305  TemplateArgLists.addOuterTemplateArguments(Converted);
3306  InstantiateAttrsForDecl(TemplateArgLists, ClassTemplate->getTemplatedDecl(),
3307  Decl);
3308  }
3309 
3310  // Diagnose uses of this specialization.
3311  (void)DiagnoseUseOfDecl(Decl, TemplateLoc);
3312 
3313  CanonType = Context.getTypeDeclType(Decl);
3314  assert(isa<RecordType>(CanonType) &&
3315  "type of non-dependent specialization is not a RecordType");
3316  } else if (auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
3317  CanonType = checkBuiltinTemplateIdType(*this, BTD, Converted, TemplateLoc,
3318  TemplateArgs);
3319  }
3320 
3321  // Build the fully-sugared type for this class template
3322  // specialization, which refers back to the class template
3323  // specialization we created or found.
3324  return Context.getTemplateSpecializationType(Name, TemplateArgs, CanonType);
3325 }
3326 
3327 TypeResult
3329  TemplateTy TemplateD, IdentifierInfo *TemplateII,
3330  SourceLocation TemplateIILoc,
3331  SourceLocation LAngleLoc,
3332  ASTTemplateArgsPtr TemplateArgsIn,
3333  SourceLocation RAngleLoc,
3334  bool IsCtorOrDtorName, bool IsClassName) {
3335  if (SS.isInvalid())
3336  return true;
3337 
3338  if (!IsCtorOrDtorName && !IsClassName && SS.isSet()) {
3339  DeclContext *LookupCtx = computeDeclContext(SS, /*EnteringContext*/false);
3340 
3341  // C++ [temp.res]p3:
3342  // A qualified-id that refers to a type and in which the
3343  // nested-name-specifier depends on a template-parameter (14.6.2)
3344  // shall be prefixed by the keyword typename to indicate that the
3345  // qualified-id denotes a type, forming an
3346  // elaborated-type-specifier (7.1.5.3).
3347  if (!LookupCtx && isDependentScopeSpecifier(SS)) {
3348  Diag(SS.getBeginLoc(), diag::err_typename_missing_template)
3349  << SS.getScopeRep() << TemplateII->getName();
3350  // Recover as if 'typename' were specified.
3351  // FIXME: This is not quite correct recovery as we don't transform SS
3352  // into the corresponding dependent form (and we don't diagnose missing
3353  // 'template' keywords within SS as a result).
3354  return ActOnTypenameType(nullptr, SourceLocation(), SS, TemplateKWLoc,
3355  TemplateD, TemplateII, TemplateIILoc, LAngleLoc,
3356  TemplateArgsIn, RAngleLoc);
3357  }
3358 
3359  // Per C++ [class.qual]p2, if the template-id was an injected-class-name,
3360  // it's not actually allowed to be used as a type in most cases. Because
3361  // we annotate it before we know whether it's valid, we have to check for
3362  // this case here.
3363  auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
3364  if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
3365  Diag(TemplateIILoc,
3366  TemplateKWLoc.isInvalid()
3367  ? diag::err_out_of_line_qualified_id_type_names_constructor
3368  : diag::ext_out_of_line_qualified_id_type_names_constructor)
3369  << TemplateII << 0 /*injected-class-name used as template name*/
3370  << 1 /*if any keyword was present, it was 'template'*/;
3371  }
3372  }
3373 
3374  TemplateName Template = TemplateD.get();
3375 
3376  // Translate the parser's template argument list in our AST format.
3377  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
3378  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
3379 
3380  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
3381  QualType T
3383  DTN->getQualifier(),
3384  DTN->getIdentifier(),
3385  TemplateArgs);
3386  // Build type-source information.
3387  TypeLocBuilder TLB;
3391  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
3392  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
3393  SpecTL.setTemplateNameLoc(TemplateIILoc);
3394  SpecTL.setLAngleLoc(LAngleLoc);
3395  SpecTL.setRAngleLoc(RAngleLoc);
3396  for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
3397  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
3398  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
3399  }
3400 
3401  QualType Result = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
3402  if (Result.isNull())
3403  return true;
3404 
3405  // Build type-source information.
3406  TypeLocBuilder TLB;
3408  = TLB.push<TemplateSpecializationTypeLoc>(Result);
3409  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
3410  SpecTL.setTemplateNameLoc(TemplateIILoc);
3411  SpecTL.setLAngleLoc(LAngleLoc);
3412  SpecTL.setRAngleLoc(RAngleLoc);
3413  for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
3414  SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
3415 
3416  // NOTE: avoid constructing an ElaboratedTypeLoc if this is a
3417  // constructor or destructor name (in such a case, the scope specifier
3418  // will be attached to the enclosing Decl or Expr node).
3419  if (SS.isNotEmpty() && !IsCtorOrDtorName) {
3420  // Create an elaborated-type-specifier containing the nested-name-specifier.
3421  Result = Context.getElaboratedType(ETK_None, SS.getScopeRep(), Result);
3422  ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
3424  ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
3425  }
3426 
3427  return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
3428 }
3429 
3431  TypeSpecifierType TagSpec,
3432  SourceLocation TagLoc,
3433  CXXScopeSpec &SS,
3434  SourceLocation TemplateKWLoc,
3435  TemplateTy TemplateD,
3436  SourceLocation TemplateLoc,
3437  SourceLocation LAngleLoc,
3438  ASTTemplateArgsPtr TemplateArgsIn,
3439  SourceLocation RAngleLoc) {
3440  TemplateName Template = TemplateD.get();
3441 
3442  // Translate the parser's template argument list in our AST format.
3443  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
3444  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
3445 
3446  // Determine the tag kind
3448  ElaboratedTypeKeyword Keyword
3450 
3451  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
3453  DTN->getQualifier(),
3454  DTN->getIdentifier(),
3455  TemplateArgs);
3456 
3457  // Build type-source information.
3458  TypeLocBuilder TLB;
3461  SpecTL.setElaboratedKeywordLoc(TagLoc);
3462  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
3463  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
3464  SpecTL.setTemplateNameLoc(TemplateLoc);
3465  SpecTL.setLAngleLoc(LAngleLoc);
3466  SpecTL.setRAngleLoc(RAngleLoc);
3467  for (unsigned I = 0, N = SpecTL.getNumArgs(); I != N; ++I)
3468  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
3469  return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
3470  }
3471 
3472  if (TypeAliasTemplateDecl *TAT =
3473  dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) {
3474  // C++0x [dcl.type.elab]p2:
3475  // If the identifier resolves to a typedef-name or the simple-template-id
3476  // resolves to an alias template specialization, the
3477  // elaborated-type-specifier is ill-formed.
3478  Diag(TemplateLoc, diag::err_tag_reference_non_tag)
3479  << TAT << NTK_TypeAliasTemplate << TagKind;
3480  Diag(TAT->getLocation(), diag::note_declared_at);
3481  }
3482 
3483  QualType Result = CheckTemplateIdType(Template, TemplateLoc, TemplateArgs);
3484  if (Result.isNull())
3485  return TypeResult(true);
3486 
3487  // Check the tag kind
3488  if (const RecordType *RT = Result->getAs<RecordType>()) {
3489  RecordDecl *D = RT->getDecl();
3490 
3492  assert(Id && "templated class must have an identifier");
3493 
3494  if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition,
3495  TagLoc, Id)) {
3496  Diag(TagLoc, diag::err_use_with_wrong_tag)
3497  << Result
3499  Diag(D->getLocation(), diag::note_previous_use);
3500  }
3501  }
3502 
3503  // Provide source-location information for the template specialization.
3504  TypeLocBuilder TLB;
3506  = TLB.push<TemplateSpecializationTypeLoc>(Result);
3507  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
3508  SpecTL.setTemplateNameLoc(TemplateLoc);
3509  SpecTL.setLAngleLoc(LAngleLoc);
3510  SpecTL.setRAngleLoc(RAngleLoc);
3511  for (unsigned i = 0, e = SpecTL.getNumArgs(); i != e; ++i)
3512  SpecTL.setArgLocInfo(i, TemplateArgs[i].getLocInfo());
3513 
3514  // Construct an elaborated type containing the nested-name-specifier (if any)
3515  // and tag keyword.
3516  Result = Context.getElaboratedType(Keyword, SS.getScopeRep(), Result);
3517  ElaboratedTypeLoc ElabTL = TLB.push<ElaboratedTypeLoc>(Result);
3518  ElabTL.setElaboratedKeywordLoc(TagLoc);
3519  ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
3520  return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
3521 }
3522 
3523 static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized,
3524  NamedDecl *PrevDecl,
3525  SourceLocation Loc,
3527 
3529 
3531  const TemplateArgument &Arg, unsigned Depth, unsigned Index) {
3532  switch (Arg.getKind()) {
3539  return false;
3540 
3541  case TemplateArgument::Type: {
3542  QualType Type = Arg.getAsType();
3543  const TemplateTypeParmType *TPT =
3545  return TPT && !Type.hasQualifiers() &&
3546  TPT->getDepth() == Depth && TPT->getIndex() == Index;
3547  }
3548 
3550  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg.getAsExpr());
3551  if (!DRE || !DRE->getDecl())
3552  return false;
3553  const NonTypeTemplateParmDecl *NTTP =
3554  dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
3555  return NTTP && NTTP->getDepth() == Depth && NTTP->getIndex() == Index;
3556  }
3557 
3559  const TemplateTemplateParmDecl *TTP =
3560  dyn_cast_or_null<TemplateTemplateParmDecl>(
3562  return TTP && TTP->getDepth() == Depth && TTP->getIndex() == Index;
3563  }
3564  llvm_unreachable("unexpected kind of template argument");
3565 }
3566 
3569  if (Params->size() != Args.size())
3570  return false;
3571 
3572  unsigned Depth = Params->getDepth();
3573 
3574  for (unsigned I = 0, N = Args.size(); I != N; ++I) {
3575  TemplateArgument Arg = Args[I];
3576 
3577  // If the parameter is a pack expansion, the argument must be a pack
3578  // whose only element is a pack expansion.
3579  if (Params->getParam(I)->isParameterPack()) {
3580  if (Arg.getKind() != TemplateArgument::Pack || Arg.pack_size() != 1 ||
3581  !Arg.pack_begin()->isPackExpansion())
3582  return false;
3583  Arg = Arg.pack_begin()->getPackExpansionPattern();
3584  }
3585 
3586  if (!isTemplateArgumentTemplateParameter(Arg, Depth, I))
3587  return false;
3588  }
3589 
3590  return true;
3591 }
3592 
3593 /// Convert the parser's template argument list representation into our form.
3596  TemplateArgumentListInfo TemplateArgs(TemplateId.LAngleLoc,
3597  TemplateId.RAngleLoc);
3598  ASTTemplateArgsPtr TemplateArgsPtr(TemplateId.getTemplateArgs(),
3599  TemplateId.NumArgs);
3600  S.translateTemplateArguments(TemplateArgsPtr, TemplateArgs);
3601  return TemplateArgs;
3602 }
3603 
3604 template<typename PartialSpecDecl>
3605 static void checkMoreSpecializedThanPrimary(Sema &S, PartialSpecDecl *Partial) {
3606  if (Partial->getDeclContext()->isDependentContext())
3607  return;
3608 
3609  // FIXME: Get the TDK from deduction in order to provide better diagnostics
3610  // for non-substitution-failure issues?
3611  TemplateDeductionInfo Info(Partial->getLocation());
3612  if (S.isMoreSpecializedThanPrimary(Partial, Info))
3613  return;
3614 
3615  auto *Template = Partial->getSpecializedTemplate();
3616  S.Diag(Partial->getLocation(),
3617  diag::ext_partial_spec_not_more_specialized_than_primary)
3618  << isa<VarTemplateDecl>(Template);
3619 
3620  if (Info.hasSFINAEDiagnostic()) {
3623  Info.takeSFINAEDiagnostic(Diag);
3624  SmallString<128> SFINAEArgString;
3625  Diag.second.EmitToString(S.getDiagnostics(), SFINAEArgString);
3626  S.Diag(Diag.first,
3627  diag::note_partial_spec_not_more_specialized_than_primary)
3628  << SFINAEArgString;
3629  }
3630 
3631  S.Diag(Template->getLocation(), diag::note_template_decl_here);
3632 }
3633 
3634 static void
3636  const llvm::SmallBitVector &DeducibleParams) {
3637  for (unsigned I = 0, N = DeducibleParams.size(); I != N; ++I) {
3638  if (!DeducibleParams[I]) {
3639  NamedDecl *Param = TemplateParams->getParam(I);
3640  if (Param->getDeclName())
3641  S.Diag(Param->getLocation(), diag::note_non_deducible_parameter)
3642  << Param->getDeclName();
3643  else
3644  S.Diag(Param->getLocation(), diag::note_non_deducible_parameter)
3645  << "(anonymous)";
3646  }
3647  }
3648 }
3649 
3650 
3651 template<typename PartialSpecDecl>
3653  PartialSpecDecl *Partial) {
3654  // C++1z [temp.class.spec]p8: (DR1495)
3655  // - The specialization shall be more specialized than the primary
3656  // template (14.5.5.2).
3657  checkMoreSpecializedThanPrimary(S, Partial);
3658 
3659  // C++ [temp.class.spec]p8: (DR1315)
3660  // - Each template-parameter shall appear at least once in the
3661  // template-id outside a non-deduced context.
3662  // C++1z [temp.class.spec.match]p3 (P0127R2)
3663  // If the template arguments of a partial specialization cannot be
3664  // deduced because of the structure of its template-parameter-list
3665  // and the template-id, the program is ill-formed.
3666  auto *TemplateParams = Partial->getTemplateParameters();
3667  llvm::SmallBitVector DeducibleParams(TemplateParams->size());
3668  S.MarkUsedTemplateParameters(Partial->getTemplateArgs(), true,
3669  TemplateParams->getDepth(), DeducibleParams);
3670 
3671  if (!DeducibleParams.all()) {
3672  unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
3673  S.Diag(Partial->getLocation(), diag::ext_partial_specs_not_deducible)
3674  << isa<VarTemplatePartialSpecializationDecl>(Partial)
3675  << (NumNonDeducible > 1)
3676  << SourceRange(Partial->getLocation(),
3677  Partial->getTemplateArgsAsWritten()->RAngleLoc);
3678  noteNonDeducibleParameters(S, TemplateParams, DeducibleParams);
3679  }
3680 }
3681 
3684  checkTemplatePartialSpecialization(*this, Partial);
3685 }
3686 
3689  checkTemplatePartialSpecialization(*this, Partial);
3690 }
3691 
3693  // C++1z [temp.param]p11:
3694  // A template parameter of a deduction guide template that does not have a
3695  // default-argument shall be deducible from the parameter-type-list of the
3696  // deduction guide template.
3697  auto *TemplateParams = TD->getTemplateParameters();
3698  llvm::SmallBitVector DeducibleParams(TemplateParams->size());
3699  MarkDeducedTemplateParameters(TD, DeducibleParams);
3700  for (unsigned I = 0; I != TemplateParams->size(); ++I) {
3701  // A parameter pack is deducible (to an empty pack).
3702  auto *Param = TemplateParams->getParam(I);
3703  if (Param->isParameterPack() || hasVisibleDefaultArgument(Param))
3704  DeducibleParams[I] = true;
3705  }
3706 
3707  if (!DeducibleParams.all()) {
3708  unsigned NumNonDeducible = DeducibleParams.size() - DeducibleParams.count();
3709  Diag(TD->getLocation(), diag::err_deduction_guide_template_not_deducible)
3710  << (NumNonDeducible > 1);
3711  noteNonDeducibleParameters(*this, TemplateParams, DeducibleParams);
3712  }
3713 }
3714 
3716  Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc,
3717  TemplateParameterList *TemplateParams, StorageClass SC,
3718  bool IsPartialSpecialization) {
3719  // D must be variable template id.
3721  "Variable template specialization is declared with a template it.");
3722 
3723  TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
3724  TemplateArgumentListInfo TemplateArgs =
3725  makeTemplateArgumentListInfo(*this, *TemplateId);
3726  SourceLocation TemplateNameLoc = D.getIdentifierLoc();
3727  SourceLocation LAngleLoc = TemplateId->LAngleLoc;
3728  SourceLocation RAngleLoc = TemplateId->RAngleLoc;
3729 
3730  TemplateName Name = TemplateId->Template.get();
3731 
3732  // The template-id must name a variable template.
3733  VarTemplateDecl *VarTemplate =
3734  dyn_cast_or_null<VarTemplateDecl>(Name.getAsTemplateDecl());
3735  if (!VarTemplate) {
3736  NamedDecl *FnTemplate;
3737  if (auto *OTS = Name.getAsOverloadedTemplate())
3738  FnTemplate = *OTS->begin();
3739  else
3740  FnTemplate = dyn_cast_or_null<FunctionTemplateDecl>(Name.getAsTemplateDecl());
3741  if (FnTemplate)
3742  return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template_but_method)
3743  << FnTemplate->getDeclName();
3744  return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template)
3745  << IsPartialSpecialization;
3746  }
3747 
3748  // Check for unexpanded parameter packs in any of the template arguments.
3749  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
3750  if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
3751  UPPC_PartialSpecialization))
3752  return true;
3753 
3754  // Check that the template argument list is well-formed for this
3755  // template.
3757  if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
3758  false, Converted))
3759  return true;
3760 
3761  // Find the variable template (partial) specialization declaration that
3762  // corresponds to these arguments.
3763  if (IsPartialSpecialization) {
3764  if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, VarTemplate,
3765  TemplateArgs.size(), Converted))
3766  return true;
3767 
3768  // FIXME: Move these checks to CheckTemplatePartialSpecializationArgs so we
3769  // also do them during instantiation.
3770  bool InstantiationDependent;
3771  if (!Name.isDependent() &&
3773  TemplateArgs.arguments(),
3774  InstantiationDependent)) {
3775  Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
3776  << VarTemplate->getDeclName();
3777  IsPartialSpecialization = false;
3778  }
3779 
3781  Converted)) {
3782  // C++ [temp.class.spec]p9b3:
3783  //
3784  // -- The argument list of the specialization shall not be identical
3785  // to the implicit argument list of the primary template.
3786  Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
3787  << /*variable template*/ 1
3788  << /*is definition*/(SC != SC_Extern && !CurContext->isRecord())
3789  << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
3790  // FIXME: Recover from this by treating the declaration as a redeclaration
3791  // of the primary template.
3792  return true;
3793  }
3794  }
3795 
3796  void *InsertPos = nullptr;
3797  VarTemplateSpecializationDecl *PrevDecl = nullptr;
3798 
3799  if (IsPartialSpecialization)
3800  // FIXME: Template parameter list matters too
3801  PrevDecl = VarTemplate->findPartialSpecialization(Converted, InsertPos);
3802  else
3803  PrevDecl = VarTemplate->findSpecialization(Converted, InsertPos);
3804 
3805  VarTemplateSpecializationDecl *Specialization = nullptr;
3806 
3807  // Check whether we can declare a variable template specialization in
3808  // the current scope.
3809  if (CheckTemplateSpecializationScope(*this, VarTemplate, PrevDecl,
3810  TemplateNameLoc,
3811  IsPartialSpecialization))
3812  return true;
3813 
3814  if (PrevDecl && PrevDecl->getSpecializationKind() == TSK_Undeclared) {
3815  // Since the only prior variable template specialization with these
3816  // arguments was referenced but not declared, reuse that
3817  // declaration node as our own, updating its source location and
3818  // the list of outer template parameters to reflect our new declaration.
3819  Specialization = PrevDecl;
3820  Specialization->setLocation(TemplateNameLoc);
3821  PrevDecl = nullptr;
3822  } else if (IsPartialSpecialization) {
3823  // Create a new class template partial specialization declaration node.
3825  cast_or_null<VarTemplatePartialSpecializationDecl>(PrevDecl);
3828  Context, VarTemplate->getDeclContext(), TemplateKWLoc,
3829  TemplateNameLoc, TemplateParams, VarTemplate, DI->getType(), DI, SC,
3830  Converted, TemplateArgs);
3831 
3832  if (!PrevPartial)
3833  VarTemplate->AddPartialSpecialization(Partial, InsertPos);
3834  Specialization = Partial;
3835 
3836  // If we are providing an explicit specialization of a member variable
3837  // template specialization, make a note of that.
3838  if (PrevPartial && PrevPartial->getInstantiatedFromMember())
3839  PrevPartial->setMemberSpecialization();
3840 
3841  CheckTemplatePartialSpecialization(Partial);
3842  } else {
3843  // Create a new class template specialization declaration node for
3844  // this explicit specialization or friend declaration.
3845  Specialization = VarTemplateSpecializationDecl::Create(
3846  Context, VarTemplate->getDeclContext(), TemplateKWLoc, TemplateNameLoc,
3847  VarTemplate, DI->getType(), DI, SC, Converted);
3848  Specialization->setTemplateArgsInfo(TemplateArgs);
3849 
3850  if (!PrevDecl)
3851  VarTemplate->AddSpecialization(Specialization, InsertPos);
3852  }
3853 
3854  // C++ [temp.expl.spec]p6:
3855  // If a template, a member template or the member of a class template is
3856  // explicitly specialized then that specialization shall be declared
3857  // before the first use of that specialization that would cause an implicit
3858  // instantiation to take place, in every translation unit in which such a
3859  // use occurs; no diagnostic is required.
3860  if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
3861  bool Okay = false;
3862  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
3863  // Is there any previous explicit specialization declaration?
3865  Okay = true;
3866  break;
3867  }
3868  }
3869 
3870  if (!Okay) {
3871  SourceRange Range(TemplateNameLoc, RAngleLoc);
3872  Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
3873  << Name << Range;
3874 
3875  Diag(PrevDecl->getPointOfInstantiation(),
3876  diag::note_instantiation_required_here)
3877  << (PrevDecl->getTemplateSpecializationKind() !=
3879  return true;
3880  }
3881  }
3882 
3883  Specialization->setTemplateKeywordLoc(TemplateKWLoc);
3884  Specialization->setLexicalDeclContext(CurContext);
3885 
3886  // Add the specialization into its lexical context, so that it can
3887  // be seen when iterating through the list of declarations in that
3888  // context. However, specializations are not found by name lookup.
3889  CurContext->addDecl(Specialization);
3890 
3891  // Note that this is an explicit specialization.
3893 
3894  if (PrevDecl) {
3895  // Check that this isn't a redefinition of this specialization,
3896  // merging with previous declarations.
3897  LookupResult PrevSpec(*this, GetNameForDeclarator(D), LookupOrdinaryName,
3898  forRedeclarationInCurContext());
3899  PrevSpec.addDecl(PrevDecl);
3900  D.setRedeclaration(CheckVariableDeclaration(Specialization, PrevSpec));
3901  } else if (Specialization->isStaticDataMember() &&
3902  Specialization->isOutOfLine()) {
3903  Specialization->setAccess(VarTemplate->getAccess());
3904  }
3905 
3906  // Link instantiations of static data members back to the template from
3907  // which they were instantiated.
3908  if (Specialization->isStaticDataMember())
3909  Specialization->setInstantiationOfStaticDataMember(
3910  VarTemplate->getTemplatedDecl(),
3911  Specialization->getSpecializationKind());
3912 
3913  return Specialization;
3914 }
3915 
3916 namespace {
3917 /// A partial specialization whose template arguments have matched
3918 /// a given template-id.
3919 struct PartialSpecMatchResult {
3921  TemplateArgumentList *Args;
3922 };
3923 } // end anonymous namespace
3924 
3925 DeclResult
3927  SourceLocation TemplateNameLoc,
3928  const TemplateArgumentListInfo &TemplateArgs) {
3929  assert(Template && "A variable template id without template?");
3930 
3931  // Check that the template argument list is well-formed for this template.
3933  if (CheckTemplateArgumentList(
3934  Template, TemplateNameLoc,
3935  const_cast<TemplateArgumentListInfo &>(TemplateArgs), false,
3936  Converted))
3937  return true;
3938 
3939  // Find the variable template specialization declaration that
3940  // corresponds to these arguments.
3941  void *InsertPos = nullptr;
3942  if (VarTemplateSpecializationDecl *Spec = Template->findSpecialization(
3943  Converted, InsertPos)) {
3944  checkSpecializationVisibility(TemplateNameLoc, Spec);
3945  // If we already have a variable template specialization, return it.
3946  return Spec;
3947  }
3948 
3949  // This is the first time we have referenced this variable template
3950  // specialization. Create the canonical declaration and add it to
3951  // the set of specializations, based on the closest partial specialization
3952  // that it represents. That is,
3953  VarDecl *InstantiationPattern = Template->getTemplatedDecl();
3955  Converted);
3956  TemplateArgumentList *InstantiationArgs = &TemplateArgList;
3957  bool AmbiguousPartialSpec = false;
3958  typedef PartialSpecMatchResult MatchResult;
3960  SourceLocation PointOfInstantiation = TemplateNameLoc;
3961  TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation,
3962  /*ForTakingAddress=*/false);
3963 
3964  // 1. Attempt to find the closest partial specialization that this
3965  // specializes, if any.
3966  // If any of the template arguments is dependent, then this is probably
3967  // a placeholder for an incomplete declarative context; which must be
3968  // complete by instantiation time. Thus, do not search through the partial
3969  // specializations yet.
3970  // TODO: Unify with InstantiateClassTemplateSpecialization()?
3971  // Perhaps better after unification of DeduceTemplateArguments() and
3972  // getMoreSpecializedPartialSpecialization().
3973  bool InstantiationDependent = false;
3975  TemplateArgs, InstantiationDependent)) {
3976 
3978  Template->getPartialSpecializations(PartialSpecs);
3979 
3980  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
3981  VarTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
3982  TemplateDeductionInfo Info(FailedCandidates.getLocation());
3983 
3984  if (TemplateDeductionResult Result =
3985  DeduceTemplateArguments(Partial, TemplateArgList, Info)) {
3986  // Store the failed-deduction information for use in diagnostics, later.
3987  // TODO: Actually use the failed-deduction info?
3988  FailedCandidates.addCandidate().set(
3989  DeclAccessPair::make(Template, AS_public), Partial,
3990  MakeDeductionFailureInfo(Context, Result, Info));
3991  (void)Result;
3992  } else {
3993  Matched.push_back(PartialSpecMatchResult());
3994  Matched.back().Partial = Partial;
3995  Matched.back().Args = Info.take();
3996  }
3997  }
3998 
3999  if (Matched.size() >= 1) {
4000  SmallVector<MatchResult, 4>::iterator Best = Matched.begin();
4001  if (Matched.size() == 1) {
4002  // -- If exactly one matching specialization is found, the
4003  // instantiation is generated from that specialization.
4004  // We don't need to do anything for this.
4005  } else {
4006  // -- If more than one matching specialization is found, the
4007  // partial order rules (14.5.4.2) are used to determine
4008  // whether one of the specializations is more specialized
4009  // than the others. If none of the specializations is more
4010  // specialized than all of the other matching
4011  // specializations, then the use of the variable template is
4012  // ambiguous and the program is ill-formed.
4013  for (SmallVector<MatchResult, 4>::iterator P = Best + 1,
4014  PEnd = Matched.end();
4015  P != PEnd; ++P) {
4016  if (getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
4017  PointOfInstantiation) ==
4018  P->Partial)
4019  Best = P;
4020  }
4021 
4022  // Determine if the best partial specialization is more specialized than
4023  // the others.
4024  for (SmallVector<MatchResult, 4>::iterator P = Matched.begin(),
4025  PEnd = Matched.end();
4026  P != PEnd; ++P) {
4027  if (P != Best && getMoreSpecializedPartialSpecialization(
4028  P->Partial, Best->Partial,
4029  PointOfInstantiation) != Best->Partial) {
4030  AmbiguousPartialSpec = true;
4031  break;
4032  }
4033  }
4034  }
4035 
4036  // Instantiate using the best variable template partial specialization.
4037  InstantiationPattern = Best->Partial;
4038  InstantiationArgs = Best->Args;
4039  } else {
4040  // -- If no match is found, the instantiation is generated
4041  // from the primary template.
4042  // InstantiationPattern = Template->getTemplatedDecl();
4043  }
4044  }
4045 
4046  // 2. Create the canonical declaration.
4047  // Note that we do not instantiate a definition until we see an odr-use
4048  // in DoMarkVarDeclReferenced().
4049  // FIXME: LateAttrs et al.?
4050  VarTemplateSpecializationDecl *Decl = BuildVarTemplateInstantiation(
4051  Template, InstantiationPattern, *InstantiationArgs, TemplateArgs,
4052  Converted, TemplateNameLoc, InsertPos /*, LateAttrs, StartingScope*/);
4053  if (!Decl)
4054  return true;
4055 
4056  if (AmbiguousPartialSpec) {
4057  // Partial ordering did not produce a clear winner. Complain.
4058  Decl->setInvalidDecl();
4059  Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
4060  << Decl;
4061 
4062  // Print the matching partial specializations.
4063  for (MatchResult P : Matched)
4064  Diag(P.Partial->getLocation(), diag::note_partial_spec_match)
4065  << getTemplateArgumentBindingsText(P.Partial->getTemplateParameters(),
4066  *P.Args);
4067  return true;
4068  }
4069 
4071  dyn_cast<VarTemplatePartialSpecializationDecl>(InstantiationPattern))
4072  Decl->setInstantiationOf(D, InstantiationArgs);
4073 
4074  checkSpecializationVisibility(TemplateNameLoc, Decl);
4075 
4076  assert(Decl && "No variable template specialization?");
4077  return Decl;
4078 }
4079 
4080 ExprResult
4082  const DeclarationNameInfo &NameInfo,
4083  VarTemplateDecl *Template, SourceLocation TemplateLoc,
4084  const TemplateArgumentListInfo *TemplateArgs) {
4085 
4086  DeclResult Decl = CheckVarTemplateId(Template, TemplateLoc, NameInfo.getLoc(),
4087  *TemplateArgs);
4088  if (Decl.isInvalid())
4089  return ExprError();
4090 
4091  VarDecl *Var = cast<VarDecl>(Decl.get());
4092  if (!Var->getTemplateSpecializationKind())
4094  NameInfo.getLoc());
4095 
4096  // Build an ordinary singleton decl ref.
4097  return BuildDeclarationNameExpr(SS, NameInfo, Var,
4098  /*FoundD=*/nullptr, TemplateArgs);
4099 }
4100 
4102  SourceLocation Loc) {
4103  Diag(Loc, diag::err_template_missing_args)
4104  << (int)getTemplateNameKindForDiagnostics(Name) << Name;
4105  if (TemplateDecl *TD = Name.getAsTemplateDecl()) {
4106  Diag(TD->getLocation(), diag::note_template_decl_here)
4107  << TD->getTemplateParameters()->getSourceRange();
4108  }
4109 }
4110 
4112  SourceLocation TemplateKWLoc,
4113  LookupResult &R,
4114  bool RequiresADL,
4115  const TemplateArgumentListInfo *TemplateArgs) {
4116  // FIXME: Can we do any checking at this point? I guess we could check the
4117  // template arguments that we have against the template name, if the template
4118  // name refers to a single template. That's not a terribly common case,
4119  // though.
4120  // foo<int> could identify a single function unambiguously
4121  // This approach does NOT work, since f<int>(1);
4122  // gets resolved prior to resorting to overload resolution
4123  // i.e., template<class T> void f(double);
4124  // vs template<class T, class U> void f(U);
4125 
4126  // These should be filtered out by our callers.
4127  assert(!R.empty() && "empty lookup results when building templateid");
4128  assert(!R.isAmbiguous() && "ambiguous lookup when building templateid");
4129 
4130  // Non-function templates require a template argument list.
4131  if (auto *TD = R.getAsSingle<TemplateDecl>()) {
4132  if (!TemplateArgs && !isa<FunctionTemplateDecl>(TD)) {
4133  diagnoseMissingTemplateArguments(TemplateName(TD), R.getNameLoc());
4134  return ExprError();
4135  }
4136  }
4137 
4138  auto AnyDependentArguments = [&]() -> bool {
4139  bool InstantiationDependent;
4140  return TemplateArgs &&
4142  *TemplateArgs, InstantiationDependent);
4143  };
4144 
4145  // In C++1y, check variable template ids.
4146  if (R.getAsSingle<VarTemplateDecl>() && !AnyDependentArguments()) {
4147  return CheckVarTemplateId(SS, R.getLookupNameInfo(),
4149  TemplateKWLoc, TemplateArgs);
4150  }
4151 
4152  // We don't want lookup warnings at this point.
4153  R.suppressDiagnostics();
4154 
4157  SS.getWithLocInContext(Context),
4158  TemplateKWLoc,
4159  R.getLookupNameInfo(),
4160  RequiresADL, TemplateArgs,
4161  R.begin(), R.end());
4162 
4163  return ULE;
4164 }
4165 
4166 // We actually only call this from template instantiation.
4167 ExprResult
4169  SourceLocation TemplateKWLoc,
4170  const DeclarationNameInfo &NameInfo,
4171  const TemplateArgumentListInfo *TemplateArgs) {
4172 
4173  assert(TemplateArgs || TemplateKWLoc.isValid());
4174  DeclContext *DC;
4175  if (!(DC = computeDeclContext(SS, false)) ||
4176  DC->isDependentContext() ||
4177  RequireCompleteDeclContext(SS, DC))
4178  return BuildDependentDeclRefExpr(SS, TemplateKWLoc, NameInfo, TemplateArgs);
4179 
4180  bool MemberOfUnknownSpecialization;
4181  LookupResult R(*this, NameInfo, LookupOrdinaryName);
4182  if (LookupTemplateName(R, (Scope *)nullptr, SS, QualType(),
4183  /*Entering*/false, MemberOfUnknownSpecialization,
4184  TemplateKWLoc))
4185  return ExprError();
4186 
4187  if (R.isAmbiguous())
4188  return ExprError();
4189 
4190  if (R.empty()) {
4191  Diag(NameInfo.getLoc(), diag::err_no_member)
4192  << NameInfo.getName() << DC << SS.getRange();
4193  return ExprError();
4194  }
4195 
4196  if (ClassTemplateDecl *Temp = R.getAsSingle<ClassTemplateDecl>()) {
4197  Diag(NameInfo.getLoc(), diag::err_template_kw_refers_to_class_template)
4198  << SS.getScopeRep()
4199  << NameInfo.getName().getAsString() << SS.getRange();
4200  Diag(Temp->getLocation(), diag::note_referenced_class_template);
4201  return ExprError();
4202  }
4203 
4204  return BuildTemplateIdExpr(SS, TemplateKWLoc, R, /*ADL*/ false, TemplateArgs);
4205 }
4206 
4207 /// Form a dependent template name.
4208 ///
4209 /// This action forms a dependent template name given the template
4210 /// name and its (presumably dependent) scope specifier. For
4211 /// example, given "MetaFun::template apply", the scope specifier \p
4212 /// SS will be "MetaFun::", \p TemplateKWLoc contains the location
4213 /// of the "template" keyword, and "apply" is the \p Name.
4215  CXXScopeSpec &SS,
4216  SourceLocation TemplateKWLoc,
4217  const UnqualifiedId &Name,
4218  ParsedType ObjectType,
4219  bool EnteringContext,
4220  TemplateTy &Result,
4221  bool AllowInjectedClassName) {
4222  if (TemplateKWLoc.isValid() && S && !S->getTemplateParamParent())
4223  Diag(TemplateKWLoc,
4224  getLangOpts().CPlusPlus11 ?
4225  diag::warn_cxx98_compat_template_outside_of_template :
4226  diag::ext_template_outside_of_template)
4227  << FixItHint::CreateRemoval(TemplateKWLoc);
4228 
4229  DeclContext *LookupCtx = nullptr;
4230  if (SS.isSet())
4231  LookupCtx = computeDeclContext(SS, EnteringContext);
4232  if (!LookupCtx && ObjectType)
4233  LookupCtx = computeDeclContext(ObjectType.get());
4234  if (LookupCtx) {
4235  // C++0x [temp.names]p5:
4236  // If a name prefixed by the keyword template is not the name of
4237  // a template, the program is ill-formed. [Note: the keyword
4238  // template may not be applied to non-template members of class
4239  // templates. -end note ] [ Note: as is the case with the
4240  // typename prefix, the template prefix is allowed in cases
4241  // where it is not strictly necessary; i.e., when the
4242  // nested-name-specifier or the expression on the left of the ->
4243  // or . is not dependent on a template-parameter, or the use
4244  // does not appear in the scope of a template. -end note]
4245  //
4246  // Note: C++03 was more strict here, because it banned the use of
4247  // the "template" keyword prior to a template-name that was not a
4248  // dependent name. C++ DR468 relaxed this requirement (the
4249  // "template" keyword is now permitted). We follow the C++0x
4250  // rules, even in C++03 mode with a warning, retroactively applying the DR.
4251  bool MemberOfUnknownSpecialization;
4252  TemplateNameKind TNK = isTemplateName(S, SS, TemplateKWLoc.isValid(), Name,
4253  ObjectType, EnteringContext, Result,
4254  MemberOfUnknownSpecialization);
4255  if (TNK == TNK_Non_template && MemberOfUnknownSpecialization) {
4256  // This is a dependent template. Handle it below.
4257  } else if (TNK == TNK_Non_template) {
4258  // Do the lookup again to determine if this is a "nothing found" case or
4259  // a "not a template" case. FIXME: Refactor isTemplateName so we don't
4260  // need to do this.
4261  DeclarationNameInfo DNI = GetNameFromUnqualifiedId(Name);
4262  LookupResult R(*this, DNI.getName(), Name.getBeginLoc(),
4263  LookupOrdinaryName);
4264  bool MOUS;
4265  if (!LookupTemplateName(R, S, SS, ObjectType.get(), EnteringContext,
4266  MOUS, TemplateKWLoc))
4267  Diag(Name.getBeginLoc(), diag::err_no_member)
4268  << DNI.getName() << LookupCtx << SS.getRange();
4269  return TNK_Non_template;
4270  } else {
4271  // We found something; return it.
4272  auto *LookupRD = dyn_cast<CXXRecordDecl>(LookupCtx);
4273  if (!AllowInjectedClassName && SS.isSet() && LookupRD &&
4275  Name.Identifier && LookupRD->getIdentifier() == Name.Identifier) {
4276  // C++14 [class.qual]p2:
4277  // In a lookup in which function names are not ignored and the
4278  // nested-name-specifier nominates a class C, if the name specified
4279  // [...] is the injected-class-name of C, [...] the name is instead
4280  // considered to name the constructor
4281  //
4282  // We don't get here if naming the constructor would be valid, so we
4283  // just reject immediately and recover by treating the
4284  // injected-class-name as naming the template.
4285  Diag(Name.getBeginLoc(),
4286  diag::ext_out_of_line_qualified_id_type_names_constructor)
4287  << Name.Identifier
4288  << 0 /*injected-class-name used as template name*/
4289  << 1 /*'template' keyword was used*/;
4290  }
4291  return TNK;
4292  }
4293  }
4294 
4295  NestedNameSpecifier *Qualifier = SS.getScopeRep();
4296 
4297  switch (Name.getKind()) {
4299  Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
4300  Name.Identifier));
4302 
4304  Result = TemplateTy::make(Context.getDependentTemplateName(Qualifier,
4306  return TNK_Function_template;
4307 
4309  llvm_unreachable("literal operator id cannot have a dependent scope");
4310 
4311  default:
4312  break;
4313  }
4314 
4315  Diag(Name.getBeginLoc(), diag::err_template_kw_refers_to_non_template)
4316  << GetNameFromUnqualifiedId(Name).getName() << Name.getSourceRange()
4317  << TemplateKWLoc;
4318  return TNK_Non_template;
4319 }
4320 
4322  TemplateArgumentLoc &AL,
4323  SmallVectorImpl<TemplateArgument> &Converted) {
4324  const TemplateArgument &Arg = AL.getArgument();
4325  QualType ArgType;
4326  TypeSourceInfo *TSI = nullptr;
4327 
4328  // Check template type parameter.
4329  switch(Arg.getKind()) {
4331  // C++ [temp.arg.type]p1:
4332  // A template-argument for a template-parameter which is a
4333  // type shall be a type-id.
4334  ArgType = Arg.getAsType();
4335  TSI = AL.getTypeSourceInfo();
4336  break;
4339  // We have a template type parameter but the template argument
4340  // is a template without any arguments.
4341  SourceRange SR = AL.getSourceRange();
4343  diagnoseMissingTemplateArguments(Name, SR.getEnd());
4344  return true;
4345  }
4347  // We have a template type parameter but the template argument is an
4348  // expression; see if maybe it is missing the "typename" keyword.
4349  CXXScopeSpec SS;
4350  DeclarationNameInfo NameInfo;
4351 
4352  if (DeclRefExpr *ArgExpr = dyn_cast<DeclRefExpr>(Arg.getAsExpr())) {
4353  SS.Adopt(ArgExpr->getQualifierLoc());
4354  NameInfo = ArgExpr->getNameInfo();
4355  } else if (DependentScopeDeclRefExpr *ArgExpr =
4356  dyn_cast<DependentScopeDeclRefExpr>(Arg.getAsExpr())) {
4357  SS.Adopt(ArgExpr->getQualifierLoc());
4358  NameInfo = ArgExpr->getNameInfo();
4359  } else if (CXXDependentScopeMemberExpr *ArgExpr =
4360  dyn_cast<CXXDependentScopeMemberExpr>(Arg.getAsExpr())) {
4361  if (ArgExpr->isImplicitAccess()) {
4362  SS.Adopt(ArgExpr->getQualifierLoc());
4363  NameInfo = ArgExpr->getMemberNameInfo();
4364  }
4365  }
4366 
4367  if (auto *II = NameInfo.getName().getAsIdentifierInfo()) {
4368  LookupResult Result(*this, NameInfo, LookupOrdinaryName);
4369  LookupParsedName(Result, CurScope, &SS);
4370 
4371  if (Result.getAsSingle<TypeDecl>() ||
4372  Result.getResultKind() ==
4374  // Suggest that the user add 'typename' before the NNS.
4375  SourceLocation Loc = AL.getSourceRange().getBegin();
4376  Diag(Loc, getLangOpts().MSVCCompat
4377  ? diag::ext_ms_template_type_arg_missing_typename
4378  : diag::err_template_arg_must_be_type_suggest)
4379  << FixItHint::CreateInsertion(Loc, "typename ");
4380  Diag(Param->getLocation(), diag::note_template_param_here);
4381 
4382  // Recover by synthesizing a type using the location information that we
4383  // already have.
4384  ArgType =
4385  Context.getDependentNameType(ETK_Typename, SS.getScopeRep(), II);
4386  TypeLocBuilder TLB;
4387  DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(ArgType);
4388  TL.setElaboratedKeywordLoc(SourceLocation(/*synthesized*/));
4389  TL.setQualifierLoc(SS.getWithLocInContext(Context));
4390  TL.setNameLoc(NameInfo.getLoc());
4391  TSI = TLB.getTypeSourceInfo(Context, ArgType);
4392 
4393  // Overwrite our input TemplateArgumentLoc so that we can recover
4394  // properly.
4395  AL = TemplateArgumentLoc(TemplateArgument(ArgType),
4397 
4398  break;
4399  }
4400  }
4401  // fallthrough
4402  LLVM_FALLTHROUGH;
4403  }
4404  default: {
4405  // We have a template type parameter but the template argument
4406  // is not a type.
4407  SourceRange SR = AL.getSourceRange();
4408  Diag(SR.getBegin(), diag::err_template_arg_must_be_type) << SR;
4409  Diag(Param->getLocation(), diag::note_template_param_here);
4410 
4411  return true;
4412  }
4413  }
4414 
4415  if (CheckTemplateArgument(Param, TSI))
4416  return true;
4417 
4418  // Add the converted template type argument.
4419  ArgType = Context.getCanonicalType(ArgType);
4420 
4421  // Objective-C ARC:
4422  // If an explicitly-specified template argument type is a lifetime type
4423  // with no lifetime qualifier, the __strong lifetime qualifier is inferred.
4424  if (getLangOpts().ObjCAutoRefCount &&
4425  ArgType->isObjCLifetimeType() &&
4426  !ArgType.getObjCLifetime()) {
4427  Qualifiers Qs;
4429  ArgType = Context.getQualifiedType(ArgType, Qs);
4430  }
4431 
4432  Converted.push_back(TemplateArgument(ArgType));
4433  return false;
4434 }
4435 
4436 /// Substitute template arguments into the default template argument for
4437 /// the given template type parameter.
4438 ///
4439 /// \param SemaRef the semantic analysis object for which we are performing
4440 /// the substitution.
4441 ///
4442 /// \param Template the template that we are synthesizing template arguments
4443 /// for.
4444 ///
4445 /// \param TemplateLoc the location of the template name that started the
4446 /// template-id we are checking.
4447 ///
4448 /// \param RAngleLoc the location of the right angle bracket ('>') that
4449 /// terminates the template-id.
4450 ///
4451 /// \param Param the template template parameter whose default we are
4452 /// substituting into.
4453 ///
4454 /// \param Converted the list of template arguments provided for template
4455 /// parameters that precede \p Param in the template parameter list.
4456 /// \returns the substituted template argument, or NULL if an error occurred.
4457 static TypeSourceInfo *
4459  TemplateDecl *Template,
4460  SourceLocation TemplateLoc,
4461  SourceLocation RAngleLoc,
4462  TemplateTypeParmDecl *Param,
4463  SmallVectorImpl<TemplateArgument> &Converted) {
4464  TypeSourceInfo *ArgType = Param->getDefaultArgumentInfo();
4465 
4466  // If the argument type is dependent, instantiate it now based
4467  // on the previously-computed template arguments.
4468  if (ArgType->getType()->isInstantiationDependentType()) {
4469  Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
4470  Param, Template, Converted,
4471  SourceRange(TemplateLoc, RAngleLoc));
4472  if (Inst.isInvalid())
4473  return nullptr;
4474 
4475  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
4476 
4477  // Only substitute for the innermost template argument list.
4478  MultiLevelTemplateArgumentList TemplateArgLists;
4479  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
4480  for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
4481  TemplateArgLists.addOuterTemplateArguments(None);
4482 
4483  Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
4484  ArgType =
4485  SemaRef.SubstType(ArgType, TemplateArgLists,
4486  Param->getDefaultArgumentLoc(), Param->getDeclName());
4487  }
4488 
4489  return ArgType;
4490 }
4491 
4492 /// Substitute template arguments into the default template argument for
4493 /// the given non-type template parameter.
4494 ///
4495 /// \param SemaRef the semantic analysis object for which we are performing
4496 /// the substitution.
4497 ///
4498 /// \param Template the template that we are synthesizing template arguments
4499 /// for.
4500 ///
4501 /// \param TemplateLoc the location of the template name that started the
4502 /// template-id we are checking.
4503 ///
4504 /// \param RAngleLoc the location of the right angle bracket ('>') that
4505 /// terminates the template-id.
4506 ///
4507 /// \param Param the non-type template parameter whose default we are
4508 /// substituting into.
4509 ///
4510 /// \param Converted the list of template arguments provided for template
4511 /// parameters that precede \p Param in the template parameter list.
4512 ///
4513 /// \returns the substituted template argument, or NULL if an error occurred.
4514 static ExprResult
4516  TemplateDecl *Template,
4517  SourceLocation TemplateLoc,
4518  SourceLocation RAngleLoc,
4519  NonTypeTemplateParmDecl *Param,
4520  SmallVectorImpl<TemplateArgument> &Converted) {
4521  Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
4522  Param, Template, Converted,
4523  SourceRange(TemplateLoc, RAngleLoc));
4524  if (Inst.isInvalid())
4525  return ExprError();
4526 
4527  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
4528 
4529  // Only substitute for the innermost template argument list.
4530  MultiLevelTemplateArgumentList TemplateArgLists;
4531  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
4532  for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
4533  TemplateArgLists.addOuterTemplateArguments(None);
4534 
4535  EnterExpressionEvaluationContext ConstantEvaluated(
4537  return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists);
4538 }
4539 
4540 /// Substitute template arguments into the default template argument for
4541 /// the given template template parameter.
4542 ///
4543 /// \param SemaRef the semantic analysis object for which we are performing
4544 /// the substitution.
4545 ///
4546 /// \param Template the template that we are synthesizing template arguments
4547 /// for.
4548 ///
4549 /// \param TemplateLoc the location of the template name that started the
4550 /// template-id we are checking.
4551 ///
4552 /// \param RAngleLoc the location of the right angle bracket ('>') that
4553 /// terminates the template-id.
4554 ///
4555 /// \param Param the template template parameter whose default we are
4556 /// substituting into.
4557 ///
4558 /// \param Converted the list of template arguments provided for template
4559 /// parameters that precede \p Param in the template parameter list.
4560 ///
4561 /// \param QualifierLoc Will be set to the nested-name-specifier (with
4562 /// source-location information) that precedes the template name.
4563 ///
4564 /// \returns the substituted template argument, or NULL if an error occurred.
4565 static TemplateName
4567  TemplateDecl *Template,
4568  SourceLocation TemplateLoc,
4569  SourceLocation RAngleLoc,
4570  TemplateTemplateParmDecl *Param,
4572  NestedNameSpecifierLoc &QualifierLoc) {
4574  SemaRef, TemplateLoc, TemplateParameter(Param), Template, Converted,
4575  SourceRange(TemplateLoc, RAngleLoc));
4576  if (Inst.isInvalid())
4577  return TemplateName();
4578 
4579  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
4580 
4581  // Only substitute for the innermost template argument list.
4582  MultiLevelTemplateArgumentList TemplateArgLists;
4583  TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
4584  for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
4585  TemplateArgLists.addOuterTemplateArguments(None);
4586 
4587  Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
4588  // Substitute into the nested-name-specifier first,
4589  QualifierLoc = Param->getDefaultArgument().getTemplateQualifierLoc();
4590  if (QualifierLoc) {
4591  QualifierLoc =
4592  SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgLists);
4593  if (!QualifierLoc)
4594  return TemplateName();
4595  }
4596 
4597  return SemaRef.SubstTemplateName(
4598  QualifierLoc,
4601  TemplateArgLists);
4602 }
4603 
4604 /// If the given template parameter has a default template
4605 /// argument, substitute into that default template argument and
4606 /// return the corresponding template argument.
4609  SourceLocation TemplateLoc,
4610  SourceLocation RAngleLoc,
4611  Decl *Param,
4613  &Converted,
4614  bool &HasDefaultArg) {
4615  HasDefaultArg = false;
4616 
4617  if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) {
4618  if (!hasVisibleDefaultArgument(TypeParm))
4619  return TemplateArgumentLoc();
4620 
4621  HasDefaultArg = true;
4622  TypeSourceInfo *DI = SubstDefaultTemplateArgument(*this, Template,
4623  TemplateLoc,
4624  RAngleLoc,
4625  TypeParm,
4626  Converted);
4627  if (DI)
4628  return TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
4629 
4630  return TemplateArgumentLoc();
4631  }
4632 
4633  if (NonTypeTemplateParmDecl *NonTypeParm
4634  = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4635  if (!hasVisibleDefaultArgument(NonTypeParm))
4636  return TemplateArgumentLoc();
4637 
4638  HasDefaultArg = true;
4639  ExprResult Arg = SubstDefaultTemplateArgument(*this, Template,
4640  TemplateLoc,
4641  RAngleLoc,
4642  NonTypeParm,
4643  Converted);
4644  if (Arg.isInvalid())
4645  return TemplateArgumentLoc();
4646 
4647  Expr *ArgE = Arg.getAs<Expr>();
4648  return TemplateArgumentLoc(TemplateArgument(ArgE), ArgE);
4649  }
4650 
4651  TemplateTemplateParmDecl *TempTempParm
4652  = cast<TemplateTemplateParmDecl>(Param);
4653  if (!hasVisibleDefaultArgument(TempTempParm))
4654  return TemplateArgumentLoc();
4655 
4656  HasDefaultArg = true;
4657  NestedNameSpecifierLoc QualifierLoc;
4658  TemplateName TName = SubstDefaultTemplateArgument(*this, Template,
4659  TemplateLoc,
4660  RAngleLoc,
4661  TempTempParm,
4662  Converted,
4663  QualifierLoc);
4664  if (TName.isNull())
4665  return TemplateArgumentLoc();
4666 
4667  return TemplateArgumentLoc(TemplateArgument(TName),
4668  TempTempParm->getDefaultArgument().getTemplateQualifierLoc(),
4669  TempTempParm->getDefaultArgument().getTemplateNameLoc());
4670 }
4671 
4672 /// Convert a template-argument that we parsed as a type into a template, if
4673 /// possible. C++ permits injected-class-names to perform dual service as
4674 /// template template arguments and as template type arguments.
4676  // Extract and step over any surrounding nested-name-specifier.
4677  NestedNameSpecifierLoc QualLoc;
4678  if (auto ETLoc = TLoc.getAs<ElaboratedTypeLoc>()) {
4679  if (ETLoc.getTypePtr()->getKeyword() != ETK_None)
4680  return TemplateArgumentLoc();
4681 
4682  QualLoc = ETLoc.getQualifierLoc();
4683  TLoc = ETLoc.getNamedTypeLoc();
4684  }
4685 
4686  // If this type was written as an injected-class-name, it can be used as a
4687  // template template argument.
4688  if (auto InjLoc = TLoc.getAs<InjectedClassNameTypeLoc>())
4689  return TemplateArgumentLoc(InjLoc.getTypePtr()->getTemplateName(),
4690  QualLoc, InjLoc.getNameLoc());
4691 
4692  // If this type was written as an injected-class-name, it may have been
4693  // converted to a RecordType during instantiation. If the RecordType is
4694  // *not* wrapped in a TemplateSpecializationType and denotes a class
4695  // template specialization, it must have come from an injected-class-name.
4696  if (auto RecLoc = TLoc.getAs<RecordTypeLoc>())
4697  if (auto *CTSD =
4698  dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))
4699  return TemplateArgumentLoc(TemplateName(CTSD->getSpecializedTemplate()),
4700  QualLoc, RecLoc.getNameLoc());
4701 
4702  return TemplateArgumentLoc();
4703 }
4704 
4705 /// Check that the given template argument corresponds to the given
4706 /// template parameter.
4707 ///
4708 /// \param Param The template parameter against which the argument will be
4709 /// checked.
4710 ///
4711 /// \param Arg The template argument, which may be updated due to conversions.
4712 ///
4713 /// \param Template The template in which the template argument resides.
4714 ///
4715 /// \param TemplateLoc The location of the template name for the template
4716 /// whose argument list we're matching.
4717 ///
4718 /// \param RAngleLoc The location of the right angle bracket ('>') that closes
4719 /// the template argument list.
4720 ///
4721 /// \param ArgumentPackIndex The index into the argument pack where this
4722 /// argument will be placed. Only valid if the parameter is a parameter pack.
4723 ///
4724 /// \param Converted The checked, converted argument will be added to the
4725 /// end of this small vector.
4726 ///
4727 /// \param CTAK Describes how we arrived at this particular template argument:
4728 /// explicitly written, deduced, etc.
4729 ///
4730 /// \returns true on error, false otherwise.
4732  TemplateArgumentLoc &Arg,
4733  NamedDecl *Template,
4734  SourceLocation TemplateLoc,
4735  SourceLocation RAngleLoc,
4736  unsigned ArgumentPackIndex,
4739  // Check template type parameters.
4740  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
4741  return CheckTemplateTypeArgument(TTP, Arg, Converted);
4742 
4743  // Check non-type template parameters.
4744  if (NonTypeTemplateParmDecl *NTTP =dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4745  // Do substitution on the type of the non-type template parameter
4746  // with the template arguments we've seen thus far. But if the
4747  // template has a dependent context then we cannot substitute yet.
4748  QualType NTTPType = NTTP->getType();
4749  if (NTTP->isParameterPack() && NTTP->isExpandedParameterPack())
4750  NTTPType = NTTP->getExpansionType(ArgumentPackIndex);
4751 
4752  // FIXME: Do we need to substitute into parameters here if they're
4753  // instantiation-dependent but not dependent?
4754  if (NTTPType->isDependentType() &&
4755  !isa<TemplateTemplateParmDecl>(Template) &&
4756  !Template->getDeclContext()->isDependentContext()) {
4757  // Do substitution on the type of the non-type template parameter.
4758  InstantiatingTemplate Inst(*this, TemplateLoc, Template,
4759  NTTP, Converted,
4760  SourceRange(TemplateLoc, RAngleLoc));
4761  if (Inst.isInvalid())
4762  return true;
4763 
4765  Converted);
4766  NTTPType = SubstType(NTTPType,
4767  MultiLevelTemplateArgumentList(TemplateArgs),
4768  NTTP->getLocation(),
4769  NTTP->getDeclName());
4770  // If that worked, check the non-type template parameter type
4771  // for validity.
4772  if (!NTTPType.isNull())
4773  NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
4774  NTTP->getLocation());
4775  if (NTTPType.isNull())
4776  return true;
4777  }
4778 
4779  switch (Arg.getArgument().getKind()) {
4781  llvm_unreachable("Should never see a NULL template argument here");
4782 
4784  TemplateArgument Result;
4785  unsigned CurSFINAEErrors = NumSFINAEErrors;
4786  ExprResult Res =
4787  CheckTemplateArgument(NTTP, NTTPType, Arg.getArgument().getAsExpr(),
4788  Result, CTAK);
4789  if (Res.isInvalid())
4790  return true;
4791  // If the current template argument causes an error, give up now.
4792  if (CurSFINAEErrors < NumSFINAEErrors)
4793  return true;
4794 
4795  // If the resulting expression is new, then use it in place of the
4796  // old expression in the template argument.
4797  if (Res.get() != Arg.getArgument().getAsExpr()) {
4798  TemplateArgument TA(Res.get());
4799  Arg = TemplateArgumentLoc(TA, Res.get());
4800  }
4801 
4802  Converted.push_back(Result);
4803  break;
4804  }
4805 
4809  // We've already checked this template argument, so just copy
4810  // it to the list of converted arguments.
4811  Converted.push_back(Arg.getArgument());
4812  break;
4813 
4816  // We were given a template template argument. It may not be ill-formed;
4817  // see below.
4818  if (DependentTemplateName *DTN
4821  // We have a template argument such as \c T::template X, which we
4822  // parsed as a template template argument. However, since we now
4823  // know that we need a non-type template argument, convert this
4824  // template name into an expression.
4825 
4826  DeclarationNameInfo NameInfo(DTN->getIdentifier(),
4827  Arg.getTemplateNameLoc());
4828 
4829  CXXScopeSpec SS;
4830  SS.Adopt(Arg.getTemplateQualifierLoc());
4831  // FIXME: the template-template arg was a DependentTemplateName,
4832  // so it was provided with a template keyword. However, its source
4833  // location is not stored in the template argument structure.
4834  SourceLocation TemplateKWLoc;
4836  Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
4837  nullptr);
4838 
4839  // If we parsed the template argument as a pack expansion, create a
4840  // pack expansion expression.
4842  E = ActOnPackExpansion(E.get(), Arg.getTemplateEllipsisLoc());
4843  if (E.isInvalid())
4844  return true;
4845  }
4846 
4847  TemplateArgument Result;
4848  E = CheckTemplateArgument(NTTP, NTTPType, E.get(), Result);
4849  if (E.isInvalid())
4850  return true;
4851 
4852  Converted.push_back(Result);
4853  break;
4854  }
4855 
4856  // We have a template argument that actually does refer to a class
4857  // template, alias template, or template template parameter, and
4858  // therefore cannot be a non-type template argument.
4859  Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr)
4860  << Arg.getSourceRange();
4861 
4862  Diag(Param->getLocation(), diag::note_template_param_here);
4863  return true;
4864 
4865  case TemplateArgument::Type: {
4866  // We have a non-type template parameter but the template
4867  // argument is a type.
4868 
4869  // C++ [temp.arg]p2:
4870  // In a template-argument, an ambiguity between a type-id and
4871  // an expression is resolved to a type-id, regardless of the
4872  // form of the corresponding template-parameter.
4873  //
4874  // We warn specifically about this case, since it can be rather
4875  // confusing for users.
4876  QualType T = Arg.getArgument().getAsType();
4877  SourceRange SR = Arg.getSourceRange();
4878  if (T->isFunctionType())
4879  Diag(SR.getBegin(), diag::err_template_arg_nontype_ambig) << SR << T;
4880  else
4881  Diag(SR.getBegin(), diag::err_template_arg_must_be_expr) << SR;
4882  Diag(Param->getLocation(), diag::note_template_param_here);
4883  return true;
4884  }
4885 
4887  llvm_unreachable("Caller must expand template argument packs");
4888  }
4889 
4890  return false;
4891  }
4892 
4893 
4894  // Check template template parameters.
4895  TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(Param);
4896 
4897  TemplateParameterList *Params = TempParm->getTemplateParameters();
4898  if (TempParm->isExpandedParameterPack())
4899  Params = TempParm->getExpansionTemplateParameters(ArgumentPackIndex);
4900 
4901  // Substitute into the template parameter list of the template
4902  // template parameter, since previously-supplied template arguments
4903  // may appear within the template template parameter.
4904  //
4905  // FIXME: Skip this if the parameters aren't instantiation-dependent.
4906  {
4907  // Set up a template instantiation context.
4909  InstantiatingTemplate Inst(*this, TemplateLoc, Template,
4910  TempParm, Converted,
4911  SourceRange(TemplateLoc, RAngleLoc));
4912  if (Inst.isInvalid())
4913  return true;
4914 
4915  TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
4916  Params = SubstTemplateParams(Params, CurContext,
4917  MultiLevelTemplateArgumentList(TemplateArgs));
4918  if (!Params)
4919  return true;
4920  }
4921 
4922  // C++1z [temp.local]p1: (DR1004)
4923  // When [the injected-class-name] is used [...] as a template-argument for
4924  // a template template-parameter [...] it refers to the class template
4925  // itself.
4926  if (Arg.getArgument().getKind() == TemplateArgument::Type) {
4928  Arg.getTypeSourceInfo()->getTypeLoc());
4929  if (!ConvertedArg.getArgument().isNull())
4930  Arg = ConvertedArg;
4931  }
4932 
4933  switch (Arg.getArgument().getKind()) {
4935  llvm_unreachable("Should never see a NULL template argument here");
4936 
4939  if (CheckTemplateTemplateArgument(Params, Arg))
4940  return true;
4941 
4942  Converted.push_back(Arg.getArgument());
4943  break;
4944 
4947  // We have a template template parameter but the template
4948  // argument does not refer to a template.
4949  Diag(Arg.getLocation(), diag::err_template_arg_must_be_template)
4950  << getLangOpts().CPlusPlus11;
4951  return true;
4952 
4954  llvm_unreachable("Declaration argument with template template parameter");
4956  llvm_unreachable("Integral argument with template template parameter");
4958  llvm_unreachable("Null pointer argument with template template parameter");
4959 
4961  llvm_unreachable("Caller must expand template argument packs");
4962  }
4963 
4964  return false;
4965 }
4966 
4967 /// Check whether the template parameter is a pack expansion, and if so,
4968 /// determine the number of parameters produced by that expansion. For instance:
4969 ///
4970 /// \code
4971 /// template<typename ...Ts> struct A {
4972 /// template<Ts ...NTs, template<Ts> class ...TTs, typename ...Us> struct B;
4973 /// };
4974 /// \endcode
4975 ///
4976 /// In \c A<int,int>::B, \c NTs and \c TTs have expanded pack size 2, and \c Us
4977 /// is not a pack expansion, so returns an empty Optional.
4979  if (NonTypeTemplateParmDecl *NTTP
4980  = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4981  if (NTTP->isExpandedParameterPack())
4982  return NTTP->getNumExpansionTypes();
4983  }
4984 
4985  if (TemplateTemplateParmDecl *TTP
4986  = dyn_cast<TemplateTemplateParmDecl>(Param)) {
4987  if (TTP->isExpandedParameterPack())
4988  return TTP->getNumExpansionTemplateParameters();
4989  }
4990 
4991  return None;
4992 }
4993 
4994 /// Diagnose a missing template argument.
4995 template<typename TemplateParmDecl>
4997  TemplateDecl *TD,
4998  const TemplateParmDecl *D,
4999  TemplateArgumentListInfo &Args) {
5000  // Dig out the most recent declaration of the template parameter; there may be
5001  // declarations of the template that are more recent than TD.
5002  D = cast<TemplateParmDecl>(cast<TemplateDecl>(TD->getMostRecentDecl())
5003  ->getTemplateParameters()
5004  ->getParam(D->getIndex()));
5005 
5006  // If there's a default argument that's not visible, diagnose that we're
5007  // missing a module import.
5009  if (D->hasDefaultArgument() && !S.hasVisibleDefaultArgument(D, &Modules)) {
5010  S.diagnoseMissingImport(Loc, cast<NamedDecl>(TD),
5011  D->getDefaultArgumentLoc(), Modules,
5013  /*Recover*/true);
5014  return true;
5015  }
5016 
5017  // FIXME: If there's a more recent default argument that *is* visible,
5018  // diagnose that it was declared too late.
5019 
5021 
5022  S.Diag(Loc, diag::err_template_arg_list_different_arity)
5023  << /*not enough args*/0
5025  << TD;
5026  S.Diag(TD->getLocation(), diag::note_template_decl_here)
5027  << Params->getSourceRange();
5028  return true;
5029 }
5030 
5031 /// Check that the given template argument list is well-formed
5032 /// for specializing the given template.
5034  TemplateDecl *Template, SourceLocation TemplateLoc,
5035  TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs,
5037  bool UpdateArgsWithConversions) {
5038  // Make a copy of the template arguments for processing. Only make the
5039  // changes at the end when successful in matching the arguments to the
5040  // template.
5041  TemplateArgumentListInfo NewArgs = TemplateArgs;
5042 
5043  // Make sure we get the template parameter list from the most
5044  // recentdeclaration, since that is the only one that has is guaranteed to
5045  // have all the default template argument information.
5046  TemplateParameterList *Params =
5047  cast<TemplateDecl>(Template->getMostRecentDecl())
5048  ->getTemplateParameters();
5049 
5050  SourceLocation RAngleLoc = NewArgs.getRAngleLoc();
5051 
5052  // C++ [temp.arg]p1:
5053  // [...] The type and form of each template-argument specified in
5054  // a template-id shall match the type and form specified for the
5055  // corresponding parameter declared by the template in its
5056  // template-parameter-list.
5057  bool isTemplateTemplateParameter = isa<TemplateTemplateParmDecl>(Template);
5058  SmallVector<TemplateArgument, 2> ArgumentPack;
5059  unsigned ArgIdx = 0, NumArgs = NewArgs.size();
5060  LocalInstantiationScope InstScope(*this, true);
5061  for (TemplateParameterList::iterator Param = Params->begin(),
5062  ParamEnd = Params->end();
5063  Param != ParamEnd; /* increment in loop */) {
5064  // If we have an expanded parameter pack, make sure we don't have too
5065  // many arguments.
5066  if (Optional<unsigned> Expansions = getExpandedPackSize(*Param)) {
5067  if (*Expansions == ArgumentPack.size()) {
5068  // We're done with this parameter pack. Pack up its arguments and add
5069  // them to the list.
5070  Converted.push_back(
5071  TemplateArgument::CreatePackCopy(Context, ArgumentPack));
5072  ArgumentPack.clear();
5073 
5074  // This argument is assigned to the next parameter.
5075  ++Param;
5076  continue;
5077  } else if (ArgIdx == NumArgs && !PartialTemplateArgs) {
5078  // Not enough arguments for this parameter pack.
5079  Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5080  << /*not enough args*/0
5081  << (int)getTemplateNameKindForDiagnostics(TemplateName(Template))
5082  << Template;
5083  Diag(Template->getLocation(), diag::note_template_decl_here)
5084  << Params->getSourceRange();
5085  return true;
5086  }
5087  }
5088 
5089  if (ArgIdx < NumArgs) {
5090  // Check the template argument we were given.
5091  if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template,
5092  TemplateLoc, RAngleLoc,
5093  ArgumentPack.size(), Converted))
5094  return true;
5095 
5096  bool PackExpansionIntoNonPack =
5097  NewArgs[ArgIdx].getArgument().isPackExpansion() &&
5098  (!(*Param)->isTemplateParameterPack() || getExpandedPackSize(*Param));
5099  if (PackExpansionIntoNonPack && isa<TypeAliasTemplateDecl>(Template)) {
5100  // Core issue 1430: we have a pack expansion as an argument to an
5101  // alias template, and it's not part of a parameter pack. This
5102  // can't be canonicalized, so reject it now.
5103  Diag(NewArgs[ArgIdx].getLocation(),
5104  diag::err_alias_template_expansion_into_fixed_list)
5105  << NewArgs[ArgIdx].getSourceRange();
5106  Diag((*Param)->getLocation(), diag::note_template_param_here);
5107  return true;
5108  }
5109 
5110  // We're now done with this argument.
5111  ++ArgIdx;
5112 
5113  if ((*Param)->isTemplateParameterPack()) {
5114  // The template parameter was a template parameter pack, so take the
5115  // deduced argument and place it on the argument pack. Note that we
5116  // stay on the same template parameter so that we can deduce more
5117  // arguments.
5118  ArgumentPack.push_back(Converted.pop_back_val());
5119  } else {
5120  // Move to the next template parameter.
5121  ++Param;
5122  }
5123 
5124  // If we just saw a pack expansion into a non-pack, then directly convert
5125  // the remaining arguments, because we don't know what parameters they'll
5126  // match up with.
5127  if (PackExpansionIntoNonPack) {
5128  if (!ArgumentPack.empty()) {
5129  // If we were part way through filling in an expanded parameter pack,
5130  // fall back to just producing individual arguments.
5131  Converted.insert(Converted.end(),
5132  ArgumentPack.begin(), ArgumentPack.end());
5133  ArgumentPack.clear();
5134  }
5135 
5136  while (ArgIdx < NumArgs) {
5137  Converted.push_back(NewArgs[ArgIdx].getArgument());
5138  ++ArgIdx;
5139  }
5140 
5141  return false;
5142  }
5143 
5144  continue;
5145  }
5146 
5147  // If we're checking a partial template argument list, we're done.
5148  if (PartialTemplateArgs) {
5149  if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
5150  Converted.push_back(
5151  TemplateArgument::CreatePackCopy(Context, ArgumentPack));
5152 
5153  return false;
5154  }
5155 
5156  // If we have a template parameter pack with no more corresponding
5157  // arguments, just break out now and we'll fill in the argument pack below.
5158  if ((*Param)->isTemplateParameterPack()) {
5159  assert(!getExpandedPackSize(*Param) &&
5160  "Should have dealt with this already");
5161 
5162  // A non-expanded parameter pack before the end of the parameter list
5163  // only occurs for an ill-formed template parameter list, unless we've
5164  // got a partial argument list for a function template, so just bail out.
5165  if (Param + 1 != ParamEnd)
5166  return true;
5167 
5168  Converted.push_back(
5169  TemplateArgument::CreatePackCopy(Context, ArgumentPack));
5170  ArgumentPack.clear();
5171 
5172  ++Param;
5173  continue;
5174  }
5175 
5176  // Check whether we have a default argument.
5177  TemplateArgumentLoc Arg;
5178 
5179  // Retrieve the default template argument from the template
5180  // parameter. For each kind of template parameter, we substitute the
5181  // template arguments provided thus far and any "outer" template arguments
5182  // (when the template parameter was part of a nested template) into
5183  // the default argument.
5184  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
5185  if (!hasVisibleDefaultArgument(TTP))
5186  return diagnoseMissingArgument(*this, TemplateLoc, Template, TTP,
5187  NewArgs);
5188 
5190  Template,
5191  TemplateLoc,
5192  RAngleLoc,
5193  TTP,
5194  Converted);
5195  if (!ArgType)
5196  return true;
5197 
5198  Arg = TemplateArgumentLoc(TemplateArgument(ArgType->getType()),
5199  ArgType);
5200  } else if (NonTypeTemplateParmDecl *NTTP
5201  = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
5202  if (!hasVisibleDefaultArgument(NTTP))
5203  return diagnoseMissingArgument(*this, TemplateLoc, Template, NTTP,
5204  NewArgs);
5205 
5206  ExprResult E = SubstDefaultTemplateArgument(*this, Template,
5207  TemplateLoc,
5208  RAngleLoc,
5209  NTTP,
5210  Converted);
5211  if (E.isInvalid())
5212  return true;
5213 
5214  Expr *Ex = E.getAs<Expr>();
5215  Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex);
5216  } else {
5217  TemplateTemplateParmDecl *TempParm
5218  = cast<TemplateTemplateParmDecl>(*Param);
5219 
5220  if (!hasVisibleDefaultArgument(TempParm))
5221  return diagnoseMissingArgument(*this, TemplateLoc, Template, TempParm,
5222  NewArgs);
5223 
5224  NestedNameSpecifierLoc QualifierLoc;
5225  TemplateName Name = SubstDefaultTemplateArgument(*this, Template,
5226  TemplateLoc,
5227  RAngleLoc,
5228  TempParm,
5229  Converted,
5230  QualifierLoc);
5231  if (Name.isNull())
5232  return true;
5233 
5234  Arg = TemplateArgumentLoc(TemplateArgument(Name), QualifierLoc,
5235  TempParm->getDefaultArgument().getTemplateNameLoc());
5236  }
5237 
5238  // Introduce an instantiation record that describes where we are using
5239  // the default template argument. We're not actually instantiating a
5240  // template here, we just create this object to put a note into the
5241  // context stack.
5242  InstantiatingTemplate Inst(*this, RAngleLoc, Template, *Param, Converted,
5243  SourceRange(TemplateLoc, RAngleLoc));
5244  if (Inst.isInvalid())
5245  return true;
5246 
5247  // Check the default template argument.
5248  if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc,
5249  RAngleLoc, 0, Converted))
5250  return true;
5251 
5252  // Core issue 150 (assumed resolution): if this is a template template
5253  // parameter, keep track of the default template arguments from the
5254  // template definition.
5255  if (isTemplateTemplateParameter)
5256  NewArgs.addArgument(Arg);
5257 
5258  // Move to the next template parameter and argument.
5259  ++Param;
5260  ++ArgIdx;
5261  }
5262 
5263  // If we're performing a partial argument substitution, allow any trailing
5264  // pack expansions; they might be empty. This can happen even if
5265  // PartialTemplateArgs is false (the list of arguments is complete but
5266  // still dependent).
5267  if (ArgIdx < NumArgs && CurrentInstantiationScope &&
5268  CurrentInstantiationScope->getPartiallySubstitutedPack()) {
5269  while (ArgIdx < NumArgs && NewArgs[ArgIdx].getArgument().isPackExpansion())
5270  Converted.push_back(NewArgs[ArgIdx++].getArgument());
5271  }
5272 
5273  // If we have any leftover arguments, then there were too many arguments.
5274  // Complain and fail.
5275  if (ArgIdx < NumArgs) {
5276  Diag(TemplateLoc, diag::err_template_arg_list_different_arity)
5277  << /*too many args*/1
5278  << (int)getTemplateNameKindForDiagnostics(TemplateName(Template))
5279  << Template
5280  << SourceRange(NewArgs[ArgIdx].getLocation(), NewArgs.getRAngleLoc());
5281  Diag(Template->getLocation(), diag::note_template_decl_here)
5282  << Params->getSourceRange();
5283  return true;
5284  }
5285 
5286  // No problems found with the new argument list, propagate changes back
5287  // to caller.
5288  if (UpdateArgsWithConversions)
5289  TemplateArgs = std::move(NewArgs);
5290 
5291  return false;
5292 }
5293 
5294 namespace {
5295  class UnnamedLocalNoLinkageFinder
5296  : public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
5297  {
5298  Sema &S;
5299  SourceRange SR;
5300 
5302 
5303  public:
5304  UnnamedLocalNoLinkageFinder(Sema &S, SourceRange SR) : S(S), SR(SR) { }
5305 
5306  bool Visit(QualType T) {
5307  return T.isNull() ? false : inherited::Visit(T.getTypePtr());
5308  }
5309 
5310 #define TYPE(Class, Parent) \
5311  bool Visit##Class##Type(const Class##Type *);
5312 #define ABSTRACT_TYPE(Class, Parent) \
5313  bool Visit##Class##Type(const Class##Type *) { return false; }
5314 #define NON_CANONICAL_TYPE(Class, Parent) \
5315  bool Visit##Class##Type(const Class##Type *) { return false; }
5316 #include "clang/AST/TypeNodes.def"
5317 
5318  bool VisitTagDecl(const TagDecl *Tag);
5319  bool VisitNestedNameSpecifier(NestedNameSpecifier *NNS);
5320  };
5321 } // end anonymous namespace
5322 
5323 bool UnnamedLocalNoLinkageFinder::VisitBuiltinType(const BuiltinType*) {
5324  return false;
5325 }
5326 
5327 bool UnnamedLocalNoLinkageFinder::VisitComplexType(const ComplexType* T) {
5328  return Visit(T->getElementType());
5329 }
5330 
5331 bool UnnamedLocalNoLinkageFinder::VisitPointerType(const PointerType* T) {
5332  return Visit(T->getPointeeType());
5333 }
5334 
5335 bool UnnamedLocalNoLinkageFinder::VisitBlockPointerType(
5336  const BlockPointerType* T) {
5337  return Visit(T->getPointeeType());
5338 }
5339 
5340 bool UnnamedLocalNoLinkageFinder::VisitLValueReferenceType(
5341  const LValueReferenceType* T) {
5342  return Visit(T->getPointeeType());
5343 }
5344 
5345 bool UnnamedLocalNoLinkageFinder::VisitRValueReferenceType(
5346  const RValueReferenceType* T) {
5347  return Visit(T->getPointeeType());
5348 }
5349 
5350 bool UnnamedLocalNoLinkageFinder::VisitMemberPointerType(
5351  const MemberPointerType* T) {
5352  return Visit(T->getPointeeType()) || Visit(QualType(T->getClass(), 0));
5353 }
5354 
5355 bool UnnamedLocalNoLinkageFinder::VisitConstantArrayType(
5356  const ConstantArrayType* T) {
5357  return Visit(T->getElementType());
5358 }
5359 
5360 bool UnnamedLocalNoLinkageFinder::VisitIncompleteArrayType(
5361  const IncompleteArrayType* T) {
5362  return Visit(T->getElementType());
5363 }
5364 
5365 bool UnnamedLocalNoLinkageFinder::VisitVariableArrayType(
5366  const VariableArrayType* T) {
5367  return Visit(T->getElementType());
5368 }
5369 
5370 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedArrayType(
5371  const DependentSizedArrayType* T) {
5372  return Visit(T->getElementType());
5373 }
5374 
5375 bool UnnamedLocalNoLinkageFinder::VisitDependentSizedExtVectorType(
5376  const DependentSizedExtVectorType* T) {
5377  return Visit(T->getElementType());
5378 }
5379 
5380 bool UnnamedLocalNoLinkageFinder::VisitDependentAddressSpaceType(
5381  const DependentAddressSpaceType *T) {
5382  return Visit(T->getPointeeType());
5383 }
5384 
5385 bool UnnamedLocalNoLinkageFinder::VisitVectorType(const VectorType* T) {
5386  return Visit(T->getElementType());
5387 }
5388 
5389 bool UnnamedLocalNoLinkageFinder::VisitDependentVectorType(
5390  const DependentVectorType *T) {
5391  return Visit(T->getElementType());
5392 }
5393 
5394 bool UnnamedLocalNoLinkageFinder::VisitExtVectorType(const ExtVectorType* T) {
5395  return Visit(T->getElementType());
5396 }
5397 
5398 bool UnnamedLocalNoLinkageFinder::VisitFunctionProtoType(
5399  const FunctionProtoType* T) {
5400  for (const auto &A : T->param_types()) {
5401  if (Visit(A))
5402  return true;
5403  }
5404 
5405  return Visit(T->getReturnType());
5406 }
5407 
5408 bool UnnamedLocalNoLinkageFinder::VisitFunctionNoProtoType(
5409  const FunctionNoProtoType* T) {
5410  return Visit(T->getReturnType());
5411 }
5412 
5413 bool UnnamedLocalNoLinkageFinder::VisitUnresolvedUsingType(
5414  const UnresolvedUsingType*) {
5415  return false;
5416 }
5417 
5418 bool UnnamedLocalNoLinkageFinder::VisitTypeOfExprType(const TypeOfExprType*) {
5419  return false;
5420 }
5421 
5422 bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(const TypeOfType* T) {
5423  return Visit(T->getUnderlyingType());
5424 }
5425 
5426 bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType*) {
5427  return false;
5428 }
5429 
5430 bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
5431  const UnaryTransformType*) {
5432  return false;
5433 }
5434 
5435 bool UnnamedLocalNoLinkageFinder::VisitAutoType(const AutoType *T) {
5436  return Visit(T->getDeducedType());
5437 }
5438 
5439 bool UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(
5441  return Visit(T->getDeducedType());
5442 }
5443 
5444 bool UnnamedLocalNoLinkageFinder::VisitRecordType(const RecordType* T) {
5445  return VisitTagDecl(T->getDecl());
5446 }
5447 
5448 bool UnnamedLocalNoLinkageFinder::VisitEnumType(const EnumType* T) {
5449  return VisitTagDecl(T->getDecl());
5450 }
5451 
5452 bool UnnamedLocalNoLinkageFinder::VisitTemplateTypeParmType(
5453  const TemplateTypeParmType*) {
5454  return false;
5455 }
5456 
5457 bool UnnamedLocalNoLinkageFinder::VisitSubstTemplateTypeParmPackType(
5459  return false;
5460 }
5461 
5462 bool UnnamedLocalNoLinkageFinder::VisitTemplateSpecializationType(
5463  const TemplateSpecializationType*) {
5464  return false;
5465 }
5466 
5467 bool UnnamedLocalNoLinkageFinder::VisitInjectedClassNameType(
5468  const InjectedClassNameType* T) {
5469  return VisitTagDecl(T->getDecl());
5470 }
5471 
5472 bool UnnamedLocalNoLinkageFinder::VisitDependentNameType(
5473  const DependentNameType* T) {
5474  return VisitNestedNameSpecifier(T->getQualifier());
5475 }
5476 
5477 bool UnnamedLocalNoLinkageFinder::VisitDependentTemplateSpecializationType(
5479  return VisitNestedNameSpecifier(T->getQualifier());
5480 }
5481 
5482 bool UnnamedLocalNoLinkageFinder::VisitPackExpansionType(
5483  const PackExpansionType* T) {
5484  return Visit(T->getPattern());
5485 }
5486 
5487 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectType(const ObjCObjectType *) {
5488  return false;
5489 }
5490 
5491 bool UnnamedLocalNoLinkageFinder::VisitObjCInterfaceType(
5492  const ObjCInterfaceType *) {
5493  return false;
5494 }
5495 
5496 bool UnnamedLocalNoLinkageFinder::VisitObjCObjectPointerType(
5497  const ObjCObjectPointerType *) {
5498  return false;
5499 }
5500 
5501 bool UnnamedLocalNoLinkageFinder::VisitAtomicType(const AtomicType* T) {
5502  return Visit(T->getValueType());
5503 }
5504 
5505 bool UnnamedLocalNoLinkageFinder::VisitPipeType(const PipeType* T) {
5506  return false;
5507 }
5508 
5509 bool UnnamedLocalNoLinkageFinder::VisitTagDecl(const TagDecl *Tag) {
5510  if (Tag->getDeclContext()->isFunctionOrMethod()) {
5511  S.Diag(SR.getBegin(),
5512  S.getLangOpts().CPlusPlus11 ?
5513  diag::warn_cxx98_compat_template_arg_local_type :
5514  diag::ext_template_arg_local_type)
5515  << S.Context.getTypeDeclType(Tag) << SR;
5516  return true;
5517  }
5518 
5519  if (!Tag->hasNameForLinkage()) {
5520  S.Diag(SR.getBegin(),
5521  S.getLangOpts().CPlusPlus11 ?
5522  diag::warn_cxx98_compat_template_arg_unnamed_type :
5523  diag::ext_template_arg_unnamed_type) << SR;
5524  S.Diag(Tag->getLocation(), diag::note_template_unnamed_type_here);
5525  return true;
5526  }
5527 
5528  return false;
5529 }
5530 
5531 bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier(
5532  NestedNameSpecifier *NNS) {
5533  if (NNS->getPrefix() && VisitNestedNameSpecifier(NNS->getPrefix()))
5534  return true;
5535 
5536  switch (NNS->getKind()) {
5542  return false;
5543 
5546  return Visit(QualType(NNS->getAsType(), 0));
5547  }
5548  llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
5549 }
5550 
5551 /// Check a template argument against its corresponding
5552 /// template type parameter.
5553 ///
5554 /// This routine implements the semantics of C++ [temp.arg.type]. It
5555 /// returns true if an error occurred, and false otherwise.
5557  TypeSourceInfo *ArgInfo) {
5558  assert(ArgInfo && "invalid TypeSourceInfo");
5559  QualType Arg = ArgInfo->getType();
5560  SourceRange SR = ArgInfo->getTypeLoc().getSourceRange();
5561 
5562  if (Arg->isVariablyModifiedType()) {
5563  return Diag(SR.getBegin(), diag::err_variably_modified_template_arg) << Arg;
5564  } else if (Context.hasSameUnqualifiedType(Arg, Context.OverloadTy)) {
5565  return Diag(SR.getBegin(), diag::err_template_arg_overload_type) << SR;
5566  }
5567 
5568  // C++03 [temp.arg.type]p2:
5569  // A local type, a type with no linkage, an unnamed type or a type
5570  // compounded from any of these types shall not be used as a
5571  // template-argument for a template type-parameter.
5572  //
5573  // C++11 allows these, and even in C++03 we allow them as an extension with
5574  // a warning.
5575  if (LangOpts.CPlusPlus11 || Arg->hasUnnamedOrLocalType()) {
5576  UnnamedLocalNoLinkageFinder Finder(*this, SR);
5577  (void)Finder.Visit(Context.getCanonicalType(Arg));
5578  }
5579 
5580  return false;
5581 }
5582 
5587 };
5588 
5589 /// Determine whether the given template argument is a null pointer
5590 /// value of the appropriate type.
5591 static NullPointerValueKind
5593  QualType ParamType, Expr *Arg,
5594  Decl *Entity = nullptr) {
5595  if (Arg->isValueDependent() || Arg->isTypeDependent())
5596  return NPV_NotNullPointer;
5597 
5598  // dllimport'd entities aren't constant but are available inside of template
5599  // arguments.
5600  if (Entity && Entity->hasAttr<DLLImportAttr>())
5601  return NPV_NotNullPointer;
5602 
5603  if (!S.isCompleteType(Arg->getExprLoc(), ParamType))
5604  llvm_unreachable(
5605  "Incomplete parameter type in isNullPointerValueTemplateArgument!");
5606 
5607  if (!S.getLangOpts().CPlusPlus11)
5608  return NPV_NotNullPointer;
5609 
5610  // Determine whether we have a constant expression.
5612  if (ArgRV.isInvalid())
5613  return NPV_Error;
5614  Arg = ArgRV.get();
5615 
5616  Expr::EvalResult EvalResult;
5618  EvalResult.Diag = &Notes;
5619  if (!Arg->EvaluateAsRValue(EvalResult, S.Context) ||
5620  EvalResult.HasSideEffects) {
5621  SourceLocation DiagLoc = Arg->getExprLoc();
5622 
5623  // If our only note is the usual "invalid subexpression" note, just point
5624  // the caret at its location rather than producing an essentially
5625  // redundant note.
5626  if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
5627  diag::note_invalid_subexpr_in_const_expr) {
5628  DiagLoc = Notes[0].first;
5629  Notes.clear();
5630  }
5631 
5632  S.Diag(DiagLoc, diag::err_template_arg_not_address_constant)
5633  << Arg->getType() << Arg->getSourceRange();
5634  for (unsigned I = 0, N = Notes.size(); I != N; ++I)
5635  S.Diag(Notes[I].first, Notes[I].second);
5636 
5637  S.Diag(Param->getLocation(), diag::note_template_param_here);
5638  return NPV_Error;
5639  }
5640 
5641  // C++11 [temp.arg.nontype]p1:
5642  // - an address constant expression of type std::nullptr_t
5643  if (Arg->getType()->isNullPtrType())
5644  return NPV_NullPointer;
5645 
5646  // - a constant expression that evaluates to a null pointer value (4.10); or
5647  // - a constant expression that evaluates to a null member pointer value
5648  // (4.11); or
5649  if ((EvalResult.Val.isLValue() && !EvalResult.Val.getLValueBase()) ||
5650  (EvalResult.Val.isMemberPointer() &&
5651  !EvalResult.Val.getMemberPointerDecl())) {
5652  // If our expression has an appropriate type, we've succeeded.
5653  bool ObjCLifetimeConversion;
5654  if (S.Context.hasSameUnqualifiedType(Arg->getType(), ParamType) ||
5655  S.IsQualificationConversion(Arg->getType(), ParamType, false,
5656  ObjCLifetimeConversion))
5657  return NPV_NullPointer;
5658 
5659  // The types didn't match, but we know we got a null pointer; complain,
5660  // then recover as if the types were correct.
5661  S.Diag(Arg->getExprLoc(), diag::err_template_arg_wrongtype_null_constant)
5662  << Arg->getType() << ParamType << Arg->getSourceRange();
5663  S.Diag(Param->getLocation(), diag::note_template_param_here);
5664  return NPV_NullPointer;
5665  }
5666 
5667  // If we don't have a null pointer value, but we do have a NULL pointer
5668  // constant, suggest a cast to the appropriate type.
5670  std::string Code = "static_cast<" + ParamType.getAsString() + ">(";
5671  S.Diag(Arg->getExprLoc(), diag::err_template_arg_untyped_null_constant)
5672  << ParamType << FixItHint::CreateInsertion(Arg->getBeginLoc(), Code)
5674  ")");
5675  S.Diag(Param->getLocation(), diag::note_template_param_here);
5676  return NPV_NullPointer;
5677  }
5678 
5679  // FIXME: If we ever want to support general, address-constant expressions
5680  // as non-type template arguments, we should return the ExprResult here to
5681  // be interpreted by the caller.
5682  return NPV_NotNullPointer;
5683 }
5684 
5685 /// Checks whether the given template argument is compatible with its
5686 /// template parameter.
5688  Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
5689  Expr *Arg, QualType ArgType) {
5690  bool ObjCLifetimeConversion;
5691  if (ParamType->isPointerType() &&
5692  !ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType() &&
5693  S.IsQualificationConversion(ArgType, ParamType, false,
5694  ObjCLifetimeConversion)) {
5695  // For pointer-to-object types, qualification conversions are
5696  // permitted.
5697  } else {
5698  if (const ReferenceType *ParamRef = ParamType->getAs<ReferenceType>()) {
5699  if (!ParamRef->getPointeeType()->isFunctionType()) {
5700  // C++ [temp.arg.nontype]p5b3:
5701  // For a non-type template-parameter of type reference to
5702  // object, no conversions apply. The type referred to by the
5703  // reference may be more cv-qualified than the (otherwise
5704  // identical) type of the template- argument. The
5705  // template-parameter is bound directly to the
5706  // template-argument, which shall be an lvalue.
5707 
5708  // FIXME: Other qualifiers?
5709  unsigned ParamQuals = ParamRef->getPointeeType().getCVRQualifiers();
5710  unsigned ArgQuals = ArgType.getCVRQualifiers();
5711 
5712  if ((ParamQuals | ArgQuals) != ParamQuals) {
5713  S.Diag(Arg->getBeginLoc(),
5714  diag::err_template_arg_ref_bind_ignores_quals)
5715  << ParamType << Arg->getType() << Arg->getSourceRange();
5716  S.Diag(Param->getLocation(), diag::note_template_param_here);
5717  return true;
5718  }
5719  }
5720  }
5721 
5722  // At this point, the template argument refers to an object or
5723  // function with external linkage. We now need to check whether the
5724  // argument and parameter types are compatible.
5725  if (!S.Context.hasSameUnqualifiedType(ArgType,
5726  ParamType.getNonReferenceType())) {
5727  // We can't perform this conversion or binding.
5728  if (ParamType->isReferenceType())
5729  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_no_ref_bind)
5730  << ParamType << ArgIn->getType() << Arg->getSourceRange();
5731  else
5732  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_convertible)
5733  << ArgIn->getType() << ParamType << Arg->getSourceRange();
5734  S.Diag(Param->getLocation(), diag::note_template_param_here);
5735  return true;
5736  }
5737  }
5738 
5739  return false;
5740 }
5741 
5742 /// Checks whether the given template argument is the address
5743 /// of an object or function according to C++ [temp.arg.nontype]p1.
5744 static bool
5746  NonTypeTemplateParmDecl *Param,
5747  QualType ParamType,
5748  Expr *ArgIn,
5749  TemplateArgument &Converted) {
5750  bool Invalid = false;
5751  Expr *Arg = ArgIn;
5752  QualType ArgType = Arg->getType();
5753 
5754  bool AddressTaken = false;
5755  SourceLocation AddrOpLoc;
5756  if (S.getLangOpts().MicrosoftExt) {
5757  // Microsoft Visual C++ strips all casts, allows an arbitrary number of
5758  // dereference and address-of operators.
5759  Arg = Arg->IgnoreParenCasts();
5760 
5761  bool ExtWarnMSTemplateArg = false;
5762  UnaryOperatorKind FirstOpKind;
5763  SourceLocation FirstOpLoc;
5764  while (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
5765  UnaryOperatorKind UnOpKind = UnOp->getOpcode();
5766  if (UnOpKind == UO_Deref)
5767  ExtWarnMSTemplateArg = true;
5768  if (UnOpKind == UO_AddrOf || UnOpKind == UO_Deref) {
5769  Arg = UnOp->getSubExpr()->IgnoreParenCasts();
5770  if (!AddrOpLoc.isValid()) {
5771  FirstOpKind = UnOpKind;
5772  FirstOpLoc = UnOp->getOperatorLoc();
5773  }
5774  } else
5775  break;
5776  }
5777  if (FirstOpLoc.isValid()) {
5778  if (ExtWarnMSTemplateArg)
5779  S.Diag(ArgIn->getBeginLoc(), diag::ext_ms_deref_template_argument)
5780  << ArgIn->getSourceRange();
5781 
5782  if (FirstOpKind == UO_AddrOf)
5783  AddressTaken = true;
5784  else if (Arg->getType()->isPointerType()) {
5785  // We cannot let pointers get dereferenced here, that is obviously not a
5786  // constant expression.
5787  assert(FirstOpKind == UO_Deref);
5788  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_decl_ref)
5789  << Arg->getSourceRange();
5790  }
5791  }
5792  } else {
5793  // See through any implicit casts we added to fix the type.
5794  Arg = Arg->IgnoreImpCasts();
5795 
5796  // C++ [temp.arg.nontype]p1:
5797  //
5798  // A template-argument for a non-type, non-template
5799  // template-parameter shall be one of: [...]
5800  //
5801  // -- the address of an object or function with external
5802  // linkage, including function templates and function
5803  // template-ids but excluding non-static class members,
5804  // expressed as & id-expression where the & is optional if
5805  // the name refers to a function or array, or if the
5806  // corresponding template-parameter is a reference; or
5807 
5808  // In C++98/03 mode, give an extension warning on any extra parentheses.
5809  // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
5810  bool ExtraParens = false;
5811  while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
5812  if (!Invalid && !ExtraParens) {
5813  S.Diag(Arg->getBeginLoc(),
5814  S.getLangOpts().CPlusPlus11
5815  ? diag::warn_cxx98_compat_template_arg_extra_parens
5816  : diag::ext_template_arg_extra_parens)
5817  << Arg->getSourceRange();
5818  ExtraParens = true;
5819  }
5820 
5821  Arg = Parens->getSubExpr();
5822  }
5823 
5824  while (SubstNonTypeTemplateParmExpr *subst =
5825  dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
5826  Arg = subst->getReplacement()->IgnoreImpCasts();
5827 
5828  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
5829  if (UnOp->getOpcode() == UO_AddrOf) {
5830  Arg = UnOp->getSubExpr();
5831  AddressTaken = true;
5832  AddrOpLoc = UnOp->getOperatorLoc();
5833  }
5834  }
5835 
5836  while (SubstNonTypeTemplateParmExpr *subst =
5837  dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
5838  Arg = subst->getReplacement()->IgnoreImpCasts();
5839  }
5840 
5841  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg);
5842  ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;
5843 
5844  // If our parameter has pointer type, check for a null template value.
5845  if (ParamType->isPointerType() || ParamType->isNullPtrType()) {
5846  switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ArgIn,
5847  Entity)) {
5848  case NPV_NullPointer:
5849  S.Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
5850  Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
5851  /*isNullPtr=*/true);
5852  return false;
5853 
5854  case NPV_Error:
5855  return true;
5856 
5857  case NPV_NotNullPointer:
5858  break;
5859  }
5860  }
5861 
5862  // Stop checking the precise nature of the argument if it is value dependent,
5863  // it should be checked when instantiated.
5864  if (Arg->isValueDependent()) {
5865  Converted = TemplateArgument(ArgIn);
5866  return false;
5867  }
5868 
5869  if (isa<CXXUuidofExpr>(Arg)) {
5870  if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType,
5871  ArgIn, Arg, ArgType))
5872  return true;
5873 
5874  Converted = TemplateArgument(ArgIn);
5875  return false;
5876  }
5877 
5878  if (!DRE) {
5879  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_decl_ref)
5880  << Arg->getSourceRange();
5881  S.Diag(Param->getLocation(), diag::note_template_param_here);
5882  return true;
5883  }
5884 
5885  // Cannot refer to non-static data members
5886  if (isa<FieldDecl>(Entity) || isa<IndirectFieldDecl>(Entity)) {
5887  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_field)
5888  << Entity << Arg->getSourceRange();
5889  S.Diag(Param->getLocation(), diag::note_template_param_here);
5890  return true;
5891  }
5892 
5893  // Cannot refer to non-static member functions
5894  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Entity)) {
5895  if (!Method->isStatic()) {
5896  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_method)
5897  << Method << Arg->getSourceRange();
5898  S.Diag(Param->getLocation(), diag::note_template_param_here);
5899  return true;
5900  }
5901  }
5902 
5903  FunctionDecl *Func = dyn_cast<FunctionDecl>(Entity);
5904  VarDecl *Var = dyn_cast<VarDecl>(Entity);
5905 
5906  // A non-type template argument must refer to an object or function.
5907  if (!Func && !Var) {
5908  // We found something, but we don't know specifically what it is.
5909  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_object_or_func)
5910  << Arg->getSourceRange();
5911  S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
5912  return true;
5913  }
5914 
5915  // Address / reference template args must have external linkage in C++98.
5916  if (Entity->getFormalLinkage() == InternalLinkage) {
5917  S.Diag(Arg->getBeginLoc(),
5918  S.getLangOpts().CPlusPlus11
5919  ? diag::warn_cxx98_compat_template_arg_object_internal
5920  : diag::ext_template_arg_object_internal)
5921  << !Func << Entity << Arg->getSourceRange();
5922  S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
5923  << !Func;
5924  } else if (!Entity->hasLinkage()) {
5925  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_object_no_linkage)
5926  << !Func << Entity << Arg->getSourceRange();
5927  S.Diag(Entity->getLocation(), diag::note_template_arg_internal_object)
5928  << !Func;
5929  return true;
5930  }
5931 
5932  if (Func) {
5933  // If the template parameter has pointer type, the function decays.
5934  if (ParamType->isPointerType() && !AddressTaken)
5935  ArgType = S.Context.getPointerType(Func->getType());
5936  else if (AddressTaken && ParamType->isReferenceType()) {
5937  // If we originally had an address-of operator, but the
5938  // parameter has reference type, complain and (if things look
5939  // like they will work) drop the address-of operator.
5940  if (!S.Context.hasSameUnqualifiedType(Func->getType(),
5941  ParamType.getNonReferenceType())) {
5942  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5943  << ParamType;
5944  S.Diag(Param->getLocation(), diag::note_template_param_here);
5945  return true;
5946  }
5947 
5948  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5949  << ParamType
5950  << FixItHint::CreateRemoval(AddrOpLoc);
5951  S.Diag(Param->getLocation(), diag::note_template_param_here);
5952 
5953  ArgType = Func->getType();
5954  }
5955  } else {
5956  // A value of reference type is not an object.
5957  if (Var->getType()->isReferenceType()) {
5958  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_reference_var)
5959  << Var->getType() << Arg->getSourceRange();
5960  S.Diag(Param->getLocation(), diag::note_template_param_here);
5961  return true;
5962  }
5963 
5964  // A template argument must have static storage duration.
5965  if (Var->getTLSKind()) {
5966  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_thread_local)
5967  << Arg->getSourceRange();
5968  S.Diag(Var->getLocation(), diag::note_template_arg_refers_here);
5969  return true;
5970  }
5971 
5972  // If the template parameter has pointer type, we must have taken
5973  // the address of this object.
5974  if (ParamType->isReferenceType()) {
5975  if (AddressTaken) {
5976  // If we originally had an address-of operator, but the
5977  // parameter has reference type, complain and (if things look
5978  // like they will work) drop the address-of operator.
5979  if (!S.Context.hasSameUnqualifiedType(Var->getType(),
5980  ParamType.getNonReferenceType())) {
5981  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5982  << ParamType;
5983  S.Diag(Param->getLocation(), diag::note_template_param_here);
5984  return true;
5985  }
5986 
5987  S.Diag(AddrOpLoc, diag::err_template_arg_address_of_non_pointer)
5988  << ParamType
5989  << FixItHint::CreateRemoval(AddrOpLoc);
5990  S.Diag(Param->getLocation(), diag::note_template_param_here);
5991 
5992  ArgType = Var->getType();
5993  }
5994  } else if (!AddressTaken && ParamType->isPointerType()) {
5995  if (Var->getType()->isArrayType()) {
5996  // Array-to-pointer decay.
5997  ArgType = S.Context.getArrayDecayedType(Var->getType());
5998  } else {
5999  // If the template parameter has pointer type but the address of
6000  // this object was not taken, complain and (possibly) recover by
6001  // taking the address of the entity.
6002  ArgType = S.Context.getPointerType(Var->getType());
6003  if (!S.Context.hasSameUnqualifiedType(ArgType, ParamType)) {
6004  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_address_of)
6005  << ParamType;
6006  S.Diag(Param->getLocation(), diag::note_template_param_here);
6007  return true;
6008  }
6009 
6010  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_address_of)
6011  << ParamType << FixItHint::CreateInsertion(Arg->getBeginLoc(), "&");
6012 
6013  S.Diag(Param->getLocation(), diag::note_template_param_here);
6014  }
6015  }
6016  }
6017 
6018  if (CheckTemplateArgumentIsCompatibleWithParameter(S, Param, ParamType, ArgIn,
6019  Arg, ArgType))
6020  return true;
6021 
6022  // Create the template argument.
6023  Converted =
6024  TemplateArgument(cast<ValueDecl>(Entity->getCanonicalDecl()), ParamType);
6025  S.MarkAnyDeclReferenced(Arg->getBeginLoc(), Entity, false);
6026  return false;
6027 }
6028 
6029 /// Checks whether the given template argument is a pointer to
6030 /// member constant according to C++ [temp.arg.nontype]p1.
6032  NonTypeTemplateParmDecl *Param,
6033  QualType ParamType,
6034  Expr *&ResultArg,
6035  TemplateArgument &Converted) {
6036  bool Invalid = false;
6037 
6038  Expr *Arg = ResultArg;
6039  bool ObjCLifetimeConversion;
6040 
6041  // C++ [temp.arg.nontype]p1:
6042  //
6043  // A template-argument for a non-type, non-template
6044  // template-parameter shall be one of: [...]
6045  //
6046  // -- a pointer to member expressed as described in 5.3.1.
6047  DeclRefExpr *DRE = nullptr;
6048 
6049  // In C++98/03 mode, give an extension warning on any extra parentheses.
6050  // See http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#773
6051  bool ExtraParens = false;
6052  while (ParenExpr *Parens = dyn_cast<ParenExpr>(Arg)) {
6053  if (!Invalid && !ExtraParens) {
6054  S.Diag(Arg->getBeginLoc(),
6055  S.getLangOpts().CPlusPlus11
6056  ? diag::warn_cxx98_compat_template_arg_extra_parens
6057  : diag::ext_template_arg_extra_parens)
6058  << Arg->getSourceRange();
6059  ExtraParens = true;
6060  }
6061 
6062  Arg = Parens->getSubExpr();
6063  }
6064 
6065  while (SubstNonTypeTemplateParmExpr *subst =
6066  dyn_cast<SubstNonTypeTemplateParmExpr>(Arg))
6067  Arg = subst->getReplacement()->IgnoreImpCasts();
6068 
6069  // A pointer-to-member constant written &Class::member.
6070  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(Arg)) {
6071  if (UnOp->getOpcode() == UO_AddrOf) {
6072  DRE = dyn_cast<DeclRefExpr>(UnOp->getSubExpr());
6073  if (DRE && !DRE->getQualifier())
6074  DRE = nullptr;
6075  }
6076  }
6077  // A constant of pointer-to-member type.
6078  else if ((DRE = dyn_cast<DeclRefExpr>(Arg))) {
6079  ValueDecl *VD = DRE->getDecl();
6080  if (VD->getType()->isMemberPointerType()) {
6081  if (isa<NonTypeTemplateParmDecl>(VD)) {
6082  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
6083  Converted = TemplateArgument(Arg);
6084  } else {
6085  VD = cast<ValueDecl>(VD->getCanonicalDecl());
6086  Converted = TemplateArgument(VD, ParamType);
6087  }
6088  return Invalid;
6089  }
6090  }
6091 
6092  DRE = nullptr;
6093  }
6094 
6095  ValueDecl *Entity = DRE ? DRE->getDecl() : nullptr;
6096 
6097  // Check for a null pointer value.
6098  switch (isNullPointerValueTemplateArgument(S, Param, ParamType, ResultArg,
6099  Entity)) {
6100  case NPV_Error:
6101  return true;
6102  case NPV_NullPointer:
6103  S.Diag(ResultArg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
6104  Converted = TemplateArgument(S.Context.getCanonicalType(ParamType),
6105  /*isNullPtr*/true);
6106  return false;
6107  case NPV_NotNullPointer:
6108  break;
6109  }
6110 
6111  if (S.IsQualificationConversion(ResultArg->getType(),
6112  ParamType.getNonReferenceType(), false,
6113  ObjCLifetimeConversion)) {
6114  ResultArg = S.ImpCastExprToType(ResultArg, ParamType, CK_NoOp,
6115  ResultArg->getValueKind())
6116  .get();
6117  } else if (!S.Context.hasSameUnqualifiedType(
6118  ResultArg->getType(), ParamType.getNonReferenceType())) {
6119  // We can't perform this conversion.
6120  S.Diag(ResultArg->getBeginLoc(), diag::err_template_arg_not_convertible)
6121  << ResultArg->getType() << ParamType << ResultArg->getSourceRange();
6122  S.Diag(Param->getLocation(), diag::note_template_param_here);
6123  return true;
6124  }
6125 
6126  if (!DRE)
6127  return S.Diag(Arg->getBeginLoc(),
6128  diag::err_template_arg_not_pointer_to_member_form)
6129  << Arg->getSourceRange();
6130 
6131  if (isa<FieldDecl>(DRE->getDecl()) ||
6132  isa<IndirectFieldDecl>(DRE->getDecl()) ||
6133  isa<CXXMethodDecl>(DRE->getDecl())) {
6134  assert((isa<FieldDecl>(DRE->getDecl()) ||
6135  isa<IndirectFieldDecl>(DRE->getDecl()) ||
6136  !cast<CXXMethodDecl>(DRE->getDecl())->isStatic()) &&
6137  "Only non-static member pointers can make it here");
6138 
6139  // Okay: this is the address of a non-static member, and therefore
6140  // a member pointer constant.
6141  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
6142  Converted = TemplateArgument(Arg);
6143  } else {
6144  ValueDecl *D = cast<ValueDecl>(DRE->getDecl()->getCanonicalDecl());
6145  Converted = TemplateArgument(D, ParamType);
6146  }
6147  return Invalid;
6148  }
6149 
6150  // We found something else, but we don't know specifically what it is.
6151  S.Diag(Arg->getBeginLoc(), diag::err_template_arg_not_pointer_to_member_form)
6152  << Arg->getSourceRange();
6153  S.Diag(DRE->getDecl()->getLocation(), diag::note_template_arg_refers_here);
6154  return true;
6155 }
6156 
6157 /// Check a template argument against its corresponding
6158 /// non-type template parameter.
6159 ///
6160 /// This routine implements the semantics of C++ [temp.arg.nontype].
6161 /// If an error occurred, it returns ExprError(); otherwise, it
6162 /// returns the converted template argument. \p ParamType is the
6163 /// type of the non-type template parameter after it has been instantiated.
6165  QualType ParamType, Expr *Arg,
6166  TemplateArgument &Converted,
6168  SourceLocation StartLoc = Arg->getBeginLoc();
6169 
6170  // If the parameter type somehow involves auto, deduce the type now.
6171  if (getLangOpts().CPlusPlus17 && ParamType->isUndeducedType()) {
6172  // During template argument deduction, we allow 'decltype(auto)' to
6173  // match an arbitrary dependent argument.
6174  // FIXME: The language rules don't say what happens in this case.
6175  // FIXME: We get an opaque dependent type out of decltype(auto) if the
6176  // expression is merely instantiation-dependent; is this enough?
6177  if (CTAK == CTAK_Deduced && Arg->isTypeDependent()) {
6178  auto *AT = dyn_cast<AutoType>(ParamType);
6179  if (AT && AT->isDecltypeAuto()) {
6180  Converted = TemplateArgument(Arg);
6181  return Arg;
6182  }
6183  }
6184 
6185  // When checking a deduced template argument, deduce from its type even if
6186  // the type is dependent, in order to check the types of non-type template
6187  // arguments line up properly in partial ordering.
6189  if (CTAK != CTAK_Specified)
6190  Depth = Param->getDepth() + 1;
6191  if (DeduceAutoType(
6192  Context.getTrivialTypeSourceInfo(ParamType, Param->getLocation()),
6193  Arg, ParamType, Depth) == DAR_Failed) {
6194  Diag(Arg->getExprLoc(),
6195  diag::err_non_type_template_parm_type_deduction_failure)
6196  << Param->getDeclName() << Param->getType() << Arg->getType()
6197  << Arg->getSourceRange();
6198  Diag(Param->getLocation(), diag::note_template_param_here);
6199  return ExprError();
6200  }
6201  // CheckNonTypeTemplateParameterType will produce a diagnostic if there's
6202  // an error. The error message normally references the parameter
6203  // declaration, but here we'll pass the argument location because that's
6204  // where the parameter type is deduced.
6205  ParamType = CheckNonTypeTemplateParameterType(ParamType, Arg->getExprLoc());
6206  if (ParamType.isNull()) {
6207  Diag(Param->getLocation(), diag::note_template_param_here);
6208  return ExprError();
6209  }
6210  }
6211 
6212  // We should have already dropped all cv-qualifiers by now.
6213  assert(!ParamType.hasQualifiers() &&
6214  "non-type template parameter type cannot be qualified");
6215 
6216  if (CTAK == CTAK_Deduced &&
6217  !Context.hasSameType(ParamType.getNonLValueExprType(Context),
6218  Arg->getType())) {
6219  // FIXME: If either type is dependent, we skip the check. This isn't
6220  // correct, since during deduction we're supposed to have replaced each
6221  // template parameter with some unique (non-dependent) placeholder.
6222  // FIXME: If the argument type contains 'auto', we carry on and fail the
6223  // type check in order to force specific types to be more specialized than
6224  // 'auto'. It's not clear how partial ordering with 'auto' is supposed to
6225  // work.
6226  if ((ParamType->isDependentType() || Arg->isTypeDependent()) &&
6227  !Arg->getType()->getContainedAutoType()) {
6228  Converted = TemplateArgument(Arg);
6229  return Arg;
6230  }
6231  // FIXME: This attempts to implement C++ [temp.deduct.type]p17. Per DR1770,
6232  // we should actually be checking the type of the template argument in P,
6233  // not the type of the template argument deduced from A, against the
6234  // template parameter type.
6235  Diag(StartLoc, diag::err_deduced_non_type_template_arg_type_mismatch)
6236  << Arg->getType()
6237  << ParamType.getUnqualifiedType();
6238  Diag(Param->getLocation(), diag::note_template_param_here);
6239  return ExprError();
6240  }
6241 
6242  // If either the parameter has a dependent type or the argument is
6243  // type-dependent, there's nothing we can check now.
6244  if (ParamType->isDependentType() || Arg->isTypeDependent()) {
6245  // FIXME: Produce a cloned, canonical expression?
6246  Converted = TemplateArgument(Arg);
6247  return Arg;
6248  }
6249 
6250  // The initialization of the parameter from the argument is
6251  // a constant-evaluated context.
6252  EnterExpressionEvaluationContext ConstantEvaluated(
6254 
6255  if (getLangOpts().CPlusPlus17) {
6256  // C++17 [temp.arg.nontype]p1:
6257  // A template-argument for a non-type template parameter shall be
6258  // a converted constant expression of the type of the template-parameter.
6259  APValue Value;
6261  Arg, ParamType, Value, CCEK_TemplateArg);
6262  if (ArgResult.isInvalid())
6263  return ExprError();
6264 
6265  // For a value-dependent argument, CheckConvertedConstantExpression is
6266  // permitted (and expected) to be unable to determine a value.
6267  if (ArgResult.get()->isValueDependent()) {
6268  Converted = TemplateArgument(ArgResult.get());
6269  return ArgResult;
6270  }
6271 
6272  QualType CanonParamType = Context.getCanonicalType(ParamType);
6273 
6274  // Convert the APValue to a TemplateArgument.
6275  switch (Value.getKind()) {
6277  assert(ParamType->isNullPtrType());
6278  Converted = TemplateArgument(CanonParamType, /*isNullPtr*/true);
6279  break;
6280  case APValue::Int:
6281  assert(ParamType->isIntegralOrEnumerationType());
6282  Converted = TemplateArgument(Context, Value.getInt(), CanonParamType);
6283  break;
6284  case APValue::MemberPointer: {
6285  assert(ParamType->isMemberPointerType());
6286 
6287  // FIXME: We need TemplateArgument representation and mangling for these.
6288  if (!Value.getMemberPointerPath().empty()) {
6289  Diag(Arg->getBeginLoc(),
6290  diag::err_template_arg_member_ptr_base_derived_not_supported)
6291  << Value.getMemberPointerDecl() << ParamType
6292  << Arg->getSourceRange();
6293  return ExprError();
6294  }
6295 
6296  auto *VD = const_cast<ValueDecl*>(Value.getMemberPointerDecl());
6297  Converted = VD ? TemplateArgument(VD, CanonParamType)
6298  : TemplateArgument(CanonParamType, /*isNullPtr*/true);
6299  break;
6300  }
6301  case APValue::LValue: {
6302  // For a non-type template-parameter of pointer or reference type,
6303  // the value of the constant expression shall not refer to
6304  assert(ParamType->isPointerType() || ParamType->isReferenceType() ||
6305  ParamType->isNullPtrType());
6306  // -- a temporary object
6307  // -- a string literal
6308  // -- the result of a typeid expression, or
6309  // -- a predefined __func__ variable
6310  if (auto *E = Value.getLValueBase().dyn_cast<const Expr*>()) {
6311  if (isa<CXXUuidofExpr>(E)) {
6312  Converted = TemplateArgument(ArgResult.get()->IgnoreImpCasts());
6313  break;
6314  }
6315  Diag(Arg->getBeginLoc(), diag::err_template_arg_not_decl_ref)
6316  << Arg->getSourceRange();
6317  return ExprError();
6318  }
6319  auto *VD = const_cast<ValueDecl *>(
6320  Value.getLValueBase().dyn_cast<const ValueDecl *>());
6321  // -- a subobject
6322  if (Value.hasLValuePath() && Value.getLValuePath().size() == 1 &&
6323  VD && VD->getType()->isArrayType() &&
6324  Value.getLValuePath()[0].ArrayIndex == 0 &&
6325  !Value.isLValueOnePastTheEnd() && ParamType->isPointerType()) {
6326  // Per defect report (no number yet):
6327  // ... other than a pointer to the first element of a complete array
6328  // object.
6329  } else if (!Value.hasLValuePath() || Value.getLValuePath().size() ||
6330  Value.isLValueOnePastTheEnd()) {
6331  Diag(StartLoc, diag::err_non_type_template_arg_subobject)
6332  << Value.getAsString(Context, ParamType);
6333  return ExprError();
6334  }
6335  assert((VD || !ParamType->isReferenceType()) &&
6336  "null reference should not be a constant expression");
6337  assert((!VD || !ParamType->isNullPtrType()) &&
6338  "non-null value of type nullptr_t?");
6339  Converted = VD ? TemplateArgument(VD, CanonParamType)
6340  : TemplateArgument(CanonParamType, /*isNullPtr*/true);
6341  break;
6342  }
6344  return Diag(StartLoc, diag::err_non_type_template_arg_addr_label_diff);
6345  case APValue::Float:
6346  case APValue::ComplexInt:
6347  case APValue::ComplexFloat:
6348  case APValue::Vector:
6349  case APValue::Array:
6350  case APValue::Struct:
6351  case APValue::Union:
6352  llvm_unreachable("invalid kind for template argument");
6353  }
6354 
6355  return ArgResult.get();
6356  }
6357 
6358  // C++ [temp.arg.nontype]p5:
6359  // The following conversions are performed on each expression used
6360  // as a non-type template-argument. If a non-type
6361  // template-argument cannot be converted to the type of the
6362  // corresponding template-parameter then the program is
6363  // ill-formed.
6364  if (ParamType->isIntegralOrEnumerationType()) {
6365  // C++11:
6366  // -- for a non-type template-parameter of integral or
6367  // enumeration type, conversions permitted in a converted
6368  // constant expression are applied.
6369  //
6370  // C++98:
6371  // -- for a non-type template-parameter of integral or
6372  // enumeration type, integral promotions (4.5) and integral
6373  // conversions (4.7) are applied.
6374 
6375  if (getLangOpts().CPlusPlus11) {
6376  // C++ [temp.arg.nontype]p1:
6377  // A template-argument for a non-type, non-template template-parameter
6378  // shall be one of:
6379  //
6380  // -- for a non-type template-parameter of integral or enumeration
6381  // type, a converted constant expression of the type of the
6382  // template-parameter; or
6383  llvm::APSInt Value;
6384  ExprResult ArgResult =
6385  CheckConvertedConstantExpression(Arg, ParamType, Value,
6386  CCEK_TemplateArg);
6387  if (ArgResult.isInvalid())
6388  return ExprError();
6389 
6390  // We can't check arbitrary value-dependent arguments.
6391  if (ArgResult.get()->isValueDependent()) {
6392  Converted = TemplateArgument(ArgResult.get());
6393  return ArgResult;
6394  }
6395 
6396  // Widen the argument value to sizeof(parameter type). This is almost
6397  // always a no-op, except when the parameter type is bool. In
6398  // that case, this may extend the argument from 1 bit to 8 bits.
6399  QualType IntegerType = ParamType;
6400  if (const EnumType *Enum = IntegerType->getAs<EnumType>())
6401  IntegerType = Enum->getDecl()->getIntegerType();
6402  Value = Value.extOrTrunc(Context.getTypeSize(IntegerType));
6403 
6404  Converted = TemplateArgument(Context, Value,
6405  Context.getCanonicalType(ParamType));
6406  return ArgResult;
6407  }
6408 
6409  ExprResult ArgResult = DefaultLvalueConversion(Arg);
6410  if (ArgResult.isInvalid())
6411  return ExprError();
6412  Arg = ArgResult.get();
6413 
6414  QualType ArgType = Arg->getType();
6415 
6416  // C++ [temp.arg.nontype]p1:
6417  // A template-argument for a non-type, non-template
6418  // template-parameter shall be one of:
6419  //
6420  // -- an integral constant-expression of integral or enumeration
6421  // type; or
6422  // -- the name of a non-type template-parameter; or
6423  llvm::APSInt Value;
6424  if (!ArgType->isIntegralOrEnumerationType()) {
6425  Diag(Arg->getBeginLoc(), diag::err_template_arg_not_integral_or_enumeral)
6426  << ArgType << Arg->getSourceRange();
6427  Diag(Param->getLocation(), diag::note_template_param_here);
6428  return ExprError();
6429  } else if (!Arg->isValueDependent()) {
6430  class TmplArgICEDiagnoser : public VerifyICEDiagnoser {
6431  QualType T;
6432 
6433  public:
6434  TmplArgICEDiagnoser(QualType T) : T(T) { }
6435 
6436  void diagnoseNotICE(Sema &S, SourceLocation Loc,
6437  SourceRange SR) override {
6438  S.Diag(Loc, diag::err_template_arg_not_ice) << T << SR;
6439  }
6440  } Diagnoser(ArgType);
6441 
6442  Arg = VerifyIntegerConstantExpression(Arg, &Value, Diagnoser,
6443  false).get();
6444  if (!Arg)
6445  return ExprError();
6446  }
6447 
6448  // From here on out, all we care about is the unqualified form
6449  // of the argument type.
6450  ArgType = ArgType.getUnqualifiedType();
6451 
6452  // Try to convert the argument to the parameter's type.
6453  if (Context.hasSameType(ParamType, ArgType)) {
6454  // Okay: no conversion necessary
6455  } else if (ParamType->isBooleanType()) {
6456  // This is an integral-to-boolean conversion.
6457  Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralToBoolean).get();
6458  } else if (IsIntegralPromotion(Arg, ArgType, ParamType) ||
6459  !ParamType->isEnumeralType()) {
6460  // This is an integral promotion or conversion.
6461  Arg = ImpCastExprToType(Arg, ParamType, CK_IntegralCast).get();
6462  } else {
6463  // We can't perform this conversion.
6464  Diag(Arg->getBeginLoc(), diag::err_template_arg_not_convertible)
6465  << Arg->getType() << ParamType << Arg->getSourceRange();
6466  Diag(Param->getLocation(), diag::note_template_param_here);
6467  return ExprError();
6468  }
6469 
6470  // Add the value of this argument to the list of converted
6471  // arguments. We use the bitwidth and signedness of the template
6472  // parameter.
6473  if (Arg->isValueDependent()) {
6474  // The argument is value-dependent. Create a new
6475  // TemplateArgument with the converted expression.
6476  Converted = TemplateArgument(Arg);
6477  return Arg;
6478  }
6479 
6480  QualType IntegerType = Context.getCanonicalType(ParamType);
6481  if (const EnumType *Enum = IntegerType->getAs<EnumType>())
6482  IntegerType = Context.getCanonicalType(Enum->getDecl()->getIntegerType());
6483 
6484  if (ParamType->isBooleanType()) {
6485  // Value must be zero or one.
6486  Value = Value != 0;
6487  unsigned AllowedBits = Context.getTypeSize(IntegerType);
6488  if (Value.getBitWidth() != AllowedBits)
6489  Value = Value.extOrTrunc(AllowedBits);
6490  Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
6491  } else {
6492  llvm::APSInt OldValue = Value;
6493 
6494  // Coerce the template argument's value to the value it will have
6495  // based on the template parameter's type.
6496  unsigned AllowedBits = Context.getTypeSize(IntegerType);
6497  if (Value.getBitWidth() != AllowedBits)
6498  Value = Value.extOrTrunc(AllowedBits);
6499  Value.setIsSigned(IntegerType->isSignedIntegerOrEnumerationType());
6500 
6501  // Complain if an unsigned parameter received a negative value.
6502  if (IntegerType->isUnsignedIntegerOrEnumerationType()
6503  && (OldValue.isSigned() && OldValue.isNegative())) {
6504  Diag(Arg->getBeginLoc(), diag::warn_template_arg_negative)
6505  << OldValue.toString(10) << Value.toString(10) << Param->getType()
6506  << Arg->getSourceRange();
6507  Diag(Param->getLocation(), diag::note_template_param_here);
6508  }
6509 
6510  // Complain if we overflowed the template parameter's type.
6511  unsigned RequiredBits;
6512  if (IntegerType->isUnsignedIntegerOrEnumerationType())
6513  RequiredBits = OldValue.getActiveBits();
6514  else if (OldValue.isUnsigned())
6515  RequiredBits = OldValue.getActiveBits() + 1;
6516  else
6517  RequiredBits = OldValue.getMinSignedBits();
6518  if (RequiredBits > AllowedBits) {
6519  Diag(Arg->getBeginLoc(), diag::warn_template_arg_too_large)
6520  << OldValue.toString(10) << Value.toString(10) << Param->getType()
6521  << Arg->getSourceRange();
6522  Diag(Param->getLocation(), diag::note_template_param_here);
6523  }
6524  }
6525 
6526  Converted = TemplateArgument(Context, Value,
6527  ParamType->isEnumeralType()
6528  ? Context.getCanonicalType(ParamType)
6529  : IntegerType);
6530  return Arg;
6531  }
6532 
6533  QualType ArgType = Arg->getType();
6534  DeclAccessPair FoundResult; // temporary for ResolveOverloadedFunction
6535 
6536  // Handle pointer-to-function, reference-to-function, and
6537  // pointer-to-member-function all in (roughly) the same way.
6538  if (// -- For a non-type template-parameter of type pointer to
6539  // function, only the function-to-pointer conversion (4.3) is
6540  // applied. If the template-argument represents a set of
6541  // overloaded functions (or a pointer to such), the matching
6542  // function is selected from the set (13.4).
6543  (ParamType->isPointerType() &&
6544  ParamType->getAs<PointerType>()->getPointeeType()->isFunctionType()) ||
6545  // -- For a non-type template-parameter of type reference to
6546  // function, no conversions apply. If the template-argument
6547  // represents a set of overloaded functions, the matching
6548  // function is selected from the set (13.4).
6549  (ParamType->isReferenceType() &&
6550  ParamType->getAs<ReferenceType>()->getPointeeType()->isFunctionType()) ||
6551  // -- For a non-type template-parameter of type pointer to
6552  // member function, no conversions apply. If the
6553  // template-argument represents a set of overloaded member
6554  // functions, the matching member function is selected from
6555  // the set (13.4).
6556  (ParamType->isMemberPointerType() &&
6557  ParamType->getAs<MemberPointerType>()->getPointeeType()
6558  ->isFunctionType())) {
6559 
6560  if (Arg->getType() == Context.OverloadTy) {
6561  if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType,
6562  true,
6563  FoundResult)) {
6564  if (DiagnoseUseOfDecl(Fn, Arg->getBeginLoc()))
6565  return ExprError();
6566 
6567  Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
6568  ArgType = Arg->getType();
6569  } else
6570  return ExprError();
6571  }
6572 
6573  if (!ParamType->isMemberPointerType()) {
6575  ParamType,
6576  Arg, Converted))
6577  return ExprError();
6578  return Arg;
6579  }
6580 
6581  if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
6582  Converted))
6583  return ExprError();
6584  return Arg;
6585  }
6586 
6587  if (ParamType->isPointerType()) {
6588  // -- for a non-type template-parameter of type pointer to
6589  // object, qualification conversions (4.4) and the
6590  // array-to-pointer conversion (4.2) are applied.
6591  // C++0x also allows a value of std::nullptr_t.
6592  assert(ParamType->getPointeeType()->isIncompleteOrObjectType() &&
6593  "Only object pointers allowed here");
6594 
6596  ParamType,
6597  Arg, Converted))
6598  return ExprError();
6599  return Arg;
6600  }
6601 
6602  if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
6603  // -- For a non-type template-parameter of type reference to
6604  // object, no conversions apply. The type referred to by the
6605  // reference may be more cv-qualified than the (otherwise
6606  // identical) type of the template-argument. The
6607  // template-parameter is bound directly to the
6608  // template-argument, which must be an lvalue.
6609  assert(ParamRefType->getPointeeType()->isIncompleteOrObjectType() &&
6610  "Only object references allowed here");
6611 
6612  if (Arg->getType() == Context.OverloadTy) {
6613  if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg,
6614  ParamRefType->getPointeeType(),
6615  true,
6616  FoundResult)) {
6617  if (DiagnoseUseOfDecl(Fn, Arg->getBeginLoc()))
6618  return ExprError();
6619 
6620  Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
6621  ArgType = Arg->getType();
6622  } else
6623  return ExprError();
6624  }
6625 
6627  ParamType,
6628  Arg, Converted))
6629  return ExprError();
6630  return Arg;
6631  }
6632 
6633  // Deal with parameters of type std::nullptr_t.
6634  if (ParamType->isNullPtrType()) {
6635  if (Arg->isTypeDependent() || Arg->isValueDependent()) {
6636  Converted = TemplateArgument(Arg);
6637  return Arg;
6638  }
6639 
6640  switch (isNullPointerValueTemplateArgument(*this, Param, ParamType, Arg)) {
6641  case NPV_NotNullPointer:
6642  Diag(Arg->getExprLoc(), diag::err_template_arg_not_convertible)
6643  << Arg->getType() << ParamType;
6644  Diag(Param->getLocation(), diag::note_template_param_here);
6645  return ExprError();
6646 
6647  case NPV_Error:
6648  return ExprError();
6649 
6650  case NPV_NullPointer:
6651  Diag(Arg->getExprLoc(), diag::warn_cxx98_compat_template_arg_null);
6652  Converted = TemplateArgument(Context.getCanonicalType(ParamType),
6653  /*isNullPtr*/true);
6654  return Arg;
6655  }
6656  }
6657 
6658  // -- For a non-type template-parameter of type pointer to data
6659  // member, qualification conversions (4.4) are applied.
6660  assert(ParamType->isMemberPointerType() && "Only pointers to members remain");
6661 
6662  if (CheckTemplateArgumentPointerToMember(*this, Param, ParamType, Arg,
6663  Converted))
6664  return ExprError();
6665  return Arg;
6666 }
6667 
6671 
6672 /// Check a template argument against its corresponding
6673 /// template template parameter.
6674 ///
6675 /// This routine implements the semantics of C++ [temp.arg.template].
6676 /// It returns true if an error occurred, and false otherwise.
6678  TemplateArgumentLoc &Arg) {
6680  TemplateDecl *Template = Name.getAsTemplateDecl();
6681  if (!Template) {
6682  // Any dependent template name is fine.
6683  assert(Name.isDependent() && "Non-dependent template isn't a declaration?");
6684  return false;
6685  }
6686 
6687  if (Template->isInvalidDecl())
6688  return true;
6689 
6690  // C++0x [temp.arg.template]p1:
6691  // A template-argument for a template template-parameter shall be
6692  // the name of a class template or an alias template, expressed as an
6693  // id-expression. When the template-argument names a class template, only
6694  // primary class templates are considered when matching the
6695  // template template argument with the corresponding parameter;
6696  // partial specializations are not considered even if their
6697  // parameter lists match that of the template template parameter.
6698  //
6699  // Note that we also allow template template parameters here, which
6700  // will happen when we are dealing with, e.g., class template
6701  // partial specializations.
6702  if (!isa<ClassTemplateDecl>(Template) &&
6703  !isa<TemplateTemplateParmDecl>(Template) &&
6704  !isa<TypeAliasTemplateDecl>(Template) &&
6705  !isa<BuiltinTemplateDecl>(Template)) {
6706  assert(isa<FunctionTemplateDecl>(Template) &&
6707  "Only function templates are possible here");
6708  Diag(Arg.getLocation(), diag::err_template_arg_not_valid_template);
6709  Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
6710  << Template;
6711  }
6712 
6713  // C++1z [temp.arg.template]p3: (DR 150)
6714  // A template-argument matches a template template-parameter P when P
6715  // is at least as specialized as the template-argument A.
6716  if (getLangOpts().RelaxedTemplateTemplateArgs) {
6717  // Quick check for the common case:
6718  // If P contains a parameter pack, then A [...] matches P if each of A's
6719  // template parameters matches the corresponding template parameter in
6720  // the template-parameter-list of P.
6721  if (TemplateParameterListsAreEqual(
6722  Template->getTemplateParameters(), Params, false,
6723  TPL_TemplateTemplateArgumentMatch, Arg.getLocation()))
6724  return false;
6725 
6726  if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template,
6727  Arg.getLocation()))
6728  return false;
6729  // FIXME: Produce better diagnostics for deduction failures.
6730  }
6731 
6732  return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),
6733  Params,
6734  true,
6735  TPL_TemplateTemplateArgumentMatch,
6736  Arg.getLocation());
6737 }
6738 
6739 /// Given a non-type template argument that refers to a
6740 /// declaration and the type of its corresponding non-type template
6741 /// parameter, produce an expression that properly refers to that
6742 /// declaration.
6743 ExprResult
6745  QualType ParamType,
6746  SourceLocation Loc) {
6747  // C++ [temp.param]p8:
6748  //
6749  // A non-type template-parameter of type "array of T" or
6750  // "function returning T" is adjusted to be of type "pointer to
6751  // T" or "pointer to function returning T", respectively.
6752  if (ParamType->isArrayType())
6753  ParamType = Context.getArrayDecayedType(ParamType);
6754  else if (ParamType->isFunctionType())
6755  ParamType = Context.getPointerType(ParamType);
6756 
6757  // For a NULL non-type template argument, return nullptr casted to the
6758  // parameter's type.
6759  if (Arg.getKind() == TemplateArgument::NullPtr) {
6760  return ImpCastExprToType(
6761  new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc),
6762  ParamType,
6763  ParamType->getAs<MemberPointerType>()
6764  ? CK_NullToMemberPointer
6765  : CK_NullToPointer);
6766  }
6767  assert(Arg.getKind() == TemplateArgument::Declaration &&
6768  "Only declaration template arguments permitted here");
6769 
6770  ValueDecl *VD = Arg.getAsDecl();
6771 
6772  if (VD->getDeclContext()->isRecord() &&
6773  (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD) ||
6774  isa<IndirectFieldDecl>(VD))) {
6775  // If the value is a class member, we might have a pointer-to-member.
6776  // Determine whether the non-type template template parameter is of
6777  // pointer-to-member type. If so, we need to build an appropriate
6778  // expression for a pointer-to-member, since a "normal" DeclRefExpr
6779  // would refer to the member itself.
6780  if (ParamType->isMemberPointerType()) {
6781  QualType ClassType
6782  = Context.getTypeDeclType(cast<RecordDecl>(VD->getDeclContext()));
6783  NestedNameSpecifier *Qualifier
6784  = NestedNameSpecifier::Create(Context, nullptr, false,
6785  ClassType.getTypePtr());
6786  CXXScopeSpec SS;
6787  SS.MakeTrivial(Context, Qualifier, Loc);
6788 
6789  // The actual value-ness of this is unimportant, but for
6790  // internal consistency's sake, references to instance methods
6791  // are r-values.
6792  ExprValueKind VK = VK_LValue;
6793  if (isa<CXXMethodDecl>(VD) && cast<CXXMethodDecl>(VD)->isInstance())
6794  VK = VK_RValue;
6795 
6796  ExprResult RefExpr = BuildDeclRefExpr(VD,
6797  VD->getType().getNonReferenceType(),
6798  VK,
6799  Loc,
6800  &SS);
6801  if (RefExpr.isInvalid())
6802  return ExprError();
6803 
6804  RefExpr = CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
6805 
6806  // We might need to perform a trailing qualification conversion, since
6807  // the element type on the parameter could be more qualified than the
6808  // element type in the expression we constructed.
6809  bool ObjCLifetimeConversion;
6810  if (IsQualificationConversion(((Expr*) RefExpr.get())->getType(),
6811  ParamType.getUnqualifiedType(), false,
6812  ObjCLifetimeConversion))
6813  RefExpr = ImpCastExprToType(RefExpr.get(), ParamType.getUnqualifiedType(), CK_NoOp);
6814 
6815  assert(!RefExpr.isInvalid() &&
6816  Context.hasSameType(((Expr*) RefExpr.get())->getType(),
6817  ParamType.getUnqualifiedType()));
6818  return RefExpr;
6819  }
6820  }
6821 
6822  QualType T = VD->getType().getNonReferenceType();
6823 
6824  if (ParamType->isPointerType()) {
6825  // When the non-type template parameter is a pointer, take the
6826  // address of the declaration.
6827  ExprResult RefExpr = BuildDeclRefExpr(VD, T, VK_LValue, Loc);
6828  if (RefExpr.isInvalid())
6829  return ExprError();
6830 
6831  if (!Context.hasSameUnqualifiedType(ParamType->getPointeeType(), T) &&
6832  (T->isFunctionType() || T->isArrayType())) {
6833  // Decay functions and arrays unless we're forming a pointer to array.
6834  RefExpr = DefaultFunctionArrayConversion(RefExpr.get());
6835  if (RefExpr.isInvalid())
6836  return ExprError();
6837 
6838  return RefExpr;
6839  }
6840 
6841  // Take the address of everything else
6842  return CreateBuiltinUnaryOp(Loc, UO_AddrOf, RefExpr.get());
6843  }
6844 
6845  ExprValueKind VK = VK_RValue;
6846 
6847  // If the non-type template parameter has reference type, qualify the
6848  // resulting declaration reference with the extra qualifiers on the
6849  // type that the reference refers to.
6850  if (const ReferenceType *TargetRef = ParamType->getAs<ReferenceType>()) {
6851  VK = VK_LValue;
6852  T = Context.getQualifiedType(T,
6853  TargetRef->getPointeeType().getQualifiers());
6854  } else if (isa<FunctionDecl>(VD)) {
6855  // References to functions are always lvalues.
6856  VK = VK_LValue;
6857  }
6858 
6859  return BuildDeclRefExpr(VD, T, VK, Loc);
6860 }
6861 
6862 /// Construct a new expression that refers to the given
6863 /// integral template argument with the given source-location
6864 /// information.
6865 ///
6866 /// This routine takes care of the mapping from an integral template
6867 /// argument (which may have any integral type) to the appropriate
6868 /// literal value.
6869 ExprResult
6871  SourceLocation Loc) {
6872  assert(Arg.getKind() == TemplateArgument::Integral &&
6873  "Operation is only valid for integral template arguments");
6874  QualType OrigT = Arg.getIntegralType();
6875 
6876  // If this is an enum type that we're instantiating, we need to use an integer
6877  // type the same size as the enumerator. We don't want to build an
6878  // IntegerLiteral with enum type. The integer type of an enum type can be of
6879  // any integral type with C++11 enum classes, make sure we create the right
6880  // type of literal for it.
6881  QualType T = OrigT;
6882  if (const EnumType *ET = OrigT->getAs<EnumType>())
6883  T = ET->getDecl()->getIntegerType();
6884 
6885  Expr *E;
6886  if (T->isAnyCharacterType()) {
6888  if (T->isWideCharType())
6889  Kind = CharacterLiteral::Wide;
6890  else if (T->isChar8Type() && getLangOpts().Char8)
6891  Kind = CharacterLiteral::UTF8;
6892  else if (T->isChar16Type())
6893  Kind = CharacterLiteral::UTF16;
6894  else if (T->isChar32Type())
6895  Kind = CharacterLiteral::UTF32;
6896  else
6897  Kind = CharacterLiteral::Ascii;
6898 
6899  E = new (Context) CharacterLiteral(Arg.getAsIntegral().getZExtValue(),
6900  Kind, T, Loc);
6901  } else if (T->isBooleanType()) {
6902  E = new (Context) CXXBoolLiteralExpr(Arg.getAsIntegral().getBoolValue(),
6903  T, Loc);
6904  } else if (T->isNullPtrType()) {
6905  E = new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
6906  } else {
6907  E = IntegerLiteral::Create(Context, Arg.getAsIntegral(), T, Loc);
6908  }
6909 
6910  if (OrigT->isEnumeralType()) {
6911  // FIXME: This is a hack. We need a better way to handle substituted
6912  // non-type template parameters.
6913  E = CStyleCastExpr::Create(Context, OrigT, VK_RValue, CK_IntegralCast, E,
6914  nullptr,
6915  Context.getTrivialTypeSourceInfo(OrigT, Loc),
6916  Loc, Loc);
6917  }
6918 
6919  return E;
6920 }
6921 
6922 /// Match two template parameters within template parameter lists.
6924  bool Complain,
6926  SourceLocation TemplateArgLoc) {
6927  // Check the actual kind (type, non-type, template).
6928  if (Old->getKind() != New->getKind()) {
6929  if (Complain) {
6930  unsigned NextDiag = diag::err_template_param_different_kind;
6931  if (TemplateArgLoc.isValid()) {
6932  S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
6933  NextDiag = diag::note_template_param_different_kind;
6934  }
6935  S.Diag(New->getLocation(), NextDiag)
6936  << (Kind != Sema::TPL_TemplateMatch);
6937  S.Diag(Old->getLocation(), diag::note_template_prev_declaration)
6938  << (Kind != Sema::TPL_TemplateMatch);
6939  }
6940 
6941  return false;
6942  }
6943 
6944  // Check that both are parameter packs or neither are parameter packs.
6945  // However, if we are matching a template template argument to a
6946  // template template parameter, the template template parameter can have
6947  // a parameter pack where the template template argument does not.
6948  if (Old->isTemplateParameterPack() != New->isTemplateParameterPack() &&
6950  Old->isTemplateParameterPack())) {
6951  if (Complain) {
6952  unsigned NextDiag = diag::err_template_parameter_pack_non_pack;
6953  if (TemplateArgLoc.isValid()) {
6954  S.Diag(TemplateArgLoc,
6955  diag::err_template_arg_template_params_mismatch);
6956  NextDiag = diag::note_template_parameter_pack_non_pack;
6957  }
6958 
6959  unsigned ParamKind = isa<TemplateTypeParmDecl>(New)? 0
6960  : isa<NonTypeTemplateParmDecl>(New)? 1
6961  : 2;
6962  S.Diag(New->getLocation(), NextDiag)
6963  << ParamKind << New->isParameterPack();
6964  S.Diag(Old->getLocation(), diag::note_template_parameter_pack_here)
6965  << ParamKind << Old->isParameterPack();
6966  }
6967 
6968  return false;
6969  }
6970 
6971  // For non-type template parameters, check the type of the parameter.
6972  if (NonTypeTemplateParmDecl *OldNTTP
6973  = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
6974  NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);
6975 
6976  // If we are matching a template template argument to a template
6977  // template parameter and one of the non-type template parameter types
6978  // is dependent, then we must wait until template instantiation time
6979  // to actually compare the arguments.
6981  (OldNTTP->getType()->isDependentType() ||
6982  NewNTTP->getType()->isDependentType()))
6983  return true;
6984 
6985  if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
6986  if (Complain) {
6987  unsigned NextDiag = diag::err_template_nontype_parm_different_type;
6988  if (TemplateArgLoc.isValid()) {
6989  S.Diag(TemplateArgLoc,
6990  diag::err_template_arg_template_params_mismatch);
6991  NextDiag = diag::note_template_nontype_parm_different_type;
6992  }
6993  S.Diag(NewNTTP->getLocation(), NextDiag)
6994  << NewNTTP->getType()
6995  << (Kind != Sema::TPL_TemplateMatch);
6996  S.Diag(OldNTTP->getLocation(),
6997  diag::note_template_nontype_parm_prev_declaration)
6998  << OldNTTP->getType();
6999  }
7000 
7001  return false;
7002  }
7003 
7004  return true;
7005  }
7006 
7007  // For template template parameters, check the template parameter types.
7008  // The template parameter lists of template template
7009  // parameters must agree.
7010  if (TemplateTemplateParmDecl *OldTTP
7011  = dyn_cast<TemplateTemplateParmDecl>(Old)) {
7012  TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
7014  OldTTP->getTemplateParameters(),
7015  Complain,
7016  (Kind == Sema::TPL_TemplateMatch
7018  : Kind),
7019  TemplateArgLoc);
7020  }
7021 
7022  return true;
7023 }
7024 
7025 /// Diagnose a known arity mismatch when comparing template argument
7026 /// lists.
7027 static
7029  TemplateParameterList *New,
7030  TemplateParameterList *Old,
7032  SourceLocation TemplateArgLoc) {
7033  unsigned NextDiag = diag::err_template_param_list_different_arity;
7034  if (TemplateArgLoc.isValid()) {
7035  S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
7036  NextDiag = diag::note_template_param_list_different_arity;
7037  }
7038  S.Diag(New->getTemplateLoc(), NextDiag)
7039  << (New->size() > Old->size())
7040  << (Kind != Sema::TPL_TemplateMatch)
7041  << SourceRange(New->getTemplateLoc(), New->getRAngleLoc());
7042  S.Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration)
7043  << (Kind != Sema::TPL_TemplateMatch)
7044  << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc());
7045 }
7046 
7047 /// Determine whether the given template parameter lists are
7048 /// equivalent.
7049 ///
7050 /// \param New The new template parameter list, typically written in the
7051 /// source code as part of a new template declaration.
7052 ///
7053 /// \param Old The old template parameter list, typically found via
7054 /// name lookup of the template declared with this template parameter
7055 /// list.
7056 ///
7057 /// \param Complain If true, this routine will produce a diagnostic if
7058 /// the template parameter lists are not equivalent.
7059 ///
7060 /// \param Kind describes how we are to match the template parameter lists.
7061 ///
7062 /// \param TemplateArgLoc If this source location is valid, then we
7063 /// are actually checking the template parameter list of a template
7064 /// argument (New) against the template parameter list of its
7065 /// corresponding template template parameter (Old). We produce
7066 /// slightly different diagnostics in this scenario.
7067 ///
7068 /// \returns True if the template parameter lists are equal, false
7069 /// otherwise.
7070 bool
7072  TemplateParameterList *Old,
7073  bool Complain,
7075  SourceLocation TemplateArgLoc) {
7076  if (Old->size() != New->size() && Kind != TPL_TemplateTemplateArgumentMatch) {
7077  if (Complain)
7078  DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
7079  TemplateArgLoc);
7080 
7081  return false;
7082  }
7083 
7084  // C++0x [temp.arg.template]p3:
7085  // A template-argument matches a template template-parameter (call it P)
7086  // when each of the template parameters in the template-parameter-list of
7087  // the template-argument's corresponding class template or alias template
7088  // (call it A) matches the corresponding template parameter in the
7089  // template-parameter-list of P. [...]
7090  TemplateParameterList::iterator NewParm = New->begin();
7091  TemplateParameterList::iterator NewParmEnd = New->end();
7092  for (TemplateParameterList::iterator OldParm = Old->begin(),
7093  OldParmEnd = Old->end();
7094  OldParm != OldParmEnd; ++OldParm) {
7095  if (Kind != TPL_TemplateTemplateArgumentMatch ||
7096  !(*OldParm)->isTemplateParameterPack()) {
7097  if (NewParm == NewParmEnd) {
7098  if (Complain)
7099  DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
7100  TemplateArgLoc);
7101 
7102  return false;
7103  }
7104 
7105  if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
7106  Kind, TemplateArgLoc))
7107  return false;
7108 
7109  ++NewParm;
7110  continue;
7111  }
7112 
7113  // C++0x [temp.arg.template]p3:
7114  // [...] When P's template- parameter-list contains a template parameter
7115  // pack (14.5.3), the template parameter pack will match zero or more
7116  // template parameters or template parameter packs in the
7117  // template-parameter-list of A with the same type and form as the
7118  // template parameter pack in P (ignoring whether those template
7119  // parameters are template parameter packs).
7120  for (; NewParm != NewParmEnd; ++NewParm) {
7121  if (!MatchTemplateParameterKind(*this, *NewParm, *OldParm, Complain,
7122  Kind, TemplateArgLoc))
7123  return false;
7124  }
7125  }
7126 
7127  // Make sure we exhausted all of the arguments.
7128  if (NewParm != NewParmEnd) {
7129  if (Complain)
7130  DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
7131  TemplateArgLoc);
7132 
7133  return false;
7134  }
7135 
7136  return true;
7137 }
7138 
7139 /// Check whether a template can be declared within this scope.
7140 ///
7141 /// If the template declaration is valid in this scope, returns
7142 /// false. Otherwise, issues a diagnostic and returns true.
7143 bool
7145  if (!S)
7146  return false;
7147 
7148  // Find the nearest enclosing declaration scope.
7149  while ((S->getFlags() & Scope::DeclScope) == 0 ||
7150  (S->getFlags() & Scope::TemplateParamScope) != 0)
7151  S = S->getParent();
7152 
7153  // C++ [temp]p4:
7154  // A template [...] shall not have C linkage.
7155  DeclContext *Ctx = S->getEntity();
7156  if (Ctx && Ctx->isExternCContext()) {
7157  Diag(TemplateParams->getTemplateLoc(), diag::err_template_linkage)
7158  << TemplateParams->getSourceRange();
7159  if (const LinkageSpecDecl *LSD = Ctx->getExternCContext())
7160  Diag(LSD->getExternLoc(), diag::note_extern_c_begins_here);
7161  return true;
7162  }
7163  Ctx = Ctx->getRedeclContext();
7164 
7165  // C++ [temp]p2:
7166  // A template-declaration can appear only as a namespace scope or
7167  // class scope declaration.
7168  if (Ctx) {
7169  if (Ctx->isFileContext())
7170  return false;
7171  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Ctx)) {
7172  // C++ [temp.mem]p2:
7173  // A local class shall not have member templates.
7174  if (RD->isLocalClass())
7175  return Diag(TemplateParams->getTemplateLoc(),
7176  diag::err_template_inside_local_class)
7177  << TemplateParams->getSourceRange();
7178  else
7179  return false;
7180  }
7181  }
7182 
7183  return Diag(TemplateParams->getTemplateLoc(),
7184  diag::err_template_outside_namespace_or_class_scope)
7185  << TemplateParams->getSourceRange();
7186 }
7187 
7188 /// Determine what kind of template specialization the given declaration
7189 /// is.
7191  if (!D)
7192  return TSK_Undeclared;
7193 
7194  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D))
7195  return Record->getTemplateSpecializationKind();
7196  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D))
7197  return Function->getTemplateSpecializationKind();
7198  if (VarDecl *Var = dyn_cast<VarDecl>(D))
7199  return Var->getTemplateSpecializationKind();
7200 
7201  return TSK_Undeclared;
7202 }
7203 
7204 /// Check whether a specialization is well-formed in the current
7205 /// context.
7206 ///
7207 /// This routine determines whether a template specialization can be declared
7208 /// in the current context (C++ [temp.expl.spec]p2).
7209 ///
7210 /// \param S the semantic analysis object for which this check is being
7211 /// performed.
7212 ///
7213 /// \param Specialized the entity being specialized or instantiated, which
7214 /// may be a kind of template (class template, function template, etc.) or
7215 /// a member of a class template (member function, static data member,
7216 /// member class).
7217 ///
7218 /// \param PrevDecl the previous declaration of this entity, if any.
7219 ///
7220 /// \param Loc the location of the explicit specialization or instantiation of
7221 /// this entity.
7222 ///
7223 /// \param IsPartialSpecialization whether this is a partial specialization of
7224 /// a class template.
7225 ///
7226 /// \returns true if there was an error that we cannot recover from, false
7227 /// otherwise.
7229  NamedDecl *Specialized,
7230  NamedDecl *PrevDecl,
7231  SourceLocation Loc,
7232  bool IsPartialSpecialization) {
7233  // Keep these "kind" numbers in sync with the %select statements in the
7234  // various diagnostics emitted by this routine.
7235  int EntityKind = 0;
7236  if (isa<ClassTemplateDecl>(Specialized))
7237  EntityKind = IsPartialSpecialization? 1 : 0;
7238  else if (isa<VarTemplateDecl>(Specialized))
7239  EntityKind = IsPartialSpecialization ? 3 : 2;
7240  else if (isa<FunctionTemplateDecl>(Specialized))
7241  EntityKind = 4;
7242  else if (isa<CXXMethodDecl>(Specialized))
7243  EntityKind = 5;
7244  else if (isa<VarDecl>(Specialized))
7245  EntityKind = 6;
7246  else if (isa<RecordDecl>(Specialized))
7247  EntityKind = 7;
7248  else if (isa<EnumDecl>(Specialized) && S.getLangOpts().CPlusPlus11)
7249  EntityKind = 8;
7250  else {
7251  S.Diag(Loc, diag::err_template_spec_unknown_kind)
7252  << S.getLangOpts().CPlusPlus11;
7253  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
7254  return true;
7255  }
7256 
7257  // C++ [temp.expl.spec]p2:
7258  // An explicit specialization may be declared in any scope in which
7259  // the corresponding primary template may be defined.
7261  S.Diag(Loc, diag::err_template_spec_decl_function_scope)
7262  << Specialized;
7263  return true;
7264  }
7265 
7266  // C++ [temp.class.spec]p6:
7267  // A class template partial specialization may be declared in any
7268  // scope in which the primary template may be defined.
7269  DeclContext *SpecializedContext =
7270  Specialized->getDeclContext()->getRedeclContext();
7272 
7273  // Make sure that this redeclaration (or definition) occurs in the same
7274  // scope or an enclosing namespace.
7275  if (!(DC->isFileContext() ? DC->Encloses(SpecializedContext)
7276  : DC->Equals(SpecializedContext))) {
7277  if (isa<TranslationUnitDecl>(SpecializedContext))
7278  S.Diag(Loc, diag::err_template_spec_redecl_global_scope)
7279  << EntityKind << Specialized;
7280  else {
7281  auto *ND = cast<NamedDecl>(SpecializedContext);
7282  int Diag = diag::err_template_spec_redecl_out_of_scope;
7283  if (S.getLangOpts().MicrosoftExt && !DC->isRecord())
7284  Diag = diag::ext_ms_template_spec_redecl_out_of_scope;
7285  S.Diag(Loc, Diag) << EntityKind << Specialized
7286  << ND << isa<CXXRecordDecl>(ND);
7287  }
7288 
7289  S.Diag(Specialized->getLocation(), diag::note_specialized_entity);
7290 
7291  // Don't allow specializing in the wrong class during error recovery.
7292  // Otherwise, things can go horribly wrong.
7293  if (DC->isRecord())
7294  return true;
7295  }
7296 
7297  return false;
7298 }
7299 
7301  if (!E->isTypeDependent())
7302  return SourceLocation();
7303  DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
7304  Checker.TraverseStmt(E);
7305  if (Checker.MatchLoc.isInvalid())
7306  return E->getSourceRange();
7307  return Checker.MatchLoc;
7308 }
7309 
7311  if (!TL.getType()->isDependentType())
7312  return SourceLocation();
7313  DependencyChecker Checker(Depth, /*IgnoreNonTypeDependent*/true);
7314  Checker.TraverseTypeLoc(TL);
7315  if (Checker.MatchLoc.isInvalid())
7316  return TL.getSourceRange();
7317  return Checker.MatchLoc;
7318 }
7319 
7320 /// Subroutine of Sema::CheckTemplatePartialSpecializationArgs
7321 /// that checks non-type template partial specialization arguments.
7323  Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param,
7324  const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument) {
7325  for (unsigned I = 0; I != NumArgs; ++I) {
7326  if (Args[I].getKind() == TemplateArgument::Pack) {
7328  S, TemplateNameLoc, Param, Args[I].pack_begin(),
7329  Args[I].pack_size(), IsDefaultArgument))
7330  return true;
7331 
7332  continue;
7333  }
7334 
7335  if (Args[I].getKind() != TemplateArgument::Expression)
7336  continue;
7337 
7338  Expr *ArgExpr = Args[I].getAsExpr();
7339 
7340  // We can have a pack expansion of any of the bullets below.
7341  if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(ArgExpr))
7342  ArgExpr = Expansion->getPattern();
7343 
7344  // Strip off any implicit casts we added as part of type checking.
7345  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
7346  ArgExpr = ICE->getSubExpr();
7347 
7348  // C++ [temp.class.spec]p8:
7349  // A non-type argument is non-specialized if it is the name of a
7350  // non-type parameter. All other non-type arguments are
7351  // specialized.
7352  //
7353  // Below, we check the two conditions that only apply to
7354  // specialized non-type arguments, so skip any non-specialized
7355  // arguments.
7356  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ArgExpr))
7357  if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
7358  continue;
7359 
7360  // C++ [temp.class.spec]p9:
7361  // Within the argument list of a class template partial
7362  // specialization, the following restrictions apply:
7363  // -- A partially specialized non-type argument expression
7364  // shall not involve a template parameter of the partial
7365  // specialization except when the argument expression is a
7366  // simple identifier.
7367  // -- The type of a template parameter corresponding to a
7368  // specialized non-type argument shall not be dependent on a
7369  // parameter of the specialization.
7370  // DR1315 removes the first bullet, leaving an incoherent set of rules.
7371  // We implement a compromise between the original rules and DR1315:
7372  // -- A specialized non-type template argument shall not be
7373  // type-dependent and the corresponding template parameter
7374  // shall have a non-dependent type.
7375  SourceRange ParamUseRange =
7376  findTemplateParameterInType(Param->getDepth(), ArgExpr);
7377  if (ParamUseRange.isValid()) {
7378  if (IsDefaultArgument) {
7379  S.Diag(TemplateNameLoc,
7380  diag::err_dependent_non_type_arg_in_partial_spec);
7381  S.Diag(ParamUseRange.getBegin(),
7382  diag::note_dependent_non_type_default_arg_in_partial_spec)
7383  << ParamUseRange;
7384  } else {
7385  S.Diag(ParamUseRange.getBegin(),
7386  diag::err_dependent_non_type_arg_in_partial_spec)
7387  << ParamUseRange;
7388  }
7389  return true;
7390  }
7391 
7392  ParamUseRange = findTemplateParameter(
7393  Param->getDepth(), Param->getTypeSourceInfo()->getTypeLoc());
7394  if (ParamUseRange.isValid()) {
7395  S.Diag(IsDefaultArgument ? TemplateNameLoc : ArgExpr->getBeginLoc(),
7396  diag::err_dependent_typed_non_type_arg_in_partial_spec)
7397  << Param->getType();
7398  S.Diag(Param->getLocation(), diag::note_template_param_here)
7399  << (IsDefaultArgument ? ParamUseRange : SourceRange())
7400  << ParamUseRange;
7401  return true;
7402  }
7403  }
7404 
7405  return false;
7406 }
7407 
7408 /// Check the non-type template arguments of a class template
7409 /// partial specialization according to C++ [temp.class.spec]p9.
7410 ///
7411 /// \param TemplateNameLoc the location of the template name.
7412 /// \param PrimaryTemplate the template parameters of the primary class
7413 /// template.
7414 /// \param NumExplicit the number of explicitly-specified template arguments.
7415 /// \param TemplateArgs the template arguments of the class template
7416 /// partial specialization.
7417 ///
7418 /// \returns \c true if there was an error, \c false otherwise.
7420  SourceLocation TemplateNameLoc, TemplateDecl *PrimaryTemplate,
7421  unsigned NumExplicit, ArrayRef<TemplateArgument> TemplateArgs) {
7422  // We have to be conservative when checking a template in a dependent
7423  // context.
7424  if (PrimaryTemplate->getDeclContext()->isDependentContext())
7425  return false;
7426 
7427  TemplateParameterList *TemplateParams =
7428  PrimaryTemplate->getTemplateParameters();
7429  for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
7431  = dyn_cast<NonTypeTemplateParmDecl>(TemplateParams->getParam(I));
7432  if (!Param)
7433  continue;
7434 
7435  if (CheckNonTypeTemplatePartialSpecializationArgs(*this, TemplateNameLoc,
7436  Param, &TemplateArgs[I],
7437  1, I >= NumExplicit))
7438  return true;
7439  }
7440 
7441  return false;
7442 }
7443 
7445  Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
7446  SourceLocation ModulePrivateLoc, TemplateIdAnnotation &TemplateId,
7447  const ParsedAttributesView &Attr,
7448  MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody) {
7449  assert(TUK != TUK_Reference && "References are not specializations");
7450 
7451  CXXScopeSpec &SS = TemplateId.SS;
7452 
7453  // NOTE: KWLoc is the location of the tag keyword. This will instead
7454  // store the location of the outermost template keyword in the declaration.
7455  SourceLocation TemplateKWLoc = TemplateParameterLists.size() > 0
7456  ? TemplateParameterLists[0]->getTemplateLoc() : KWLoc;
7457  SourceLocation TemplateNameLoc = TemplateId.TemplateNameLoc;
7458  SourceLocation LAngleLoc = TemplateId.LAngleLoc;
7459  SourceLocation RAngleLoc = TemplateId.RAngleLoc;
7460 
7461  // Find the class template we're specializing
7462  TemplateName Name = TemplateId.Template.get();
7463  ClassTemplateDecl *ClassTemplate
7464  = dyn_cast_or_null<ClassTemplateDecl>(Name.getAsTemplateDecl());
7465 
7466  if (!ClassTemplate) {
7467  Diag(TemplateNameLoc, diag::err_not_class_template_specialization)
7468  << (Name.getAsTemplateDecl() &&
7469  isa<TemplateTemplateParmDecl>(Name.getAsTemplateDecl()));
7470  return true;
7471  }
7472 
7473  bool isMemberSpecialization = false;
7474  bool isPartialSpecialization = false;
7475 
7476  // Check the validity of the template headers that introduce this
7477  // template.
7478  // FIXME: We probably shouldn't complain about these headers for
7479  // friend declarations.
7480  bool Invalid = false;
7481  TemplateParameterList *TemplateParams =
7482  MatchTemplateParametersToScopeSpecifier(
7483  KWLoc, TemplateNameLoc, SS, &TemplateId,
7484  TemplateParameterLists, TUK == TUK_Friend, isMemberSpecialization,
7485  Invalid);
7486  if (Invalid)
7487  return true;
7488 
7489  if (TemplateParams && TemplateParams->size() > 0) {
7490  isPartialSpecialization = true;
7491 
7492  if (TUK == TUK_Friend) {
7493  Diag(KWLoc, diag::err_partial_specialization_friend)
7494  << SourceRange(LAngleLoc, RAngleLoc);
7495  return true;
7496  }
7497 
7498  // C++ [temp.class.spec]p10:
7499  // The template parameter list of a specialization shall not
7500  // contain default template argument values.
7501  for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
7502  Decl *Param = TemplateParams->getParam(I);
7503  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
7504  if (TTP->hasDefaultArgument()) {
7505  Diag(TTP->getDefaultArgumentLoc(),
7506  diag::err_default_arg_in_partial_spec);
7507  TTP->removeDefaultArgument();
7508  }
7509  } else if (NonTypeTemplateParmDecl *NTTP
7510  = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
7511  if (Expr *DefArg = NTTP->getDefaultArgument()) {
7512  Diag(NTTP->getDefaultArgumentLoc(),
7513  diag::err_default_arg_in_partial_spec)
7514  << DefArg->getSourceRange();
7515  NTTP->removeDefaultArgument();
7516  }
7517  } else {
7518  TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Param);
7519  if (TTP->hasDefaultArgument()) {
7521  diag::err_default_arg_in_partial_spec)
7522  << TTP->getDefaultArgument().getSourceRange();
7523  TTP->removeDefaultArgument();
7524  }
7525  }
7526  }
7527  } else if (TemplateParams) {
7528  if (TUK == TUK_Friend)
7529  Diag(KWLoc, diag::err_template_spec_friend)
7531  SourceRange(TemplateParams->getTemplateLoc(),
7532  TemplateParams->getRAngleLoc()))
7533  << SourceRange(LAngleLoc, RAngleLoc);
7534  } else {
7535  assert(TUK == TUK_Friend && "should have a 'template<>' for this decl");
7536  }
7537 
7538  // Check that the specialization uses the same tag kind as the
7539  // original template.
7541  assert(Kind != TTK_Enum && "Invalid enum tag in class template spec!");
7542  if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
7543  Kind, TUK == TUK_Definition, KWLoc,
7544  ClassTemplate->getIdentifier())) {
7545  Diag(KWLoc, diag::err_use_with_wrong_tag)
7546  << ClassTemplate
7548  ClassTemplate->getTemplatedDecl()->getKindName());
7549  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
7550  diag::note_previous_use);
7551  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
7552  }
7553 
7554  // Translate the parser's template argument list in our AST format.
7555  TemplateArgumentListInfo TemplateArgs =
7556  makeTemplateArgumentListInfo(*this, TemplateId);
7557 
7558  // Check for unexpanded parameter packs in any of the template arguments.
7559  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
7560  if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
7561  UPPC_PartialSpecialization))
7562  return true;
7563 
7564  // Check that the template argument list is well-formed for this
7565  // template.
7567  if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
7568  TemplateArgs, false, Converted))
7569  return true;
7570 
7571  // Find the class template (partial) specialization declaration that
7572  // corresponds to these arguments.
7573  if (isPartialSpecialization) {
7574  if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, ClassTemplate,
7575  TemplateArgs.size(), Converted))
7576  return true;
7577 
7578  // FIXME: Move this to CheckTemplatePartialSpecializationArgs so we
7579  // also do it during instantiation.
7580  bool InstantiationDependent;
7581  if (!Name.isDependent() &&
7583  TemplateArgs.arguments(), InstantiationDependent)) {
7584  Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
7585  << ClassTemplate->getDeclName();
7586  isPartialSpecialization = false;
7587  }
7588  }
7589 
7590  void *InsertPos = nullptr;
7591  ClassTemplateSpecializationDecl *PrevDecl = nullptr;
7592 
7593  if (isPartialSpecialization)
7594  // FIXME: Template parameter list matters, too
7595  PrevDecl = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
7596  else
7597  PrevDecl = ClassTemplate->findSpecialization(Converted, InsertPos);
7598 
7599  ClassTemplateSpecializationDecl *Specialization = nullptr;
7600 
7601  // Check whether we can declare a class template specialization in
7602  // the current scope.
7603  if (TUK != TUK_Friend &&
7604  CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl,
7605  TemplateNameLoc,
7606  isPartialSpecialization))
7607  return true;
7608 
7609  // The canonical type
7610  QualType CanonType;
7611  if (isPartialSpecialization) {
7612  // Build the canonical type that describes the converted template
7613  // arguments of the class template partial specialization.
7614  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
7615  CanonType = Context.getTemplateSpecializationType(CanonTemplate,
7616  Converted);
7617 
7618  if (Context.hasSameType(CanonType,
7619  ClassTemplate->getInjectedClassNameSpecialization())) {
7620  // C++ [temp.class.spec]p9b3:
7621  //
7622  // -- The argument list of the specialization shall not be identical
7623  // to the implicit argument list of the primary template.
7624  //
7625  // This rule has since been removed, because it's redundant given DR1495,
7626  // but we keep it because it produces better diagnostics and recovery.
7627  Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
7628  << /*class template*/0 << (TUK == TUK_Definition)
7629  << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
7630  return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
7631  ClassTemplate->getIdentifier(),
7632  TemplateNameLoc,
7633  Attr,
7634  TemplateParams,
7635  AS_none, /*ModulePrivateLoc=*/SourceLocation(),
7636  /*FriendLoc*/SourceLocation(),
7637  TemplateParameterLists.size() - 1,
7638  TemplateParameterLists.data());
7639  }
7640 
7641  // Create a new class template partial specialization declaration node.
7643  = cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl);
7646  ClassTemplate->getDeclContext(),
7647  KWLoc, TemplateNameLoc,
7648  TemplateParams,
7649  ClassTemplate,
7650  Converted,
7651  TemplateArgs,
7652  CanonType,
7653  PrevPartial);
7654  SetNestedNameSpecifier(*this, Partial, SS);
7655  if (TemplateParameterLists.size() > 1 && SS.isSet()) {
7656  Partial->setTemplateParameterListsInfo(
7657  Context, TemplateParameterLists.drop_back(1));
7658  }
7659 
7660  if (!PrevPartial)
7661  ClassTemplate->AddPartialSpecialization(Partial, InsertPos);
7662  Specialization = Partial;
7663 
7664  // If we are providing an explicit specialization of a member class
7665  // template specialization, make a note of that.
7666  if (PrevPartial && PrevPartial->getInstantiatedFromMember())
7667  PrevPartial->setMemberSpecialization();
7668 
7669  CheckTemplatePartialSpecialization(Partial);
7670  } else {
7671  // Create a new class template specialization declaration node for
7672  // this explicit specialization or friend declaration.
7673  Specialization
7675  ClassTemplate->getDeclContext(),
7676  KWLoc, TemplateNameLoc,
7677  ClassTemplate,
7678  Converted,
7679  PrevDecl);
7680  SetNestedNameSpecifier(*this, Specialization, SS);
7681  if (TemplateParameterLists.size() > 0) {
7682  Specialization->setTemplateParameterListsInfo(Context,
7683  TemplateParameterLists);
7684  }
7685 
7686  if (!PrevDecl)
7687  ClassTemplate->AddSpecialization(Specialization, InsertPos);
7688 
7689  if (CurContext->isDependentContext()) {
7690  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
7691  CanonType = Context.getTemplateSpecializationType(
7692  CanonTemplate, Converted);
7693  } else {
7694  CanonType = Context.getTypeDeclType(Specialization);
7695  }
7696  }
7697 
7698  // C++ [temp.expl.spec]p6:
7699  // If a template, a member template or the member of a class template is
7700  // explicitly specialized then that specialization shall be declared
7701  // before the first use of that specialization that would cause an implicit
7702  // instantiation to take place, in every translation unit in which such a
7703  // use occurs; no diagnostic is required.
7704  if (PrevDecl && PrevDecl->getPointOfInstantiation().isValid()) {
7705  bool Okay = false;
7706  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
7707  // Is there any previous explicit specialization declaration?
7709  Okay = true;
7710  break;
7711  }
7712  }
7713 
7714  if (!Okay) {
7715  SourceRange Range(TemplateNameLoc, RAngleLoc);
7716  Diag(TemplateNameLoc, diag::err_specialization_after_instantiation)
7717  << Context.getTypeDeclType(Specialization) << Range;
7718 
7719  Diag(PrevDecl->getPointOfInstantiation(),
7720  diag::note_instantiation_required_here)
7721  << (PrevDecl->getTemplateSpecializationKind()
7723  return true;
7724  }
7725  }
7726 
7727  // If this is not a friend, note that this is an explicit specialization.
7728  if (TUK != TUK_Friend)
7730 
7731  // Check that this isn't a redefinition of this specialization.
7732  if (TUK == TUK_Definition) {
7733  RecordDecl *Def = Specialization->getDefinition();
7734  NamedDecl *Hidden = nullptr;
7735  if (Def && SkipBody && !hasVisibleDefinition(Def, &Hidden)) {
7736  SkipBody->ShouldSkip = true;
7737  SkipBody->Previous = Def;
7738  makeMergedDefinitionVisible(Hidden);
7739  } else if (Def) {
7740  SourceRange Range(TemplateNameLoc, RAngleLoc);
7741  Diag(TemplateNameLoc, diag::err_redefinition) << Specialization << Range;
7742  Diag(Def->getLocation(), diag::note_previous_definition);
7743  Specialization->setInvalidDecl();
7744  return true;
7745  }
7746  }
7747 
7748  ProcessDeclAttributeList(S, Specialization, Attr);
7749 
7750  // Add alignment attributes if necessary; these attributes are checked when
7751  // the ASTContext lays out the structure.
7752  if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip)) {
7753  AddAlignmentAttributesForRecord(Specialization);
7754  AddMsStructLayoutForRecord(Specialization);
7755  }
7756 
7757  if (ModulePrivateLoc.isValid())
7758  Diag(Specialization->getLocation(), diag::err_module_private_specialization)
7759  << (isPartialSpecialization? 1 : 0)
7760  << FixItHint::CreateRemoval(ModulePrivateLoc);
7761 
7762  // Build the fully-sugared type for this class template
7763  // specialization as the user wrote in the specialization
7764  // itself. This means that we'll pretty-print the type retrieved
7765  // from the specialization's declaration the way that the user
7766  // actually wrote the specialization, rather than formatting the
7767  // name based on the "canonical" representation used to store the
7768  // template arguments in the specialization.
7769  TypeSourceInfo *WrittenTy
7770  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
7771  TemplateArgs, CanonType);
7772  if (TUK != TUK_Friend) {
7773  Specialization->setTypeAsWritten(WrittenTy);
7774  Specialization->setTemplateKeywordLoc(TemplateKWLoc);
7775  }
7776 
7777  // C++ [temp.expl.spec]p9:
7778  // A template explicit specialization is in the scope of the
7779  // namespace in which the template was defined.
7780  //
7781  // We actually implement this paragraph where we set the semantic
7782  // context (in the creation of the ClassTemplateSpecializationDecl),
7783  // but we also maintain the lexical context where the actual
7784  // definition occurs.
7785  Specialization->setLexicalDeclContext(CurContext);
7786 
7787  // We may be starting the definition of this specialization.
7788  if (TUK == TUK_Definition && (!SkipBody || !SkipBody->ShouldSkip))
7789  Specialization->startDefinition();
7790 
7791  if (TUK == TUK_Friend) {
7792  FriendDecl *Friend = FriendDecl::Create(Context, CurContext,
7793  TemplateNameLoc,
7794  WrittenTy,
7795  /*FIXME:*/KWLoc);
7796  Friend->setAccess(AS_public);
7797  CurContext->addDecl(Friend);
7798  } else {
7799  // Add the specialization into its lexical context, so that it can
7800  // be seen when iterating through the list of declarations in that
7801  // context. However, specializations are not found by name lookup.
7802  CurContext->addDecl(Specialization);
7803  }
7804 
7805  if (SkipBody && SkipBody->ShouldSkip)
7806  return SkipBody->Previous;
7807 
7808  return Specialization;
7809 }
7810 
7812  MultiTemplateParamsArg TemplateParameterLists,
7813  Declarator &D) {
7814  Decl *NewDecl = HandleDeclarator(S, D, TemplateParameterLists);
7815  ActOnDocumentableDecl(NewDecl);
7816  return NewDecl;
7817 }
7818 
7819 /// Strips various properties off an implicit instantiation
7820 /// that has just been explicitly specialized.
7822  D->dropAttr<DLLImportAttr>();
7823  D->dropAttr<DLLExportAttr>();
7824 
7825  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
7826  FD->setInlineSpecified(false);
7827 }
7828 
7829 /// Compute the diagnostic location for an explicit instantiation
7830 // declaration or definition.
7832  NamedDecl* D, SourceLocation PointOfInstantiation) {
7833  // Explicit instantiations following a specialization have no effect and
7834  // hence no PointOfInstantiation. In that case, walk decl backwards
7835  // until a valid name loc is found.
7836  SourceLocation PrevDiagLoc = PointOfInstantiation;
7837  for (Decl *Prev = D; Prev && !PrevDiagLoc.isValid();
7838  Prev = Prev->getPreviousDecl()) {
7839  PrevDiagLoc = Prev->getLocation();
7840  }
7841  assert(PrevDiagLoc.isValid() &&
7842  "Explicit instantiation without point of instantiation?");
7843  return PrevDiagLoc;
7844 }
7845 
7846 /// Diagnose cases where we have an explicit template specialization
7847 /// before/after an explicit template instantiation, producing diagnostics
7848 /// for those cases where they are required and determining whether the
7849 /// new specialization/instantiation will have any effect.
7850 ///
7851 /// \param NewLoc the location of the new explicit specialization or
7852 /// instantiation.
7853 ///
7854 /// \param NewTSK the kind of the new explicit specialization or instantiation.
7855 ///
7856 /// \param PrevDecl the previous declaration of the entity.
7857 ///
7858 /// \param PrevTSK the kind of the old explicit specialization or instantiatin.
7859 ///
7860 /// \param PrevPointOfInstantiation if valid, indicates where the previus
7861 /// declaration was instantiated (either implicitly or explicitly).
7862 ///
7863 /// \param HasNoEffect will be set to true to indicate that the new
7864 /// specialization or instantiation has no effect and should be ignored.
7865 ///
7866 /// \returns true if there was an error that should prevent the introduction of
7867 /// the new declaration into the AST, false otherwise.
7868 bool
7871  NamedDecl *PrevDecl,
7873  SourceLocation PrevPointOfInstantiation,
7874  bool &HasNoEffect) {
7875  HasNoEffect = false;
7876 
7877  switch (NewTSK) {
7878  case TSK_Undeclared:
7880  assert(
7881  (PrevTSK == TSK_Undeclared || PrevTSK == TSK_ImplicitInstantiation) &&
7882  "previous declaration must be implicit!");
7883  return false;
7884 
7886  switch (PrevTSK) {
7887  case TSK_Undeclared:
7889  // Okay, we're just specializing something that is either already
7890  // explicitly specialized or has merely been mentioned without any
7891  // instantiation.
7892  return false;
7893 
7895  if (PrevPointOfInstantiation.isInvalid()) {
7896  // The declaration itself has not actually been instantiated, so it is
7897  // still okay to specialize it.
7898  StripImplicitInstantiation(PrevDecl);
7899  return false;
7900  }
7901  // Fall through
7902  LLVM_FALLTHROUGH;
7903 
7906  assert((PrevTSK == TSK_ImplicitInstantiation ||
7907  PrevPointOfInstantiation.isValid()) &&
7908  "Explicit instantiation without point of instantiation?");
7909 
7910  // C++ [temp.expl.spec]p6:
7911  // If a template, a member template or the member of a class template
7912  // is explicitly specialized then that specialization shall be declared
7913  // before the first use of that specialization that would cause an
7914  // implicit instantiation to take place, in every translation unit in
7915  // which such a use occurs; no diagnostic is required.
7916  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
7917  // Is there any previous explicit specialization declaration?
7919  return false;
7920  }
7921 
7922  Diag(NewLoc, diag::err_specialization_after_instantiation)
7923  << PrevDecl;
7924  Diag(PrevPointOfInstantiation, diag::note_instantiation_required_here)
7925  << (PrevTSK != TSK_ImplicitInstantiation);
7926 
7927  return true;
7928  }
7929  llvm_unreachable("The switch over PrevTSK must be exhaustive.");
7930 
7932  switch (PrevTSK) {
7934  // This explicit instantiation declaration is redundant (that's okay).
7935  HasNoEffect = true;
7936  return false;
7937 
7938  case TSK_Undeclared:
7940  // We're explicitly instantiating something that may have already been
7941  // implicitly instantiated; that's fine.
7942  return false;
7943 
7945  // C++0x [temp.explicit]p4:
7946  // For a given set of template parameters, if an explicit instantiation
7947  // of a template appears after a declaration of an explicit
7948  // specialization for that template, the explicit instantiation has no
7949  // effect.
7950  HasNoEffect = true;
7951  return false;
7952 
7954  // C++0x [temp.explicit]p10:
7955  // If an entity is the subject of both an explicit instantiation
7956  // declaration and an explicit instantiation definition in the same
7957  // translation unit, the definition shall follow the declaration.
7958  Diag(NewLoc,
7959  diag::err_explicit_instantiation_declaration_after_definition);
7960 
7961  // Explicit instantiations following a specialization have no effect and
7962  // hence no PrevPointOfInstantiation. In that case, walk decl backwards
7963  // until a valid name loc is found.
7964  Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
7965  diag::note_explicit_instantiation_definition_here);
7966  HasNoEffect = true;
7967  return false;
7968  }
7969  llvm_unreachable("Unexpected TemplateSpecializationKind!");
7970 
7972  switch (PrevTSK) {
7973  case TSK_Undeclared:
7975  // We're explicitly instantiating something that may have already been
7976  // implicitly instantiated; that's fine.
7977  return false;
7978 
7980  // C++ DR 259, C++0x [temp.explicit]p4:
7981  // For a given set of template parameters, if an explicit
7982  // instantiation of a template appears after a declaration of
7983  // an explicit specialization for that template, the explicit
7984  // instantiation has no effect.
7985  Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
7986  << PrevDecl;
7987  Diag(PrevDecl->getLocation(),
7988  diag::note_previous_template_specialization);
7989  HasNoEffect = true;
7990  return false;
7991 
7993  // We're explicitly instantiating a definition for something for which we
7994  // were previously asked to suppress instantiations. That's fine.
7995 
7996  // C++0x [temp.explicit]p4:
7997  // For a given set of template parameters, if an explicit instantiation
7998  // of a template appears after a declaration of an explicit
7999  // specialization for that template, the explicit instantiation has no
8000  // effect.
8001  for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
8002  // Is there any previous explicit specialization declaration?
8004  HasNoEffect = true;
8005  break;
8006  }
8007  }
8008 
8009  return false;
8010 
8012  // C++0x [temp.spec]p5:
8013  // For a given template and a given set of template-arguments,
8014  // - an explicit instantiation definition shall appear at most once
8015  // in a program,
8016 
8017  // MSVCCompat: MSVC silently ignores duplicate explicit instantiations.
8018  Diag(NewLoc, (getLangOpts().MSVCCompat)
8019  ? diag::ext_explicit_instantiation_duplicate
8020  : diag::err_explicit_instantiation_duplicate)
8021  << PrevDecl;
8022  Diag(DiagLocForExplicitInstantiation(PrevDecl, PrevPointOfInstantiation),
8023  diag::note_previous_explicit_instantiation);
8024  HasNoEffect = true;
8025  return false;
8026  }
8027  }
8028 
8029  llvm_unreachable("Missing specialization/instantiation case?");
8030 }
8031 
8032 /// Perform semantic analysis for the given dependent function
8033 /// template specialization.
8034 ///
8035 /// The only possible way to get a dependent function template specialization
8036 /// is with a friend declaration, like so:
8037 ///
8038 /// \code
8039 /// template <class T> void foo(T);
8040 /// template <class T> class A {
8041 /// friend void foo<>(T);
8042 /// };
8043 /// \endcode
8044 ///
8045 /// There really isn't any useful analysis we can do here, so we
8046 /// just store the information.
8047 bool
8049  const TemplateArgumentListInfo &ExplicitTemplateArgs,
8051  // Remove anything from Previous that isn't a function template in
8052  // the correct context.
8053  DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
8054  LookupResult::Filter F = Previous.makeFilter();
8055  enum DiscardReason { NotAFunctionTemplate, NotAMemberOfEnclosing };
8056  SmallVector<std::pair<DiscardReason, Decl *>, 8> DiscardedCandidates;
8057  while (F.hasNext()) {
8058  NamedDecl *D = F.next()->getUnderlyingDecl();
8059  if (!isa<FunctionTemplateDecl>(D)) {
8060  F.erase();
8061  DiscardedCandidates.push_back(std::make_pair(NotAFunctionTemplate, D));
8062  continue;
8063  }
8064 
8065  if (!FDLookupContext->InEnclosingNamespaceSetOf(
8066  D->getDeclContext()->getRedeclContext())) {
8067  F.erase();
8068  DiscardedCandidates.push_back(std::make_pair(NotAMemberOfEnclosing, D));
8069  continue;
8070  }
8071  }
8072  F.done();
8073 
8074  if (Previous.empty()) {
8075  Diag(FD->getLocation(),
8076  diag::err_dependent_function_template_spec_no_match);
8077  for (auto &P : DiscardedCandidates)
8078  Diag(P.second->getLocation(),
8079  diag::note_dependent_function_template_spec_discard_reason)
8080  << P.first;
8081  return true;
8082  }
8083 
8084  FD->setDependentTemplateSpecialization(Context, Previous.asUnresolvedSet(),
8085  ExplicitTemplateArgs);
8086  return false;
8087 }
8088 
8089 /// Perform semantic analysis for the given function template
8090 /// specialization.
8091 ///
8092 /// This routine performs all of the semantic analysis required for an
8093 /// explicit function template specialization. On successful completion,
8094 /// the function declaration \p FD will become a function template
8095 /// specialization.
8096 ///
8097 /// \param FD the function declaration, which will be updated to become a
8098 /// function template specialization.
8099 ///
8100 /// \param ExplicitTemplateArgs the explicitly-provided template arguments,
8101 /// if any. Note that this may be valid info even when 0 arguments are
8102 /// explicitly provided as in, e.g., \c void sort<>(char*, char*);
8103 /// as it anyway contains info on the angle brackets locations.
8104 ///
8105 /// \param Previous the set of declarations that may be specialized by
8106 /// this function specialization.
8107 ///
8108 /// \param QualifiedFriend whether this is a lookup for a qualified friend
8109 /// declaration with no explicit template argument list that might be
8110 /// befriending a function template specialization.
8112  FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
8113  LookupResult &Previous, bool QualifiedFriend) {
8114  // The set of function template specializations that could match this
8115  // explicit function template specialization.
8116  UnresolvedSet<8> Candidates;
8117  TemplateSpecCandidateSet FailedCandidates(FD->getLocation(),
8118  /*ForTakingAddress=*/false);
8119 
8120  llvm::SmallDenseMap<FunctionDecl *, TemplateArgumentListInfo, 8>
8121  ConvertedTemplateArgs;
8122 
8123  DeclContext *FDLookupContext = FD->getDeclContext()->getRedeclContext();
8124  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
8125  I != E; ++I) {
8126  NamedDecl *Ovl = (*I)->getUnderlyingDecl();
8127  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) {
8128  // Only consider templates found within the same semantic lookup scope as
8129  // FD.
8130  if (!FDLookupContext->InEnclosingNamespaceSetOf(
8131  Ovl->getDeclContext()->getRedeclContext()))
8132  continue;
8133 
8134  // When matching a constexpr member function template specialization
8135  // against the primary template, we don't yet know whether the
8136  // specialization has an implicit 'const' (because we don't know whether
8137  // it will be a static member function until we know which template it
8138  // specializes), so adjust it now assuming it specializes this template.
8139  QualType FT = FD->getType();
8140  if (FD->isConstexpr()) {
8141  CXXMethodDecl *OldMD =
8142  dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
8143  if (OldMD && OldMD->isConst()) {
8144  const FunctionProtoType *FPT = FT->castAs<FunctionProtoType>();
8146  EPI.TypeQuals.addConst();
8147  FT = Context.getFunctionType(FPT->getReturnType(),
8148  FPT->getParamTypes(), EPI);
8149  }
8150  }
8151 
8153  if (ExplicitTemplateArgs)
8154  Args = *ExplicitTemplateArgs;
8155 
8156  // C++ [temp.expl.spec]p11:
8157  // A trailing template-argument can be left unspecified in the
8158  // template-id naming an explicit function template specialization
8159  // provided it can be deduced from the function argument type.
8160  // Perform template argument deduction to determine whether we may be
8161  // specializing this template.
8162  // FIXME: It is somewhat wasteful to build
8163  TemplateDeductionInfo Info(FailedCandidates.getLocation());
8164  FunctionDecl *Specialization = nullptr;
8166  cast<FunctionTemplateDecl>(FunTmpl->getFirstDecl()),
8167  ExplicitTemplateArgs ? &Args : nullptr, FT, Specialization,
8168  Info)) {
8169  // Template argument deduction failed; record why it failed, so
8170  // that we can provide nifty diagnostics.
8171  FailedCandidates.addCandidate().set(
8172  I.getPair(), FunTmpl->getTemplatedDecl(),
8173  MakeDeductionFailureInfo(Context, TDK, Info));
8174  (void)TDK;
8175  continue;
8176  }
8177 
8178  // Target attributes are part of the cuda function signature, so
8179  // the deduced template's cuda target must match that of the
8180  // specialization. Given that C++ template deduction does not
8181  // take target attributes into account, we reject candidates
8182  // here that have a different target.
8183  if (LangOpts.CUDA &&
8184  IdentifyCUDATarget(Specialization,
8185  /* IgnoreImplicitHDAttributes = */ true) !=
8186  IdentifyCUDATarget(FD, /* IgnoreImplicitHDAttributes = */ true)) {
8187  FailedCandidates.addCandidate().set(
8188  I.getPair(), FunTmpl->getTemplatedDecl(),
8189  MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
8190  continue;
8191  }
8192 
8193  // Record this candidate.
8194  if (ExplicitTemplateArgs)
8195  ConvertedTemplateArgs[Specialization] = std::move(Args);
8196  Candidates.addDecl(Specialization, I.getAccess());
8197  }
8198  }
8199 
8200  // For a qualified friend declaration (with no explicit marker to indicate
8201  // that a template specialization was intended), note all (template and
8202  // non-template) candidates.
8203  if (QualifiedFriend && Candidates.empty()) {
8204  Diag(FD->getLocation(), diag::err_qualified_friend_no_match)
8205  << FD->getDeclName() << FDLookupContext;
8206  // FIXME: We should form a single candidate list and diagnose all
8207  // candidates at once, to get proper sorting and limiting.
8208  for (auto *OldND : Previous) {
8209  if (auto *OldFD = dyn_cast<FunctionDecl>(OldND->getUnderlyingDecl()))
8210  NoteOverloadCandidate(OldND, OldFD, FD->getType(), false);
8211  }
8212  FailedCandidates.NoteCandidates(*this, FD->getLocation());
8213  return true;
8214  }
8215 
8216  // Find the most specialized function template.
8217  UnresolvedSetIterator Result = getMostSpecialized(
8218  Candidates.begin(), Candidates.end(), FailedCandidates, FD->getLocation(),
8219  PDiag(diag::err_function_template_spec_no_match) << FD->getDeclName(),
8220  PDiag(diag::err_function_template_spec_ambiguous)
8221  << FD->getDeclName() << (ExplicitTemplateArgs != nullptr),
8222  PDiag(diag::note_function_template_spec_matched));
8223 
8224  if (Result == Candidates.end())
8225  return true;
8226 
8227  // Ignore access information; it doesn't figure into redeclaration checking.
8228  FunctionDecl *Specialization = cast<FunctionDecl>(*Result);
8229 
8231  = Specialization->getTemplateSpecializationInfo();
8232  assert(SpecInfo && "Function template specialization info missing?");
8233 
8234  // Note: do not overwrite location info if previous template
8235  // specialization kind was explicit.
8237  if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation) {
8238  Specialization->setLocation(FD->getLocation());
8239  Specialization->setLexicalDeclContext(FD->getLexicalDeclContext());
8240  // C++11 [dcl.constexpr]p1: An explicit specialization of a constexpr
8241  // function can differ from the template declaration with respect to
8242  // the constexpr specifier.
8243  // FIXME: We need an update record for this AST mutation.
8244  // FIXME: What if there are multiple such prior declarations (for instance,
8245  // from different modules)?
8246  Specialization->setConstexpr(FD->isConstexpr());
8247  }
8248 
8249  // FIXME: Check if the prior specialization has a point of instantiation.
8250  // If so, we have run afoul of .
8251 
8252  // If this is a friend declaration, then we're not really declaring
8253  // an explicit specialization.
8254  bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None);
8255 
8256  // Check the scope of this explicit specialization.
8257  if (!isFriend &&
8259  Specialization->getPrimaryTemplate(),
8260  Specialization, FD->getLocation(),
8261  false))
8262  return true;
8263 
8264  // C++ [temp.expl.spec]p6:
8265  // If a template, a member template or the member of a class template is
8266  // explicitly specialized then that specialization shall be declared
8267  // before the first use of that specialization that would cause an implicit
8268  // instantiation to take place, in every translation unit in which such a
8269  // use occurs; no diagnostic is required.
8270  bool HasNoEffect = false;
8271  if (!isFriend &&
8272  CheckSpecializationInstantiationRedecl(FD->getLocation(),
8274  Specialization,
8275  SpecInfo->getTemplateSpecializationKind(),
8276  SpecInfo->getPointOfInstantiation(),
8277  HasNoEffect))
8278  return true;
8279 
8280  // Mark the prior declaration as an explicit specialization, so that later
8281  // clients know that this is an explicit specialization.
8282  if (!isFriend) {
8283  // Since explicit specializations do not inherit '=delete' from their
8284  // primary function template - check if the 'specialization' that was
8285  // implicitly generated (during template argument deduction for partial
8286  // ordering) from the most specialized of all the function templates that
8287  // 'FD' could have been specializing, has a 'deleted' definition. If so,
8288  // first check that it was implicitly generated during template argument
8289  // deduction by making sure it wasn't referenced, and then reset the deleted
8290  // flag to not-deleted, so that we can inherit that information from 'FD'.
8291  if (Specialization->isDeleted() && !SpecInfo->isExplicitSpecialization() &&
8292  !Specialization->getCanonicalDecl()->isReferenced()) {
8293  // FIXME: This assert will not hold in the presence of modules.
8294  assert(
8295  Specialization->getCanonicalDecl() == Specialization &&
8296  "This must be the only existing declaration of this specialization");
8297  // FIXME: We need an update record for this AST mutation.
8298  Specialization->setDeletedAsWritten(false);
8299  }
8300  // FIXME: We need an update record for this AST mutation.
8302  MarkUnusedFileScopedDecl(Specialization);
8303  }
8304 
8305  // Turn the given function declaration into a function template
8306  // specialization, with the template arguments from the previous
8307  // specialization.
8308  // Take copies of (semantic and syntactic) template argument lists.
8309  const TemplateArgumentList* TemplArgs = new (Context)
8310  TemplateArgumentList(Specialization->getTemplateSpecializationArgs());
8311  FD->setFunctionTemplateSpecialization(
8312  Specialization->getPrimaryTemplate(), TemplArgs, /*InsertPos=*/nullptr,
8313  SpecInfo->getTemplateSpecializationKind(),
8314  ExplicitTemplateArgs ? &ConvertedTemplateArgs[Specialization] : nullptr);
8315 
8316  // A function template specialization inherits the target attributes
8317  // of its template. (We require the attributes explicitly in the
8318  // code to match, but a template may have implicit attributes by
8319  // virtue e.g. of being constexpr, and it passes these implicit
8320  // attributes on to its specializations.)
8321  if (LangOpts.CUDA)
8322  inheritCUDATargetAttrs(FD, *Specialization->getPrimaryTemplate());
8323 
8324  // The "previous declaration" for this function template specialization is
8325  // the prior function template specialization.
8326  Previous.clear();
8327  Previous.addDecl(Specialization);
8328  return false;
8329 }
8330 
8331 /// Perform semantic analysis for the given non-template member
8332 /// specialization.
8333 ///
8334 /// This routine performs all of the semantic analysis required for an
8335 /// explicit member function specialization. On successful completion,
8336 /// the function declaration \p FD will become a member function
8337 /// specialization.
8338 ///
8339 /// \param Member the member declaration, which will be updated to become a
8340 /// specialization.
8341 ///
8342 /// \param Previous the set of declarations, one of which may be specialized
8343 /// by this function specialization; the set will be modified to contain the
8344 /// redeclared member.
8345 bool
8347  assert(!isa<TemplateDecl>(Member) && "Only for non-template members");
8348 
8349  // Try to find the member we are instantiating.
8350  NamedDecl *FoundInstantiation = nullptr;
8351  NamedDecl *Instantiation = nullptr;
8352  NamedDecl *InstantiatedFrom = nullptr;
8353  MemberSpecializationInfo *MSInfo = nullptr;
8354 
8355  if (Previous.empty()) {
8356  // Nowhere to look anyway.
8357  } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Member)) {
8358  for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
8359  I != E; ++I) {
8360  NamedDecl *D = (*I)->getUnderlyingDecl();
8361  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
8362  QualType Adjusted = Function->getType();
8363  if (!hasExplicitCallingConv(Adjusted))
8364  Adjusted = adjustCCAndNoReturn(Adjusted, Method->getType());
8365  // This doesn't handle deduced return types, but both function
8366  // declarations should be undeduced at this point.
8367  if (Context.hasSameType(Adjusted, Method->getType())) {
8368  FoundInstantiation = *I;
8369  Instantiation = Method;
8370  InstantiatedFrom = Method->getInstantiatedFromMemberFunction();
8371  MSInfo = Method->getMemberSpecializationInfo();
8372  break;
8373  }
8374  }
8375  }
8376  } else if (isa<VarDecl>(Member)) {
8377  VarDecl *PrevVar;
8378  if (Previous.isSingleResult() &&
8379  (PrevVar = dyn_cast<VarDecl>(Previous.getFoundDecl())))
8380  if (PrevVar->isStaticDataMember()) {
8381  FoundInstantiation = Previous.getRepresentativeDecl();
8382  Instantiation = PrevVar;
8383  InstantiatedFrom = PrevVar->getInstantiatedFromStaticDataMember();
8384  MSInfo = PrevVar->getMemberSpecializationInfo();
8385  }
8386  } else if (isa<RecordDecl>(Member)) {
8387  CXXRecordDecl *PrevRecord;
8388  if (Previous.isSingleResult() &&
8389  (PrevRecord = dyn_cast<CXXRecordDecl>(Previous.getFoundDecl()))) {
8390  FoundInstantiation = Previous.getRepresentativeDecl();
8391  Instantiation = PrevRecord;
8392  InstantiatedFrom = PrevRecord->getInstantiatedFromMemberClass();
8393  MSInfo = PrevRecord->getMemberSpecializationInfo();
8394  }
8395  } else if (isa<EnumDecl>(Member)) {
8396  EnumDecl *PrevEnum;
8397  if (Previous.isSingleResult() &&
8398  (PrevEnum = dyn_cast<EnumDecl>(Previous.getFoundDecl()))) {
8399  FoundInstantiation = Previous.getRepresentativeDecl();
8400  Instantiation = PrevEnum;
8401  InstantiatedFrom = PrevEnum->getInstantiatedFromMemberEnum();
8402  MSInfo = PrevEnum->getMemberSpecializationInfo();
8403  }
8404  }
8405 
8406  if (!Instantiation) {
8407  // There is no previous declaration that matches. Since member
8408  // specializations are always out-of-line, the caller will complain about
8409  // this mismatch later.
8410  return false;
8411  }
8412 
8413  // A member specialization in a friend declaration isn't really declaring
8414  // an explicit specialization, just identifying a specific (possibly implicit)
8415  // specialization. Don't change the template specialization kind.
8416  //
8417  // FIXME: Is this really valid? Other compilers reject.
8418  if (Member->getFriendObjectKind() != Decl::FOK_None) {
8419  // Preserve instantiation information.
8420  if (InstantiatedFrom && isa<CXXMethodDecl>(Member)) {
8421  cast<CXXMethodDecl>(Member)->setInstantiationOfMemberFunction(
8422  cast<CXXMethodDecl>(InstantiatedFrom),
8423  cast<CXXMethodDecl>(Instantiation)->getTemplateSpecializationKind());
8424  } else if (InstantiatedFrom && isa<CXXRecordDecl>(Member)) {
8425  cast<CXXRecordDecl>(Member)->setInstantiationOfMemberClass(
8426  cast<CXXRecordDecl>(InstantiatedFrom),
8427  cast<CXXRecordDecl>(Instantiation)->getTemplateSpecializationKind());
8428  }
8429 
8430  Previous.clear();
8431  Previous.addDecl(FoundInstantiation);
8432  return false;
8433  }
8434 
8435  // Make sure that this is a specialization of a member.
8436  if (!InstantiatedFrom) {
8437  Diag(Member->getLocation(), diag::err_spec_member_not_instantiated)
8438  << Member;
8439  Diag(Instantiation->getLocation(), diag::note_specialized_decl);
8440  return true;
8441  }
8442 
8443  // C++ [temp.expl.spec]p6:
8444  // If a template, a member template or the member of a class template is
8445  // explicitly specialized then that specialization shall be declared
8446  // before the first use of that specialization that would cause an implicit
8447  // instantiation to take place, in every translation unit in which such a
8448  // use occurs; no diagnostic is required.
8449  assert(MSInfo && "Member specialization info missing?");
8450 
8451  bool HasNoEffect = false;
8452  if (CheckSpecializationInstantiationRedecl(Member->getLocation(),
8454  Instantiation,
8456  MSInfo->getPointOfInstantiation(),
8457  HasNoEffect))
8458  return true;
8459 
8460  // Check the scope of this explicit specialization.
8462  InstantiatedFrom,
8463  Instantiation, Member->getLocation(),
8464  false))
8465  return true;
8466 
8467  // Note that this member specialization is an "instantiation of" the
8468  // corresponding member of the original template.
8469  if (auto *MemberFunction = dyn_cast<FunctionDecl>(Member)) {
8470  FunctionDecl *InstantiationFunction = cast<FunctionDecl>(Instantiation);
8471  if (InstantiationFunction->getTemplateSpecializationKind() ==
8473  // Explicit specializations of member functions of class templates do not
8474  // inherit '=delete' from the member function they are specializing.
8475  if (InstantiationFunction->isDeleted()) {
8476  // FIXME: This assert will not hold in the presence of modules.
8477  assert(InstantiationFunction->getCanonicalDecl() ==
8478  InstantiationFunction);
8479  // FIXME: We need an update record for this AST mutation.
8480  InstantiationFunction->setDeletedAsWritten(false);
8481  }
8482  }
8483 
8484  MemberFunction->setInstantiationOfMemberFunction(
8485  cast<CXXMethodDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
8486  } else if (auto *MemberVar = dyn_cast<VarDecl>(Member)) {
8487  MemberVar->setInstantiationOfStaticDataMember(
8488  cast<VarDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
8489  } else if (auto *MemberClass = dyn_cast<CXXRecordDecl>(Member)) {
8490  MemberClass->setInstantiationOfMemberClass(
8491  cast<CXXRecordDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
8492  } else if (auto *MemberEnum = dyn_cast<EnumDecl>(Member)) {
8493  MemberEnum->setInstantiationOfMemberEnum(
8494  cast<EnumDecl>(InstantiatedFrom), TSK_ExplicitSpecialization);
8495  } else {
8496  llvm_unreachable("unknown member specialization kind");
8497  }
8498 
8499  // Save the caller the trouble of having to figure out which declaration
8500  // this specialization matches.
8501  Previous.clear();
8502  Previous.addDecl(FoundInstantiation);
8503  return false;
8504 }
8505 
8506 /// Complete the explicit specialization of a member of a class template by
8507 /// updating the instantiated member to be marked as an explicit specialization.
8508 ///
8509 /// \param OrigD The member declaration instantiated from the template.
8510 /// \param Loc The location of the explicit specialization of the member.
8511 template<typename DeclT>
8512 static void completeMemberSpecializationImpl(Sema &S, DeclT *OrigD,
8513  SourceLocation Loc) {
8514  if (OrigD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
8515  return;
8516 
8517  // FIXME: Inform AST mutation listeners of this AST mutation.
8518  // FIXME: If there are multiple in-class declarations of the member (from
8519  // multiple modules, or a declaration and later definition of a member type),
8520  // should we update all of them?
8521  OrigD->setTemplateSpecializationKind(TSK_ExplicitSpecialization);
8522  OrigD->setLocation(Loc);
8523 }
8524 
8527  NamedDecl *Instantiation = cast<NamedDecl>(Member->getCanonicalDecl());
8528  if (Instantiation == Member)
8529  return;
8530 
8531  if (auto *Function = dyn_cast<CXXMethodDecl>(Instantiation))
8532  completeMemberSpecializationImpl(*this, Function, Member->getLocation());
8533  else if (auto *Var = dyn_cast<VarDecl>(Instantiation))
8534  completeMemberSpecializationImpl(*this, Var, Member->getLocation());
8535  else if (auto *Record = dyn_cast<CXXRecordDecl>(Instantiation))
8536  completeMemberSpecializationImpl(*this, Record, Member->getLocation());
8537  else if (auto *Enum = dyn_cast<EnumDecl>(Instantiation))
8538  completeMemberSpecializationImpl(*this, Enum, Member->getLocation());
8539  else
8540  llvm_unreachable("unknown member specialization kind");
8541 }
8542 
8543 /// Check the scope of an explicit instantiation.
8544 ///
8545 /// \returns true if a serious error occurs, false otherwise.
8547  SourceLocation InstLoc,
8548  bool WasQualifiedName) {
8550  DeclContext *CurContext = S.CurContext->getRedeclContext();
8551 
8552  if (CurContext->isRecord()) {
8553  S.Diag(InstLoc, diag::err_explicit_instantiation_in_class)
8554  << D;
8555  return true;
8556  }
8557 
8558  // C++11 [temp.explicit]p3:
8559  // An explicit instantiation shall appear in an enclosing namespace of its
8560  // template. If the name declared in the explicit instantiation is an
8561  // unqualified name, the explicit instantiation shall appear in the
8562  // namespace where its template is declared or, if that namespace is inline
8563  // (7.3.1), any namespace from its enclosing namespace set.
8564  //
8565  // This is DR275, which we do not retroactively apply to C++98/03.
8566  if (WasQualifiedName) {
8567  if (CurContext->Encloses(OrigContext))
8568  return false;
8569  } else {
8570  if (CurContext->InEnclosingNamespaceSetOf(OrigContext))
8571  return false;
8572  }
8573 
8574  if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(OrigContext)) {
8575  if (WasQualifiedName)
8576  S.Diag(InstLoc,
8577  S.getLangOpts().CPlusPlus11?
8578  diag::err_explicit_instantiation_out_of_scope :
8579  diag::warn_explicit_instantiation_out_of_scope_0x)
8580  << D << NS;
8581  else
8582  S.Diag(InstLoc,
8583  S.getLangOpts().CPlusPlus11?
8584  diag::err_explicit_instantiation_unqualified_wrong_namespace :
8585  diag::warn_explicit_instantiation_unqualified_wrong_namespace_0x)
8586  << D << NS;
8587  } else
8588  S.Diag(InstLoc,
8589  S.getLangOpts().CPlusPlus11?
8590  diag::err_explicit_instantiation_must_be_global :
8591  diag::warn_explicit_instantiation_must_be_global_0x)
8592  << D;
8593  S.Diag(D->getLocation(), diag::note_explicit_instantiation_here);
8594  return false;
8595 }
8596 
8597 /// Determine whether the given scope specifier has a template-id in it.
8599  if (!SS.isSet())
8600  return false;
8601 
8602  // C++11 [temp.explicit]p3:
8603  // If the explicit instantiation is for a member function, a member class
8604  // or a static data member of a class template specialization, the name of
8605  // the class template specialization in the qualified-id for the member
8606  // name shall be a simple-template-id.
8607  //
8608  // C++98 has the same restriction, just worded differently.
8609  for (NestedNameSpecifier *NNS = SS.getScopeRep(); NNS;
8610  NNS = NNS->getPrefix())
8611  if (const Type *T = NNS->getAsType())
8612  if (isa<TemplateSpecializationType>(T))
8613  return true;
8614 
8615  return false;
8616 }
8617 
8618 /// Make a dllexport or dllimport attr on a class template specialization take
8619 /// effect.
8622  auto *A = cast_or_null<InheritableAttr>(getDLLAttr(Def));
8623  assert(A && "dllExportImportClassTemplateSpecialization called "
8624  "on Def without dllexport or dllimport");
8625 
8626  // We reject explicit instantiations in class scope, so there should
8627  // never be any delayed exported classes to worry about.
8628  assert(S.DelayedDllExportClasses.empty() &&
8629  "delayed exports present at explicit instantiation");
8631 
8632  // Propagate attribute to base class templates.
8633  for (auto &B : Def->bases()) {
8634  if (auto *BT = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
8635  B.getType()->getAsCXXRecordDecl()))
8637  }
8638 
8640 }
8641 
8642 // Explicit instantiation of a class template specialization
8644  Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc,
8645  unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS,
8646  TemplateTy TemplateD, SourceLocation TemplateNameLoc,
8647  SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn,
8648  SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {
8649  // Find the class template we're specializing
8650  TemplateName Name = TemplateD.get();
8651  TemplateDecl *TD = Name.getAsTemplateDecl();
8652  // Check that the specialization uses the same tag kind as the
8653  // original template.
8655  assert(Kind != TTK_Enum &&
8656  "Invalid enum tag in class template explicit instantiation!");
8657 
8658  ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(TD);
8659 
8660  if (!ClassTemplate) {
8661  NonTagKind NTK = getNonTagTypeDeclKind(TD, Kind);
8662  Diag(TemplateNameLoc, diag::err_tag_reference_non_tag) << TD << NTK << Kind;
8663  Diag(TD->getLocation(), diag::note_previous_use);
8664  return true;
8665  }
8666 
8667  if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(),
8668  Kind, /*isDefinition*/false, KWLoc,
8669  ClassTemplate->getIdentifier())) {
8670  Diag(KWLoc, diag::err_use_with_wrong_tag)
8671  << ClassTemplate
8673  ClassTemplate->getTemplatedDecl()->getKindName());
8674  Diag(ClassTemplate->getTemplatedDecl()->getLocation(),
8675  diag::note_previous_use);
8676  Kind = ClassTemplate->getTemplatedDecl()->getTagKind();
8677  }
8678 
8679  // C++0x [temp.explicit]p2:
8680  // There are two forms of explicit instantiation: an explicit instantiation
8681  // definition and an explicit instantiation declaration. An explicit
8682  // instantiation declaration begins with the extern keyword. [...]
8683  TemplateSpecializationKind TSK = ExternLoc.isInvalid()
8686 
8688  // Check for dllexport class template instantiation declarations.
8689  for (const ParsedAttr &AL : Attr) {
8690  if (AL.getKind() == ParsedAttr::AT_DLLExport) {
8691  Diag(ExternLoc,
8692  diag::warn_attribute_dllexport_explicit_instantiation_decl);
8693  Diag(AL.getLoc(), diag::note_attribute);
8694  break;
8695  }
8696  }
8697 
8698  if (auto *A = ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {
8699  Diag(ExternLoc,
8700  diag::warn_attribute_dllexport_explicit_instantiation_decl);
8701  Diag(A->getLocation(), diag::note_attribute);
8702  }
8703  }
8704 
8705  // In MSVC mode, dllimported explicit instantiation definitions are treated as
8706  // instantiation declarations for most purposes.
8707  bool DLLImportExplicitInstantiationDef = false;
8709  Context.getTargetInfo().getCXXABI().isMicrosoft()) {
8710  // Check for dllimport class template instantiation definitions.
8711  bool DLLImport =
8712  ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
8713  for (const ParsedAttr &AL : Attr) {
8714  if (AL.getKind() == ParsedAttr::AT_DLLImport)
8715  DLLImport = true;
8716  if (AL.getKind() == ParsedAttr::AT_DLLExport) {
8717  // dllexport trumps dllimport here.
8718  DLLImport = false;
8719  break;
8720  }
8721  }
8722  if (DLLImport) {
8724  DLLImportExplicitInstantiationDef = true;
8725  }
8726  }
8727 
8728  // Translate the parser's template argument list in our AST format.
8729  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
8730  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
8731 
8732  // Check that the template argument list is well-formed for this
8733  // template.
8735  if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
8736  TemplateArgs, false, Converted))
8737  return true;
8738 
8739  // Find the class template specialization declaration that
8740  // corresponds to these arguments.
8741  void *InsertPos = nullptr;
8743  = ClassTemplate->findSpecialization(Converted, InsertPos);
8744 
8745  TemplateSpecializationKind PrevDecl_TSK
8746  = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared;
8747 
8748  // C++0x [temp.explicit]p2:
8749  // [...] An explicit instantiation shall appear in an enclosing
8750  // namespace of its template. [...]
8751  //
8752  // This is C++ DR 275.
8753  if (CheckExplicitInstantiationScope(*this, ClassTemplate, TemplateNameLoc,
8754  SS.isSet()))
8755  return true;
8756 
8757  ClassTemplateSpecializationDecl *Specialization = nullptr;
8758 
8759  bool HasNoEffect = false;
8760  if (PrevDecl) {
8761  if (CheckSpecializationInstantiationRedecl(TemplateNameLoc, TSK,
8762  PrevDecl, PrevDecl_TSK,
8763  PrevDecl->getPointOfInstantiation(),
8764  HasNoEffect))
8765  return PrevDecl;
8766 
8767  // Even though HasNoEffect == true means that this explicit instantiation
8768  // has no effect on semantics, we go on to put its syntax in the AST.
8769 
8770  if (PrevDecl_TSK == TSK_ImplicitInstantiation ||
8771  PrevDecl_TSK == TSK_Undeclared) {
8772  // Since the only prior class template specialization with these
8773  // arguments was referenced but not declared, reuse that
8774  // declaration node as our own, updating the source location
8775  // for the template name to reflect our new declaration.
8776  // (Other source locations will be updated later.)
8777  Specialization = PrevDecl;
8778  Specialization->setLocation(TemplateNameLoc);
8779  PrevDecl = nullptr;
8780  }
8781 
8782  if (PrevDecl_TSK == TSK_ExplicitInstantiationDeclaration &&
8783  DLLImportExplicitInstantiationDef) {
8784  // The new specialization might add a dllimport attribute.
8785  HasNoEffect = false;
8786  }
8787  }
8788 
8789  if (!Specialization) {
8790  // Create a new class template specialization declaration node for
8791  // this explicit specialization.
8792  Specialization
8794  ClassTemplate->getDeclContext(),
8795  KWLoc, TemplateNameLoc,
8796  ClassTemplate,
8797  Converted,
8798  PrevDecl);
8799  SetNestedNameSpecifier(*this, Specialization, SS);
8800 
8801  if (!HasNoEffect && !PrevDecl) {
8802  // Insert the new specialization.
8803  ClassTemplate->AddSpecialization(Specialization, InsertPos);
8804  }
8805  }
8806 
8807  // Build the fully-sugared type for this explicit instantiation as
8808  // the user wrote in the explicit instantiation itself. This means
8809  // that we'll pretty-print the type retrieved from the
8810  // specialization's declaration the way that the user actually wrote
8811  // the explicit instantiation, rather than formatting the name based
8812  // on the "canonical" representation used to store the template
8813  // arguments in the specialization.
8814  TypeSourceInfo *WrittenTy
8815  = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
8816  TemplateArgs,
8817  Context.getTypeDeclType(Specialization));
8818  Specialization->setTypeAsWritten(WrittenTy);
8819 
8820  // Set source locations for keywords.
8821  Specialization->setExternLoc(ExternLoc);
8822  Specialization->setTemplateKeywordLoc(TemplateLoc);
8823  Specialization->setBraceRange(SourceRange());
8824 
8825  bool PreviouslyDLLExported = Specialization->hasAttr<DLLExportAttr>();
8826  ProcessDeclAttributeList(S, Specialization, Attr);
8827 
8828  // Add the explicit instantiation into its lexical context. However,
8829  // since explicit instantiations are never found by name lookup, we
8830  // just put it into the declaration context directly.
8831  Specialization->setLexicalDeclContext(CurContext);
8832  CurContext->addDecl(Specialization);
8833 
8834  // Syntax is now OK, so return if it has no other effect on semantics.
8835  if (HasNoEffect) {
8836  // Set the template specialization kind.
8837  Specialization->setTemplateSpecializationKind(TSK);
8838  return Specialization;
8839  }
8840 
8841  // C++ [temp.explicit]p3:
8842  // A definition of a class template or class member template
8843  // shall be in scope at the point of the explicit instantiation of
8844  // the class template or class member template.
8845  //
8846  // This check comes when we actually try to perform the
8847  // instantiation.
8849  = cast_or_null<ClassTemplateSpecializationDecl>(
8850  Specialization->getDefinition());
8851  if (!Def)
8852  InstantiateClassTemplateSpecialization(TemplateNameLoc, Specialization, TSK);
8853  else if (TSK == TSK_ExplicitInstantiationDefinition) {
8854  MarkVTableUsed(TemplateNameLoc, Specialization, true);
8855  Specialization->setPointOfInstantiation(Def->getPointOfInstantiation());
8856  }
8857 
8858  // Instantiate the members of this class template specialization.
8859  Def = cast_or_null<ClassTemplateSpecializationDecl>(
8860  Specialization->getDefinition());
8861  if (Def) {
8863  // Fix a TSK_ExplicitInstantiationDeclaration followed by a
8864  // TSK_ExplicitInstantiationDefinition
8865  if (Old_TSK == TSK_ExplicitInstantiationDeclaration &&
8867  DLLImportExplicitInstantiationDef)) {
8868  // FIXME: Need to notify the ASTMutationListener that we did this.
8870 
8871  if (!getDLLAttr(Def) && getDLLAttr(Specialization) &&
8872  (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
8873  Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
8874  // In the MS ABI, an explicit instantiation definition can add a dll
8875  // attribute to a template with a previous instantiation declaration.
8876  // MinGW doesn't allow this.
8877  auto *A = cast<InheritableAttr>(
8878  getDLLAttr(Specialization)->clone(getASTContext()));
8879  A->setInherited(true);
8880  Def->addAttr(A);
8882  }
8883  }
8884 
8885  // Fix a TSK_ImplicitInstantiation followed by a
8886  // TSK_ExplicitInstantiationDefinition
8887  bool NewlyDLLExported =
8888  !PreviouslyDLLExported && Specialization->hasAttr<DLLExportAttr>();
8889  if (Old_TSK == TSK_ImplicitInstantiation && NewlyDLLExported &&
8890  (Context.getTargetInfo().getCXXABI().isMicrosoft() ||
8891  Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment())) {
8892  // In the MS ABI, an explicit instantiation definition can add a dll
8893  // attribute to a template with a previous implicit instantiation.
8894  // MinGW doesn't allow this. We limit clang to only adding dllexport, to
8895  // avoid potentially strange codegen behavior. For example, if we extend
8896  // this conditional to dllimport, and we have a source file calling a
8897  // method on an implicitly instantiated template class instance and then
8898  // declaring a dllimport explicit instantiation definition for the same
8899  // template class, the codegen for the method call will not respect the
8900  // dllimport, while it will with cl. The Def will already have the DLL
8901  // attribute, since the Def and Specialization will be the same in the
8902  // case of Old_TSK == TSK_ImplicitInstantiation, and we already added the
8903  // attribute to the Specialization; we just need to make it take effect.
8904  assert(Def == Specialization &&
8905  "Def and Specialization should match for implicit instantiation");
8907  }
8908 
8909  // Set the template specialization kind. Make sure it is set before
8910  // instantiating the members which will trigger ASTConsumer callbacks.
8911  Specialization->setTemplateSpecializationKind(TSK);
8912  InstantiateClassTemplateSpecializationMembers(TemplateNameLoc, Def, TSK);
8913  } else {
8914 
8915  // Set the template specialization kind.
8916  Specialization->setTemplateSpecializationKind(TSK);
8917  }
8918 
8919  return Specialization;
8920 }
8921 
8922 // Explicit instantiation of a member class of a class template.
8923 DeclResult
8925  SourceLocation TemplateLoc, unsigned TagSpec,
8926  SourceLocation KWLoc, CXXScopeSpec &SS,
8927  IdentifierInfo *Name, SourceLocation NameLoc,
8928  const ParsedAttributesView &Attr) {
8929 
8930  bool Owned = false;
8931  bool IsDependent = false;
8932  Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference,
8933  KWLoc, SS, Name, NameLoc, Attr, AS_none,
8934  /*ModulePrivateLoc=*/SourceLocation(),
8935  MultiTemplateParamsArg(), Owned, IsDependent,
8936  SourceLocation(), false, TypeResult(),
8937  /*IsTypeSpecifier*/false,
8938  /*IsTemplateParamOrArg*/false);
8939  assert(!IsDependent && "explicit instantiation of dependent name not yet handled");
8940 
8941  if (!TagD)
8942  return true;
8943 
8944  TagDecl *Tag = cast<TagDecl>(TagD);
8945  assert(!Tag->isEnum() && "shouldn't see enumerations here");
8946 
8947  if (Tag->isInvalidDecl())
8948  return true;
8949 
8950  CXXRecordDecl *Record = cast<CXXRecordDecl>(Tag);
8951  CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
8952  if (!Pattern) {
8953  Diag(TemplateLoc, diag::err_explicit_instantiation_nontemplate_type)
8954  << Context.getTypeDeclType(Record);
8955  Diag(Record->getLocation(), diag::note_nontemplate_decl_here);
8956  return true;
8957  }
8958 
8959  // C++0x [temp.explicit]p2:
8960  // If the explicit instantiation is for a class or member class, the
8961  // elaborated-type-specifier in the declaration shall include a
8962  // simple-template-id.
8963  //
8964  // C++98 has the same restriction, just worded differently.
8965  if (!ScopeSpecifierHasTemplateId(SS))
8966  Diag(TemplateLoc, diag::ext_explicit_instantiation_without_qualified_id)
8967  << Record << SS.getRange();
8968 
8969  // C++0x [temp.explicit]p2:
8970  // There are two forms of explicit instantiation: an explicit instantiation
8971  // definition and an explicit instantiation declaration. An explicit
8972  // instantiation declaration begins with the extern keyword. [...]
8976 
8977  // C++0x [temp.explicit]p2:
8978  // [...] An explicit instantiation shall appear in an enclosing
8979  // namespace of its template. [...]
8980  //
8981  // This is C++ DR 275.
8982  CheckExplicitInstantiationScope(*this, Record, NameLoc, true);
8983 
8984  // Verify that it is okay to explicitly instantiate here.
8985  CXXRecordDecl *PrevDecl
8986  = cast_or_null<CXXRecordDecl>(Record->getPreviousDecl());
8987  if (!PrevDecl && Record->getDefinition())
8988  PrevDecl = Record;
8989  if (PrevDecl) {
8991  bool HasNoEffect = false;
8992  assert(MSInfo && "No member specialization information?");
8993  if (CheckSpecializationInstantiationRedecl(TemplateLoc, TSK,
8994  PrevDecl,
8996  MSInfo->getPointOfInstantiation(),
8997  HasNoEffect))
8998  return true;
8999  if (HasNoEffect)
9000  return TagD;
9001  }
9002 
9003  CXXRecordDecl *RecordDef
9004  = cast_or_null<CXXRecordDecl>(Record->getDefinition());
9005  if (!RecordDef) {
9006  // C++ [temp.explicit]p3:
9007  // A definition of a member class of a class template shall be in scope
9008  // at the point of an explicit instantiation of the member class.
9009  CXXRecordDecl *Def
9010  = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
9011  if (!Def) {
9012  Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
9013  << 0 << Record->getDeclName() << Record->getDeclContext();
9014  Diag(Pattern->getLocation(), diag::note_forward_declaration)
9015  << Pattern;
9016  return true;
9017  } else {
9018  if (InstantiateClass(NameLoc, Record, Def,
9019  getTemplateInstantiationArgs(Record),
9020  TSK))
9021  return true;
9022 
9023  RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition());
9024  if (!RecordDef)
9025  return true;
9026  }
9027  }
9028 
9029  // Instantiate all of the members of the class.
9030  InstantiateClassMembers(NameLoc, RecordDef,
9031  getTemplateInstantiationArgs(Record), TSK);
9032 
9034  MarkVTableUsed(NameLoc, RecordDef, true);
9035 
9036  // FIXME: We don't have any representation for explicit instantiations of
9037  // member classes. Such a representation is not needed for compilation, but it
9038  // should be available for clients that want to see all of the declarations in
9039  // the source code.
9040  return TagD;
9041 }
9042 
9044  SourceLocation ExternLoc,
9045  SourceLocation TemplateLoc,
9046  Declarator &D) {
9047  // Explicit instantiations always require a name.
9048  // TODO: check if/when DNInfo should replace Name.
9049  DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
9050  DeclarationName Name = NameInfo.getName();
9051  if (!Name) {
9052  if (!D.isInvalidType())
9054  diag::err_explicit_instantiation_requires_name)
9055  << D.getDeclSpec().getSourceRange() << D.getSourceRange();
9056 
9057  return true;
9058  }
9059 
9060  // The scope passed in may not be a decl scope. Zip up the scope tree until
9061  // we find one that is.
9062  while ((S->getFlags() & Scope::DeclScope) == 0 ||
9063  (S->getFlags() & Scope::TemplateParamScope) != 0)
9064  S = S->getParent();
9065 
9066  // Determine the type of the declaration.
9067  TypeSourceInfo *T = GetTypeForDeclarator(D, S);
9068  QualType R = T->getType();
9069  if (R.isNull())
9070  return true;
9071 
9072  // C++ [dcl.stc]p1:
9073  // A storage-class-specifier shall not be specified in [...] an explicit
9074  // instantiation (14.7.2) directive.
9076  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_of_typedef)
9077  << Name;
9078  return true;
9079  } else if (D.getDeclSpec().getStorageClassSpec()
9081  // Complain about then remove the storage class specifier.
9082  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_storage_class)
9084 
9086  }
9087 
9088  // C++0x [temp.explicit]p1:
9089  // [...] An explicit instantiation of a function template shall not use the
9090  // inline or constexpr specifiers.
9091  // Presumably, this also applies to member functions of class templates as
9092  // well.
9093  if (D.getDeclSpec().isInlineSpecified())
9095  getLangOpts().CPlusPlus11 ?
9096  diag::err_explicit_instantiation_inline :
9097  diag::warn_explicit_instantiation_inline_0x)
9100  // FIXME: Add a fix-it to remove the 'constexpr' and add a 'const' if one is
9101  // not already specified.
9103  diag::err_explicit_instantiation_constexpr);
9104 
9105  // A deduction guide is not on the list of entities that can be explicitly
9106  // instantiated.
9108  Diag(D.getDeclSpec().getBeginLoc(), diag::err_deduction_guide_specialized)
9109  << /*explicit instantiation*/ 0;
9110  return true;
9111  }
9112 
9113  // C++0x [temp.explicit]p2:
9114  // There are two forms of explicit instantiation: an explicit instantiation
9115  // definition and an explicit instantiation declaration. An explicit
9116  // instantiation declaration begins with the extern keyword. [...]
9120 
9121  LookupResult Previous(*this, NameInfo, LookupOrdinaryName);
9122  LookupParsedName(Previous, S, &D.getCXXScopeSpec());
9123 
9124  if (!R->isFunctionType()) {
9125  // C++ [temp.explicit]p1:
9126  // A [...] static data member of a class template can be explicitly
9127  // instantiated from the member definition associated with its class
9128  // template.
9129  // C++1y [temp.explicit]p1:
9130  // A [...] variable [...] template specialization can be explicitly
9131  // instantiated from its template.
9132  if (Previous.isAmbiguous())
9133  return true;
9134 
9135  VarDecl *Prev = Previous.getAsSingle<VarDecl>();
9136  VarTemplateDecl *PrevTemplate = Previous.getAsSingle<VarTemplateDecl>();
9137 
9138  if (!PrevTemplate) {
9139  if (!Prev || !Prev->isStaticDataMember()) {
9140  // We expect to see a data data member here.
9141  Diag(D.getIdentifierLoc(), diag::err_explicit_instantiation_not_known)
9142  << Name;
9143  for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
9144  P != PEnd; ++P)
9145  Diag((*P)->getLocation(), diag::note_explicit_instantiation_here);
9146  return true;
9147  }
9148 
9149  if (!Prev->getInstantiatedFromStaticDataMember()) {
9150  // FIXME: Check for explicit specialization?
9151  Diag(D.getIdentifierLoc(),
9152  diag::err_explicit_instantiation_data_member_not_instantiated)
9153  << Prev;
9154  Diag(Prev->getLocation(), diag::note_explicit_instantiation_here);
9155  // FIXME: Can we provide a note showing where this was declared?
9156  return true;
9157  }
9158  } else {
9159  // Explicitly instantiate a variable template.
9160 
9161  // C++1y [dcl.spec.auto]p6:
9162  // ... A program that uses auto or decltype(auto) in a context not
9163  // explicitly allowed in this section is ill-formed.
9164  //
9165  // This includes auto-typed variable template instantiations.
9166  if (R->isUndeducedType()) {
9167  Diag(T->getTypeLoc().getBeginLoc(),
9168  diag::err_auto_not_allowed_var_inst);
9169  return true;
9170  }
9171 
9173  // C++1y [temp.explicit]p3:
9174  // If the explicit instantiation is for a variable, the unqualified-id
9175  // in the declaration shall be a template-id.
9176  Diag(D.getIdentifierLoc(),
9177  diag::err_explicit_instantiation_without_template_id)
9178  << PrevTemplate;
9179  Diag(PrevTemplate->getLocation(),
9180  diag::note_explicit_instantiation_here);
9181  return true;
9182  }
9183 
9184  // Translate the parser's template argument list into our AST format.
9185  TemplateArgumentListInfo TemplateArgs =
9187 
9188  DeclResult Res = CheckVarTemplateId(PrevTemplate, TemplateLoc,
9189  D.getIdentifierLoc(), TemplateArgs);
9190  if (Res.isInvalid())
9191  return true;
9192 
9193  // Ignore access control bits, we don't need them for redeclaration
9194  // checking.
9195  Prev = cast<VarDecl>(Res.get());
9196  }
9197 
9198  // C++0x [temp.explicit]p2:
9199  // If the explicit instantiation is for a member function, a member class
9200  // or a static data member of a class template specialization, the name of
9201  // the class template specialization in the qualified-id for the member
9202  // name shall be a simple-template-id.
9203  //
9204  // C++98 has the same restriction, just worded differently.
9205  //
9206  // This does not apply to variable template specializations, where the
9207  // template-id is in the unqualified-id instead.
9208  if (!ScopeSpecifierHasTemplateId(D.getCXXScopeSpec()) && !PrevTemplate)
9209  Diag(D.getIdentifierLoc(),
9210  diag::ext_explicit_instantiation_without_qualified_id)
9211  << Prev << D.getCXXScopeSpec().getRange();
9212 
9213  // Check the scope of this explicit instantiation.
9214  CheckExplicitInstantiationScope(*this, Prev, D.getIdentifierLoc(), true);
9215 
9216  // Verify that it is okay to explicitly instantiate here.
9219  bool HasNoEffect = false;
9220  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK, Prev,
9221  PrevTSK, POI, HasNoEffect))
9222  return true;
9223 
9224  if (!HasNoEffect) {
9225  // Instantiate static data member or variable template.
9226  Prev->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
9227  // Merge attributes.
9228  ProcessDeclAttributeList(S, Prev, D.getDeclSpec().getAttributes());
9230  InstantiateVariableDefinition(D.getIdentifierLoc(), Prev);
9231  }
9232 
9233  // Check the new variable specialization against the parsed input.
9234  if (PrevTemplate && Prev && !Context.hasSameType(Prev->getType(), R)) {
9235  Diag(T->getTypeLoc().getBeginLoc(),
9236  diag::err_invalid_var_template_spec_type)
9237  << 0 << PrevTemplate << R << Prev->getType();
9238  Diag(PrevTemplate->getLocation(), diag::note_template_declared_here)
9239  << 2 << PrevTemplate->getDeclName();
9240  return true;
9241  }
9242 
9243  // FIXME: Create an ExplicitInstantiation node?
9244  return (Decl*) nullptr;
9245  }
9246 
9247  // If the declarator is a template-id, translate the parser's template
9248  // argument list into our AST format.
9249  bool HasExplicitTemplateArgs = false;
9250  TemplateArgumentListInfo TemplateArgs;
9252  TemplateArgs = makeTemplateArgumentListInfo(*this, *D.getName().TemplateId);
9253  HasExplicitTemplateArgs = true;
9254  }
9255 
9256  // C++ [temp.explicit]p1:
9257  // A [...] function [...] can be explicitly instantiated from its template.
9258  // A member function [...] of a class template can be explicitly
9259  // instantiated from the member definition associated with its class
9260  // template.
9261  UnresolvedSet<8> TemplateMatches;
9262  FunctionDecl *NonTemplateMatch = nullptr;
9263  TemplateSpecCandidateSet FailedCandidates(D.getIdentifierLoc());
9264  for (LookupResult::iterator P = Previous.begin(), PEnd = Previous.end();
9265  P != PEnd; ++P) {
9266  NamedDecl *Prev = *P;
9267  if (!HasExplicitTemplateArgs) {
9268  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Prev)) {
9269  QualType Adjusted = adjustCCAndNoReturn(R, Method->getType(),
9270  /*AdjustExceptionSpec*/true);
9271  if (Context.hasSameUnqualifiedType(Method->getType(), Adjusted)) {
9272  if (Method->getPrimaryTemplate()) {
9273  TemplateMatches.addDecl(Method, P.getAccess());
9274  } else {
9275  // FIXME: Can this assert ever happen? Needs a test.
9276  assert(!NonTemplateMatch && "Multiple NonTemplateMatches");
9277  NonTemplateMatch = Method;
9278  }
9279  }
9280  }
9281  }
9282 
9283  FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Prev);
9284  if (!FunTmpl)
9285  continue;
9286 
9287  TemplateDeductionInfo Info(FailedCandidates.getLocation());
9288  FunctionDecl *Specialization = nullptr;
9289  if (TemplateDeductionResult TDK
9290  = DeduceTemplateArguments(FunTmpl,
9291  (HasExplicitTemplateArgs ? &TemplateArgs
9292  : nullptr),
9293  R, Specialization, Info)) {
9294  // Keep track of almost-matches.
9295  FailedCandidates.addCandidate()
9296  .set(P.getPair(), FunTmpl->getTemplatedDecl(),
9297  MakeDeductionFailureInfo(Context, TDK, Info));
9298  (void)TDK;
9299  continue;
9300  }
9301 
9302  // Target attributes are part of the cuda function signature, so
9303  // the cuda target of the instantiated function must match that of its
9304  // template. Given that C++ template deduction does not take
9305  // target attributes into account, we reject candidates here that
9306  // have a different target.
9307  if (LangOpts.CUDA &&
9308  IdentifyCUDATarget(Specialization,
9309  /* IgnoreImplicitHDAttributes = */ true) !=
9310  IdentifyCUDATarget(D.getDeclSpec().getAttributes())) {
9311  FailedCandidates.addCandidate().set(
9312  P.getPair(), FunTmpl->getTemplatedDecl(),
9313  MakeDeductionFailureInfo(Context, TDK_CUDATargetMismatch, Info));
9314  continue;
9315  }
9316 
9317  TemplateMatches.addDecl(Specialization, P.getAccess());
9318  }
9319 
9320  FunctionDecl *Specialization = NonTemplateMatch;
9321  if (!Specialization) {
9322  // Find the most specialized function template specialization.
9323  UnresolvedSetIterator Result = getMostSpecialized(
9324  TemplateMatches.begin(), TemplateMatches.end(), FailedCandidates,
9325  D.getIdentifierLoc(),
9326  PDiag(diag::err_explicit_instantiation_not_known) << Name,
9327  PDiag(diag::err_explicit_instantiation_ambiguous) << Name,
9328  PDiag(diag::note_explicit_instantiation_candidate));
9329 
9330  if (Result == TemplateMatches.end())
9331  return true;
9332 
9333  // Ignore access control bits, we don't need them for redeclaration checking.
9334  Specialization = cast<FunctionDecl>(*Result);
9335  }
9336 
9337  // C++11 [except.spec]p4
9338  // In an explicit instantiation an exception-specification may be specified,
9339  // but is not required.
9340  // If an exception-specification is specified in an explicit instantiation
9341  // directive, it shall be compatible with the exception-specifications of
9342  // other declarations of that function.
9343  if (auto *FPT = R->getAs<FunctionProtoType>())
9344  if (FPT->hasExceptionSpec()) {
9345  unsigned DiagID =
9346  diag::err_mismatched_exception_spec_explicit_instantiation;
9347  if (getLangOpts().MicrosoftExt)
9348  DiagID = diag::ext_mismatched_exception_spec_explicit_instantiation;
9349  bool Result = CheckEquivalentExceptionSpec(
9350  PDiag(DiagID) << Specialization->getType(),
9351  PDiag(diag::note_explicit_instantiation_here),
9352  Specialization->getType()->getAs<FunctionProtoType>(),
9353  Specialization->getLocation(), FPT, D.getBeginLoc());
9354  // In Microsoft mode, mismatching exception specifications just cause a
9355  // warning.
9356  if (!getLangOpts().MicrosoftExt && Result)
9357  return true;
9358  }
9359 
9360  if (Specialization->getTemplateSpecializationKind() == TSK_Undeclared) {
9361  Diag(D.getIdentifierLoc(),
9362  diag::err_explicit_instantiation_member_function_not_instantiated)
9363  << Specialization
9364  << (Specialization->getTemplateSpecializationKind() ==
9366  Diag(Specialization->getLocation(), diag::note_explicit_instantiation_here);
9367  return true;
9368  }
9369 
9370  FunctionDecl *PrevDecl = Specialization->getPreviousDecl();
9371  if (!PrevDecl && Specialization->isThisDeclarationADefinition())
9372  PrevDecl = Specialization;
9373 
9374  if (PrevDecl) {
9375  bool HasNoEffect = false;
9376  if (CheckSpecializationInstantiationRedecl(D.getIdentifierLoc(), TSK,
9377  PrevDecl,
9378  PrevDecl->getTemplateSpecializationKind(),
9379  PrevDecl->getPointOfInstantiation(),
9380  HasNoEffect))
9381  return true;
9382 
9383  // FIXME: We may still want to build some representation of this
9384  // explicit specialization.
9385  if (HasNoEffect)
9386  return (Decl*) nullptr;
9387  }
9388 
9389  ProcessDeclAttributeList(S, Specialization, D.getDeclSpec().getAttributes());
9390 
9391  // In MSVC mode, dllimported explicit instantiation definitions are treated as
9392  // instantiation declarations.
9394  Specialization->hasAttr<DLLImportAttr>() &&
9395  Context.getTargetInfo().getCXXABI().isMicrosoft())
9397 
9398  Specialization->setTemplateSpecializationKind(TSK, D.getIdentifierLoc());
9399 
9400  if (Specialization->isDefined()) {
9401  // Let the ASTConsumer know that this function has been explicitly
9402  // instantiated now, and its linkage might have changed.
9403  Consumer.HandleTopLevelDecl(DeclGroupRef(Specialization));
9404  } else if (TSK == TSK_ExplicitInstantiationDefinition)
9405  InstantiateFunctionDefinition(D.getIdentifierLoc(), Specialization);
9406 
9407  // C++0x [temp.explicit]p2:
9408  // If the explicit instantiation is for a member function, a member class
9409  // or a static data member of a class template specialization, the name of
9410  // the class template specialization in the qualified-id for the member
9411  // name shall be a simple-template-id.
9412  //
9413  // C++98 has the same restriction, just worded differently.
9414  FunctionTemplateDecl *FunTmpl = Specialization->getPrimaryTemplate();
9415  if (D.getName().getKind() != UnqualifiedIdKind::IK_TemplateId && !FunTmpl &&
9416  D.getCXXScopeSpec().isSet() &&
9418  Diag(D.getIdentifierLoc(),
9419  diag::ext_explicit_instantiation_without_qualified_id)
9420  << Specialization << D.getCXXScopeSpec().getRange();
9421 
9423  FunTmpl? (NamedDecl *)FunTmpl
9424  : Specialization->getInstantiatedFromMemberFunction(),
9425  D.getIdentifierLoc(),
9426  D.getCXXScopeSpec().isSet());
9427 
9428  // FIXME: Create some kind of ExplicitInstantiationDecl here.
9429  return (Decl*) nullptr;
9430 }
9431 
9432 TypeResult
9433 Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
9434  const CXXScopeSpec &SS, IdentifierInfo *Name,
9435  SourceLocation TagLoc, SourceLocation NameLoc) {
9436  // This has to hold, because SS is expected to be defined.
9437  assert(Name && "Expected a name in a dependent tag");
9438 
9439  NestedNameSpecifier *NNS = SS.getScopeRep();
9440  if (!NNS)
9441  return true;
9442 
9444 
9445  if (TUK == TUK_Declaration || TUK == TUK_Definition) {
9446  Diag(NameLoc, diag::err_dependent_tag_decl)
9447  << (TUK == TUK_Definition) << Kind << SS.getRange();
9448  return true;
9449  }
9450 
9451  // Create the resulting type.
9453  QualType Result = Context.getDependentNameType(Kwd, NNS, Name);
9454 
9455  // Create type-source location information for this type.
9456  TypeLocBuilder TLB;
9458  TL.setElaboratedKeywordLoc(TagLoc);
9459  TL.setQualifierLoc(SS.getWithLocInContext(Context));
9460  TL.setNameLoc(NameLoc);
9461  return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
9462 }
9463 
9464 TypeResult
9466  const CXXScopeSpec &SS, const IdentifierInfo &II,
9467  SourceLocation IdLoc) {
9468  if (SS.isInvalid())
9469  return true;
9470 
9471  if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
9472  Diag(TypenameLoc,
9473  getLangOpts().CPlusPlus11 ?
9474  diag::warn_cxx98_compat_typename_outside_of_template :
9475  diag::ext_typename_outside_of_template)
9476  << FixItHint::CreateRemoval(TypenameLoc);
9477 
9478  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
9479  QualType T = CheckTypenameType(TypenameLoc.isValid()? ETK_Typename : ETK_None,
9480  TypenameLoc, QualifierLoc, II, IdLoc);
9481  if (T.isNull())
9482  return true;
9483 
9484  TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
9485  if (isa<DependentNameType>(T)) {
9487  TL.setElaboratedKeywordLoc(TypenameLoc);
9488  TL.setQualifierLoc(QualifierLoc);
9489  TL.setNameLoc(IdLoc);
9490  } else {
9492  TL.setElaboratedKeywordLoc(TypenameLoc);
9493  TL.setQualifierLoc(QualifierLoc);
9494  TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
9495  }
9496 
9497  return CreateParsedType(T, TSI);
9498 }
9499 
9500 TypeResult
9502  SourceLocation TypenameLoc,
9503  const CXXScopeSpec &SS,
9504  SourceLocation TemplateKWLoc,
9505  TemplateTy TemplateIn,
9506  IdentifierInfo *TemplateII,
9507  SourceLocation TemplateIILoc,
9508  SourceLocation LAngleLoc,
9509  ASTTemplateArgsPtr TemplateArgsIn,
9510  SourceLocation RAngleLoc) {
9511  if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
9512  Diag(TypenameLoc,
9513  getLangOpts().CPlusPlus11 ?
9514  diag::warn_cxx98_compat_typename_outside_of_template :
9515  diag::ext_typename_outside_of_template)
9516  << FixItHint::CreateRemoval(TypenameLoc);
9517 
9518  // Strangely, non-type results are not ignored by this lookup, so the
9519  // program is ill-formed if it finds an injected-class-name.
9520  if (TypenameLoc.isValid()) {
9521  auto *LookupRD =
9522  dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS, false));
9523  if (LookupRD && LookupRD->getIdentifier() == TemplateII) {
9524  Diag(TemplateIILoc,
9525  diag::ext_out_of_line_qualified_id_type_names_constructor)
9526  << TemplateII << 0 /*injected-class-name used as template name*/
9527  << (TemplateKWLoc.isValid() ? 1 : 0 /*'template'/'typename' keyword*/);
9528  }
9529  }
9530 
9531  // Translate the parser's template argument list in our AST format.
9532  TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
9533  translateTemplateArguments(TemplateArgsIn, TemplateArgs);
9534 
9535  TemplateName Template = TemplateIn.get();
9536  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
9537  // Construct a dependent template specialization type.
9538  assert(DTN && "dependent template has non-dependent name?");
9539  assert(DTN->getQualifier() == SS.getScopeRep());
9541  DTN->getQualifier(),
9542  DTN->getIdentifier(),
9543  TemplateArgs);
9544 
9545  // Create source-location information for this type.
9546  TypeLocBuilder Builder;
9549  SpecTL.setElaboratedKeywordLoc(TypenameLoc);
9550  SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
9551  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
9552  SpecTL.setTemplateNameLoc(TemplateIILoc);
9553  SpecTL.setLAngleLoc(LAngleLoc);
9554  SpecTL.setRAngleLoc(RAngleLoc);
9555  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
9556  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
9557  return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
9558  }
9559 
9560  QualType T = CheckTemplateIdType(Template, TemplateIILoc, TemplateArgs);
9561  if (T.isNull())
9562  return true;
9563 
9564  // Provide source-location information for the template specialization type.
9565  TypeLocBuilder Builder;
9567  = Builder.push<TemplateSpecializationTypeLoc>(T);
9568  SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
9569  SpecTL.setTemplateNameLoc(TemplateIILoc);
9570  SpecTL.setLAngleLoc(LAngleLoc);
9571  SpecTL.setRAngleLoc(RAngleLoc);
9572  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
9573  SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
9574 
9575  T = Context.getElaboratedType(ETK_Typename, SS.getScopeRep(), T);
9576  ElaboratedTypeLoc TL = Builder.push<ElaboratedTypeLoc>(T);
9577  TL.setElaboratedKeywordLoc(TypenameLoc);
9578  TL.setQualifierLoc(SS.getWithLocInContext(Context));
9579 
9580  TypeSourceInfo *TSI = Builder.getTypeSourceInfo(Context, T);
9581  return CreateParsedType(T, TSI);
9582 }
9583 
9584 
9585 /// Determine whether this failed name lookup should be treated as being
9586 /// disabled by a usage of std::enable_if.
9588  SourceRange &CondRange, Expr *&Cond) {
9589  // We must be looking for a ::type...
9590  if (!II.isStr("type"))
9591  return false;
9592 
9593  // ... within an explicitly-written template specialization...
9594  if (!NNS || !NNS.getNestedNameSpecifier()->getAsType())
9595  return false;
9596  TypeLoc EnableIfTy = NNS.getTypeLoc();
9597  TemplateSpecializationTypeLoc EnableIfTSTLoc =
9598  EnableIfTy.getAs<TemplateSpecializationTypeLoc>();
9599  if (!EnableIfTSTLoc || EnableIfTSTLoc.getNumArgs() == 0)
9600  return false;
9601  const TemplateSpecializationType *EnableIfTST = EnableIfTSTLoc.getTypePtr();
9602 
9603  // ... which names a complete class template declaration...
9604  const TemplateDecl *EnableIfDecl =
9605  EnableIfTST->getTemplateName().getAsTemplateDecl();
9606  if (!EnableIfDecl || EnableIfTST->isIncompleteType())
9607  return false;
9608 
9609  // ... called "enable_if".
9610  const IdentifierInfo *EnableIfII =
9611  EnableIfDecl->getDeclName().getAsIdentifierInfo();
9612  if (!EnableIfII || !EnableIfII->isStr("enable_if"))
9613  return false;
9614 
9615  // Assume the first template argument is the condition.
9616  CondRange = EnableIfTSTLoc.getArgLoc(0).getSourceRange();
9617 
9618  // Dig out the condition.
9619  Cond = nullptr;
9620  if (EnableIfTSTLoc.getArgLoc(0).getArgument().getKind()
9622  return true;
9623 
9624  Cond = EnableIfTSTLoc.getArgLoc(0).getSourceExpression();
9625 
9626  // Ignore Boolean literals; they add no value.
9627  if (isa<CXXBoolLiteralExpr>(Cond->IgnoreParenCasts()))
9628  Cond = nullptr;
9629 
9630  return true;
9631 }
9632 
9633 /// Build the type that describes a C++ typename specifier,
9634 /// e.g., "typename T::type".
9635 QualType
9637  SourceLocation KeywordLoc,
9638  NestedNameSpecifierLoc QualifierLoc,
9639  const IdentifierInfo &II,
9640  SourceLocation IILoc) {
9641  CXXScopeSpec SS;
9642  SS.Adopt(QualifierLoc);
9643 
9644  DeclContext *Ctx = computeDeclContext(SS);
9645  if (!Ctx) {
9646  // If the nested-name-specifier is dependent and couldn't be
9647  // resolved to a type, build a typename type.
9648  assert(QualifierLoc.getNestedNameSpecifier()->isDependent());
9649  return Context.getDependentNameType(Keyword,
9650  QualifierLoc.getNestedNameSpecifier(),
9651  &II);
9652  }
9653 
9654  // If the nested-name-specifier refers to the current instantiation,
9655  // the "typename" keyword itself is superfluous. In C++03, the
9656  // program is actually ill-formed. However, DR 382 (in C++0x CD1)
9657  // allows such extraneous "typename" keywords, and we retroactively
9658  // apply this DR to C++03 code with only a warning. In any case we continue.
9659 
9660  if (RequireCompleteDeclContext(SS, Ctx))
9661  return QualType();
9662 
9663  DeclarationName Name(&II);
9664  LookupResult Result(*this, Name, IILoc, LookupOrdinaryName);
9665  LookupQualifiedName(Result, Ctx, SS);
9666  unsigned DiagID = 0;
9667  Decl *Referenced = nullptr;
9668  switch (Result.getResultKind()) {
9669  case LookupResult::NotFound: {
9670  // If we're looking up 'type' within a template named 'enable_if', produce
9671  // a more specific diagnostic.
9672  SourceRange CondRange;
9673  Expr *Cond = nullptr;
9674  if (isEnableIf(QualifierLoc, II, CondRange, Cond)) {
9675  // If we have a condition, narrow it down to the specific failed
9676  // condition.
9677  if (Cond) {
9678  Expr *FailedCond;
9679  std::string FailedDescription;
9680  std::tie(FailedCond, FailedDescription) =
9681  findFailedBooleanCondition(Cond);
9682 
9683  Diag(FailedCond->getExprLoc(),
9684  diag::err_typename_nested_not_found_requirement)
9685  << FailedDescription
9686  << FailedCond->getSourceRange();
9687  return QualType();
9688  }
9689 
9690  Diag(CondRange.getBegin(), diag::err_typename_nested_not_found_enable_if)
9691  << Ctx << CondRange;
9692  return QualType();
9693  }
9694 
9695  DiagID = diag::err_typename_nested_not_found;
9696  break;
9697  }
9698 
9700  // We found a using declaration that is a value. Most likely, the using
9701  // declaration itself is meant to have the 'typename' keyword.
9702  SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
9703  IILoc);
9704  Diag(IILoc, diag::err_typename_refers_to_using_value_decl)
9705  << Name << Ctx << FullRange;
9706  if (UnresolvedUsingValueDecl *Using
9707  = dyn_cast<UnresolvedUsingValueDecl>(Result.getRepresentativeDecl())){
9708  SourceLocation Loc = Using->getQualifierLoc().getBeginLoc();
9709  Diag(Loc, diag::note_using_value_decl_missing_typename)
9710  << FixItHint::CreateInsertion(Loc, "typename ");
9711  }
9712  }
9713  // Fall through to create a dependent typename type, from which we can recover
9714  // better.
9715  LLVM_FALLTHROUGH;
9716 
9718  // Okay, it's a member of an unknown instantiation.
9719  return Context.getDependentNameType(Keyword,
9720  QualifierLoc.getNestedNameSpecifier(),
9721  &II);
9722 
9723  case LookupResult::Found:
9724  if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
9725  // C++ [class.qual]p2:
9726  // In a lookup in which function names are not ignored and the
9727  // nested-name-specifier nominates a class C, if the name specified
9728  // after the nested-name-specifier, when looked up in C, is the
9729  // injected-class-name of C [...] then the name is instead considered
9730  // to name the constructor of class C.
9731  //
9732  // Unlike in an elaborated-type-specifier, function names are not ignored
9733  // in typename-specifier lookup. However, they are ignored in all the
9734  // contexts where we form a typename type with no keyword (that is, in
9735  // mem-initializer-ids, base-specifiers, and elaborated-type-specifiers).
9736  //
9737  // FIXME: That's not strictly true: mem-initializer-id lookup does not
9738  // ignore functions, but that appears to be an oversight.
9739  auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(Ctx);
9740  auto *FoundRD = dyn_cast<CXXRecordDecl>(Type);
9741  if (Keyword == ETK_Typename && LookupRD && FoundRD &&
9742  FoundRD->isInjectedClassName() &&
9743  declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
9744  Diag(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)
9745  << &II << 1 << 0 /*'typename' keyword used*/;
9746 
9747  // We found a type. Build an ElaboratedType, since the
9748  // typename-specifier was just sugar.
9749  MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
9750  return Context.getElaboratedType(Keyword,
9751  QualifierLoc.getNestedNameSpecifier(),
9752  Context.getTypeDeclType(Type));
9753  }
9754 
9755  // C++ [dcl.type.simple]p2:
9756  // A type-specifier of the form
9757  // typename[opt] nested-name-specifier[opt] template-name
9758  // is a placeholder for a deduced class type [...].
9759  if (getLangOpts().CPlusPlus17) {
9760  if (auto *TD = getAsTypeTemplateDecl(Result.getFoundDecl())) {
9761  return Context.getElaboratedType(
9762  Keyword, QualifierLoc.getNestedNameSpecifier(),
9764  QualType(), false));
9765  }
9766  }
9767 
9768  DiagID = diag::err_typename_nested_not_type;
9769  Referenced = Result.getFoundDecl();
9770  break;
9771 
9773  DiagID = diag::err_typename_nested_not_type;
9774  Referenced = *Result.begin();
9775  break;
9776 
9778  return QualType();
9779  }
9780 
9781  // If we get here, it's because name lookup did not find a
9782  // type. Emit an appropriate diagnostic and return an error.
9783  SourceRange FullRange(KeywordLoc.isValid() ? KeywordLoc : SS.getBeginLoc(),
9784  IILoc);
9785  Diag(IILoc, DiagID) << FullRange << Name << Ctx;
9786  if (Referenced)
9787  Diag(Referenced->getLocation(), diag::note_typename_refers_here)
9788  << Name;
9789  return QualType();
9790 }
9791 
9792 namespace {
9793  // See Sema::RebuildTypeInCurrentInstantiation
9794  class CurrentInstantiationRebuilder
9795  : public TreeTransform<CurrentInstantiationRebuilder> {
9796  SourceLocation Loc;
9797  DeclarationName Entity;
9798 
9799  public:
9801 
9802  CurrentInstantiationRebuilder(Sema &SemaRef,
9803  SourceLocation Loc,
9804  DeclarationName Entity)
9806  Loc(Loc), Entity(Entity) { }
9807 
9808  /// Determine whether the given type \p T has already been
9809  /// transformed.
9810  ///
9811  /// For the purposes of type reconstruction, a type has already been
9812  /// transformed if it is NULL or if it is not dependent.
9813  bool AlreadyTransformed(QualType T) {
9814  return T.isNull() || !T->isDependentType();
9815  }
9816 
9817  /// Returns the location of the entity whose type is being
9818  /// rebuilt.
9819  SourceLocation getBaseLocation() { return Loc; }
9820 
9821  /// Returns the name of the entity whose type is being rebuilt.
9822  DeclarationName getBaseEntity() { return Entity; }
9823 
9824  /// Sets the "base" location and entity when that
9825  /// information is known based on another transformation.
9826  void setBase(SourceLocation Loc, DeclarationName Entity) {
9827  this->Loc = Loc;
9828  this->Entity = Entity;
9829  }
9830 
9831  ExprResult TransformLambdaExpr(LambdaExpr *E) {
9832  // Lambdas never need to be transformed.
9833  return E;
9834  }
9835  };
9836 } // end anonymous namespace
9837 
9838 /// Rebuilds a type within the context of the current instantiation.
9839 ///
9840 /// The type \p T is part of the type of an out-of-line member definition of
9841 /// a class template (or class template partial specialization) that was parsed
9842 /// and constructed before we entered the scope of the class template (or
9843 /// partial specialization thereof). This routine will rebuild that type now
9844 /// that we have entered the declarator's scope, which may produce different
9845 /// canonical types, e.g.,
9846 ///
9847 /// \code
9848 /// template<typename T>
9849 /// struct X {
9850 /// typedef T* pointer;
9851 /// pointer data();
9852 /// };
9853 ///
9854 /// template<typename T>
9855 /// typename X<T>::pointer X<T>::data() { ... }
9856 /// \endcode
9857 ///
9858 /// Here, the type "typename X<T>::pointer" will be created as a DependentNameType,
9859 /// since we do not know that we can look into X<T> when we parsed the type.
9860 /// This function will rebuild the type, performing the lookup of "pointer"
9861 /// in X<T> and returning an ElaboratedType whose canonical type is the same
9862 /// as the canonical type of T*, allowing the return types of the out-of-line
9863 /// definition and the declaration to match.
9865  SourceLocation Loc,
9866  DeclarationName Name) {
9867  if (!T || !T->getType()->isDependentType())
9868  return T;
9869 
9870  CurrentInstantiationRebuilder Rebuilder(*this, Loc, Name);
9871  return Rebuilder.TransformType(T);
9872 }
9873 
9875  CurrentInstantiationRebuilder Rebuilder(*this, E->getExprLoc(),
9876  DeclarationName());
9877  return Rebuilder.TransformExpr(E);
9878 }
9879 
9881  if (SS.isInvalid())
9882  return true;
9883 
9884  NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
9885  CurrentInstantiationRebuilder Rebuilder(*this, SS.getRange().getBegin(),
9886  DeclarationName());
9887  NestedNameSpecifierLoc Rebuilt
9888  = Rebuilder.TransformNestedNameSpecifierLoc(QualifierLoc);
9889  if (!Rebuilt)
9890  return true;
9891 
9892  SS.Adopt(Rebuilt);
9893  return false;
9894 }
9895 
9896 /// Rebuild the template parameters now that we know we're in a current
9897 /// instantiation.
9899  TemplateParameterList *Params) {
9900  for (unsigned I = 0, N = Params->size(); I != N; ++I) {
9901  Decl *Param = Params->getParam(I);
9902 
9903  // There is nothing to rebuild in a type parameter.
9904  if (isa<TemplateTypeParmDecl>(Param))
9905  continue;
9906 
9907  // Rebuild the template parameter list of a template template parameter.
9908  if (TemplateTemplateParmDecl *TTP
9909  = dyn_cast<TemplateTemplateParmDecl>(Param)) {
9910  if (RebuildTemplateParamsInCurrentInstantiation(
9911  TTP->getTemplateParameters()))
9912  return true;
9913 
9914  continue;
9915  }
9916 
9917  // Rebuild the type of a non-type template parameter.
9918  NonTypeTemplateParmDecl *NTTP = cast<NonTypeTemplateParmDecl>(Param);
9919  TypeSourceInfo *NewTSI
9920  = RebuildTypeInCurrentInstantiation(NTTP->getTypeSourceInfo(),
9921  NTTP->getLocation(),
9922  NTTP->getDeclName());
9923  if (!NewTSI)
9924  return true;
9925 
9926  if (NewTSI->getType()->isUndeducedType()) {
9927  // C++17 [temp.dep.expr]p3:
9928  // An id-expression is type-dependent if it contains
9929  // - an identifier associated by name lookup with a non-type
9930  // template-parameter declared with a type that contains a
9931  // placeholder type (7.1.7.4),
9932  NewTSI = SubstAutoTypeSourceInfo(NewTSI, Context.DependentTy);
9933  }
9934 
9935  if (NewTSI != NTTP->getTypeSourceInfo()) {
9936  NTTP->setTypeSourceInfo(NewTSI);
9937  NTTP->setType(NewTSI->getType());
9938  }
9939  }
9940 
9941  return false;
9942 }
9943 
9944 /// Produces a formatted string that describes the binding of
9945 /// template parameters to template arguments.
9946 std::string
9948  const TemplateArgumentList &Args) {
9949  return getTemplateArgumentBindingsText(Params, Args.data(), Args.size());
9950 }
9951 
9952 std::string
9954  const TemplateArgument *Args,
9955  unsigned NumArgs) {
9956  SmallString<128> Str;
9957  llvm::raw_svector_ostream Out(Str);
9958 
9959  if (!Params || Params->size() == 0 || NumArgs == 0)
9960  return std::string();
9961 
9962  for (unsigned I = 0, N = Params->size(); I != N; ++I) {
9963  if (I >= NumArgs)
9964  break;
9965 
9966  if (I == 0)
9967  Out << "[with ";
9968  else
9969  Out << ", ";
9970 
9971  if (const IdentifierInfo *Id = Params->getParam(I)->getIdentifier()) {
9972  Out << Id->getName();
9973  } else {
9974  Out << '$' << I;
9975  }
9976 
9977  Out << " = ";
9978  Args[I].print(getPrintingPolicy(), Out);
9979  }
9980 
9981  Out << ']';
9982  return Out.str();
9983 }
9984 
9986  CachedTokens &Toks) {
9987  if (!FD)
9988  return;
9989 
9990  auto LPT = llvm::make_unique<LateParsedTemplate>();
9991 
9992  // Take tokens to avoid allocations
9993  LPT->Toks.swap(Toks);
9994  LPT->D = FnD;
9995  LateParsedTemplateMap.insert(std::make_pair(FD, std::move(LPT)));
9996 
9997  FD->setLateTemplateParsed(true);
9998 }
9999 
10001  if (!FD)
10002  return;
10003  FD->setLateTemplateParsed(false);
10004 }
10005 
10007  DeclContext *DC = CurContext;
10008 
10009  while (DC) {
10010  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(CurContext)) {
10011  const FunctionDecl *FD = RD->isLocalClass();
10012  return (FD && FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate);
10013  } else if (DC->isTranslationUnit() || DC->isNamespace())
10014  return false;
10015 
10016  DC = DC->getParent();
10017  }
10018  return false;
10019 }
10020 
10021 namespace {
10022 /// Walk the path from which a declaration was instantiated, and check
10023 /// that every explicit specialization along that path is visible. This enforces
10024 /// C++ [temp.expl.spec]/6:
10025 ///
10026 /// If a template, a member template or a member of a class template is
10027 /// explicitly specialized then that specialization shall be declared before
10028 /// the first use of that specialization that would cause an implicit
10029 /// instantiation to take place, in every translation unit in which such a
10030 /// use occurs; no diagnostic is required.
10031 ///
10032 /// and also C++ [temp.class.spec]/1:
10033 ///
10034 /// A partial specialization shall be declared before the first use of a
10035 /// class template specialization that would make use of the partial
10036 /// specialization as the result of an implicit or explicit instantiation
10037 /// in every translation unit in which such a use occurs; no diagnostic is
10038 /// required.
10039 class ExplicitSpecializationVisibilityChecker {
10040  Sema &S;
10041  SourceLocation Loc;
10043 
10044 public:
10045  ExplicitSpecializationVisibilityChecker(Sema &S, SourceLocation Loc)
10046  : S(S), Loc(Loc) {}
10047 
10048  void check(NamedDecl *ND) {
10049  if (auto *FD = dyn_cast<FunctionDecl>(ND))
10050  return checkImpl(FD);
10051  if (auto *RD = dyn_cast<CXXRecordDecl>(ND))
10052  return checkImpl(RD);
10053  if (auto *VD = dyn_cast<VarDecl>(ND))
10054  return checkImpl(VD);
10055  if (auto *ED = dyn_cast<EnumDecl>(ND))
10056  return checkImpl(ED);
10057  }
10058 
10059 private:
10060  void diagnose(NamedDecl *D, bool IsPartialSpec) {
10061  auto Kind = IsPartialSpec ? Sema::MissingImportKind::PartialSpecialization
10063  const bool Recover = true;
10064 
10065  // If we got a custom set of modules (because only a subset of the
10066  // declarations are interesting), use them, otherwise let
10067  // diagnoseMissingImport intelligently pick some.
10068  if (Modules.empty())
10069  S.diagnoseMissingImport(Loc, D, Kind, Recover);
10070  else
10071  S.diagnoseMissingImport(Loc, D, D->getLocation(), Modules, Kind, Recover);
10072  }
10073 
10074  // Check a specific declaration. There are three problematic cases:
10075  //
10076  // 1) The declaration is an explicit specialization of a template
10077  // specialization.
10078  // 2) The declaration is an explicit specialization of a member of an
10079  // templated class.
10080  // 3) The declaration is an instantiation of a template, and that template
10081  // is an explicit specialization of a member of a templated class.
10082  //
10083  // We don't need to go any deeper than that, as the instantiation of the
10084  // surrounding class / etc is not triggered by whatever triggered this
10085  // instantiation, and thus should be checked elsewhere.
10086  template<typename SpecDecl>
10087  void checkImpl(SpecDecl *Spec) {
10088  bool IsHiddenExplicitSpecialization = false;
10089  if (Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
10090  IsHiddenExplicitSpecialization =
10091  Spec->getMemberSpecializationInfo()
10092  ? !S.hasVisibleMemberSpecialization(Spec, &Modules)
10093  : !S.hasVisibleExplicitSpecialization(Spec, &Modules);
10094  } else {
10095  checkInstantiated(Spec);
10096  }
10097 
10098  if (IsHiddenExplicitSpecialization)
10099  diagnose(Spec->getMostRecentDecl(), false);
10100  }
10101 
10102  void checkInstantiated(FunctionDecl *FD) {
10103  if (auto *TD = FD->getPrimaryTemplate())
10104  checkTemplate(TD);
10105  }
10106 
10107  void checkInstantiated(CXXRecordDecl *RD) {
10108  auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
10109  if (!SD)
10110  return;
10111 
10112  auto From = SD->getSpecializedTemplateOrPartial();
10113  if (auto *TD = From.dyn_cast<ClassTemplateDecl *>())
10114  checkTemplate(TD);
10115  else if (auto *TD =
10116  From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
10117  if (!S.hasVisibleDeclaration(TD))
10118  diagnose(TD, true);
10119  checkTemplate(TD);
10120  }
10121  }
10122 
10123  void checkInstantiated(VarDecl *RD) {
10124  auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
10125  if (!SD)
10126  return;
10127 
10128  auto From = SD->getSpecializedTemplateOrPartial();
10129  if (auto *TD = From.dyn_cast<VarTemplateDecl *>())
10130  checkTemplate(TD);
10131  else if (auto *TD =
10132  From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
10133  if (!S.hasVisibleDeclaration(TD))
10134  diagnose(TD, true);
10135  checkTemplate(TD);
10136  }
10137  }
10138 
10139  void checkInstantiated(EnumDecl *FD) {}
10140 
10141  template<typename TemplDecl>
10142  void checkTemplate(TemplDecl *TD) {
10143  if (TD->isMemberSpecialization()) {
10144  if (!S.hasVisibleMemberSpecialization(TD, &Modules))
10145  diagnose(TD->getMostRecentDecl(), false);
10146  }
10147  }
10148 };
10149 } // end anonymous namespace
10150 
10152  if (!getLangOpts().Modules)
10153  return;
10154 
10155  ExplicitSpecializationVisibilityChecker(*this, Loc).check(Spec);
10156 }
10157 
10158 /// Check whether a template partial specialization that we've discovered
10159 /// is hidden, and produce suitable diagnostics if so.
10161  NamedDecl *Spec) {
10163  if (!hasVisibleDeclaration(Spec, &Modules))
10164  diagnoseMissingImport(Loc, Spec, Spec->getLocation(), Modules,
10165  MissingImportKind::PartialSpecialization,
10166  /*Recover*/true);
10167 }
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:5376
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:4735
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1583
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:596
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition: Sema.h:3105
void setImplicit(bool I=true)
Definition: DeclBase.h:548
Represents a function declaration or definition.
Definition: Decl.h:1738
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:2482
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:496
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:2537
QualType getPointeeType() const
Definition: Type.h:2550
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:4121
A (possibly-)qualified type.
Definition: Type.h:638
Simple class containing the result of Sema::CorrectTypo.
TemplateDeductionResult
Describes the result of template argument deduction.
Definition: Sema.h:6942
void InstantiatedLocal(const Decl *D, Decl *Inst)
base_class_range bases()
Definition: DeclCXX.h:823
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:6345
void setDefaultArgument(TypeSourceInfo *DefArg)
Set the default argument for this template parameter.
bool isMemberPointerType() const
Definition: Type.h:6327
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
static const TemplateArgument & getArgument(const TemplateArgument &A)
QualType getInjectedSpecializationType() const
Definition: Type.h:5010
NestedNameSpecifier * getQualifier() const
Return the nested name specifier that qualifies this name.
Definition: TemplateName.h:479
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition: Type.cpp:1900
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:1134
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:403
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3054
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.
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1374
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:962
Filter makeFilter()
Create a filter for this result set.
Definition: Lookup.h:671
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1568
void setExceptionSpecRange(SourceRange R)
Definition: TypeLoc.h:1388
We are matching the template parameter lists of two templates that might be redeclarations.
Definition: Sema.h:6484
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:4289
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:505
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:955
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:1020
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:2094
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:5212
void setObjCLifetime(ObjCLifetime type)
Definition: Type.h:329
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:5231
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:1933
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1308
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:4002
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2828
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:376
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4749
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:1095
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1844
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:953
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:6245
void AddDecl(Decl *D)
Definition: Scope.h:287
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition: Type.cpp:2540
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:1407
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:1890
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2091
Declaration of a variable template.
TemplateParamListContext
The context in which we are checking a template parameter list.
Definition: Sema.h:6228
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:515
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:46
Wrapper for source info for typedefs.
Definition: TypeLoc.h:664
void setSpecializationKind(TemplateSpecializationKind TSK)
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:133
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:414
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:690
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:87
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5983
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:1604
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:2720
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
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:9976
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:2484
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
Definition: Lookup.h:543
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
QualType getElementType() const
Definition: Type.h:2847
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:485
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:10852
Represents a variable declaration or definition.
Definition: Decl.h:813
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:1765
bool isEnumeralType() const
Definition: Type.h:6373
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:6748
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
Definition: Decl.cpp:2621
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:3767
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:4785
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:1129
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:432
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
Definition: Sema.h:10763
ArrayRef< LValuePathEntry > getLValuePath() const
Definition: APValue.cpp:643
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:1972
bool isInvalidDecl() const
Definition: DeclBase.h:542
bool isChar32Type() const
Definition: Type.cpp:1815
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...
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
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:1550
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4603
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:1952
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:507
The collection of all-type qualifiers we support.
Definition: Type.h:141
bool isLValueOnePastTheEnd() const
Definition: APValue.cpp:628
Information about a template-id annotation token.
PipeType - OpenCL20.
Definition: Type.h:6002
bool isObjCObjectOrInterfaceType() const
Definition: Type.h:6401
const ValueDecl * getMemberPointerDecl() const
Definition: APValue.cpp:688
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:1638
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:270
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:57
Expr * IgnoreImpCasts() LLVM_READONLY
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
Definition: Expr.h:3167
Represents a struct/union/class.
Definition: Decl.h:3593
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:260
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:986
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:298
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1148
bool isWideCharType() const
Definition: Type.cpp:1796
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:1024
TemplateName getUnderlying() const
Definition: TemplateName.h:349
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7615
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:1358
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:2083
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:5538
QualType getPointeeType() const
Definition: Type.h:2654
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:330
CXXRecordDecl * getPreviousDecl()
Definition: DeclCXX.h:736
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
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:423
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:3895
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:3941
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:1584
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:3774
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
Definition: Type.cpp:3297
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
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:288
NameKind getNameKind() const
Determine what kind of name this is.
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:4904
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:945
bool isNamespace() const
Definition: DeclBase.h:1832
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:1603
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:3877
struct OFI OperatorFunctionId
When Kind == IK_OperatorFunctionId, the overloaded operator that we parsed.
Definition: DeclSpec.h:966
bool isReferenceType() const
Definition: Type.h:6308
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2002
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:4659
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:1872
SourceLocation getRParenLoc() const
Definition: TypeLoc.h:1370
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, bool IsExplicit, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation)
Definition: DeclCXX.cpp:1855
bool hasAnyAcceptableTemplateNames(LookupResult &R, bool AllowFunctionTemplates=true)
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
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:739
The type of a non-type template parameter.
Definition: Sema.h:6633
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:439
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:6644
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:2443
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:2444
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:934
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1654
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2738
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:1748
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:521
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:2115
Wrapper for source info for injected class names of class templates.
Definition: TypeLoc.h:675
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:3243
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:555
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
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:2901
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:4176
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:2434
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack)
Represents a declaration of a type.
Definition: Decl.h:2874
std::string getAsString(ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:595
void setRedeclaration(bool Val)
Definition: DeclSpec.h:2484
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3292
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:1362
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:2790
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization...
Definition: Decl.h:3574
bool isNull() const
Definition: TypeLoc.h:119
CXXRecordDecl * getDecl() const
Definition: Type.cpp:3255
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:3469
ActionResult< ParsedType > TypeResult
Definition: Ownership.h:269
SourceLocation getTemplateEllipsisLoc() const
Definition: TemplateBase.h:546
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2595
void setSpecializationKind(TemplateSpecializationKind TSK)
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
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:6072
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1158
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
Definition: Sema.h:2206
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:3270
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
bool isNoreturnSpecified() const
Definition: DeclSpec.h:580
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:821
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:1231
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:1592
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:792
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:1869
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:3332
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3284
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:1350
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:2826
static FunctionTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
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:6505
static void SetNestedNameSpecifier(Sema &S, TagDecl *T, const CXXScopeSpec &SS)
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:507
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool ResolveTemplateArguments=false) const
Print this nested name specifier to the given output stream.
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.cpp:325
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:2127
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:870
QualType getElementType() const
Definition: Type.h:3144
RAII object used to change the argument pack substitution index within a Sema object.
Definition: Sema.h:7356
unsigned PrintCanonicalTypes
Whether to print types as written or canonically.
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:3128
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:1595
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:3455
We are matching the template parameter lists of two template template parameters as part of matching ...
Definition: Sema.h:6494
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1235
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3650
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:218
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:531
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1861
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3038
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:1613
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3687
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:15788
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:1137
bool hasLValuePath() const
Definition: APValue.cpp:638
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1627
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:569
Specifies that the expression should never be value-dependent.
Definition: Expr.h:711
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:6147
SourceRange getRange() const
Definition: DeclSpec.h:68
TemplateParameterListEqualKind
Enumeration describing how template parameter lists are compared for equality.
Definition: Sema.h:6476
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:2123
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:2966
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2099
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3026
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:190
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:214
QualType getElementType() const
Definition: Type.h:2490
unsigned getFunctionScopeDepth() const
Definition: Decl.h:1597
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2071
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
This represents one expression.
Definition: Expr.h:106
Defines the clang::LangOptions interface.
StringRef getKindName() const
Definition: Decl.h:3239
DeclResult CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation TemplateNameLoc, const TemplateArgumentListInfo &TemplateArgs)
SourceLocation getLocalRangeEnd() const
Definition: TypeLoc.h:1354
LookupNameKind
Describes the kind of name lookup to perform.
Definition: Sema.h:3050
QualType getPointeeType() const
Definition: Type.h:2694
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:5068
bool isExplicitSpecified() const
Definition: DeclSpec.h:577
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:4566
DeclContext * getEntity() const
Definition: Scope.h:325
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:6811
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
Definition: Sema.h:7489
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:5050
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:87
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:1983
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
std::string getAsString() const
Retrieve the human-readable string for this name.
bool isChar16Type() const
Definition: Type.cpp:1809
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:1767
bool isNullPtrType() const
Definition: Type.h:6569
bool isFileContext() const
Definition: DeclBase.h:1818
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
DeclContext * getDeclContext()
Definition: DeclBase.h:427
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:769
bool hasEllipsis() const
Definition: DeclSpec.h:2454
bool isConstexprSpecified() const
Definition: DeclSpec.h:727
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:1350
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:2527
void setMemberSpecialization()
Note that this member template is a specialization.
Definition: DeclTemplate.h:885
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:2422
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:179
Represents the type decltype(expr) (C++11).
Definition: Type.h:4246
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...
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy)
Print a template argument list, including the &#39;<&#39; and &#39;>&#39; enclosing the template arguments.
A namespace alias, stored as a NamespaceAliasDecl*.
bool isIdentifier() const
Determine whether this template name refers to an identifier.
Definition: TemplateName.h:482
int Depth
Definition: ASTDiff.cpp:191
void setLateTemplateParsed(bool ILT=true)
State that this templated function will be late parsed.
Definition: Decl.h:2018
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1016
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:2180
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn&#39;t...
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:614
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:1800
StorageClass
Storage classes.
Definition: Specifiers.h:206
SourceLocation getLocalRangeBegin() const
Definition: TypeLoc.h:1346
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:4289
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Lookup.h:297
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
Get the name of the overloadable C++ operator corresponding to Op.
Declaration of an alias template.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1752
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:1896
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:1380
Represents a GCC generic vector type.
Definition: Type.h:3168
void setLocation(SourceLocation L)
Definition: DeclBase.h:419
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:1605
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2720
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:3958
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1078
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition: Type.h:4709
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
ValueDecl * getDecl()
Definition: Expr.h:1114
BuiltinTemplateKind getBuiltinTemplateKind() const
void setDescribedClassTemplate(ClassTemplateDecl *Template)
Definition: DeclCXX.cpp:1623
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:1396
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:2011
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:703
static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef, const ParsedTemplateArgument &Arg)
bool isChar8Type() const
Definition: Type.cpp:1803
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList *> TPLists)
Definition: Decl.cpp:3943
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:2282
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:1104
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:301
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:6105
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:3253
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:4061
RecordDecl * getDecl() const
Definition: Type.h:4380
SourceLocation getNoreturnSpecLoc() const
Definition: DeclSpec.h:581
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
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...
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
CanQualType OverloadTy
Definition: ASTContext.h:1045
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template.
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1785
#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:169
Kind
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC, SkipBodyInfo *SkipBody=nullptr)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
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:623
param_type_range param_types() const
Definition: Type.h:4030
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:2107
Represents the parsed form of a C++ template argument.
A stack object to be created when performing template instantiation.
Definition: Sema.h:7393
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3899
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:1238
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:3438
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Encodes a location in the source.
QualType getReturnType() const
Definition: Type.h:3613
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4396
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:477
Represents typeof(type), a GCC extension.
Definition: Type.h:4219
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5738
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2095
void setBraceRange(SourceRange R)
Definition: Decl.h:3146
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:1873
void setExternLoc(SourceLocation Loc)
Sets the location of the extern keyword.
DeclarationName getName() const
getName - Returns the embedded declaration name.
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3064
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3272
void referenceDLLExportedClassMethods()
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend=false)
Perform semantic analysis for the given function template specialization.
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...
QualType getElementType() const
Definition: Type.h:3203
InheritableAttr * getDLLAttr(Decl *D)
Return a DLL attribute from the declaration.
Definition: SemaInternal.h:94
ParsedAttr - Represents a syntactic attribute.
Definition: ParsedAttr.h:117
Represents a vector type where either the type or size is dependent.
Definition: Type.h:3245
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3571
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:2041
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:1860
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
ClassTemplateDecl * getMostRecentDecl()
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2059
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3120
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:1823
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:174
EnumDecl * getDecl() const
Definition: Type.h:4403
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:570
ArrayRef< ParmVarDecl * > getParams() const
Definition: TypeLoc.h:1393
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:6116
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:2293
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:595
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl, Expr *AssociatedConstraints=nullptr)
Create a class template node.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:2085
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:215
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:4978
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:2942
QualType getPointeeType() const
Definition: Type.h:3100
Represents a pack expansion of types.
Definition: Type.h:5355
SourceLocation getLocation() const
A POD class for pairing a NamedDecl* with an access specifier.
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1366
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1560
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:1889
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:2495
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:5031
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:2535
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:2589
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.
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:2486
UnaryOperatorKind
ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
NestedNameSpecifier * getQualifier() const
Definition: Type.h:5290
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1262
CanQualType NullPtrTy
Definition: ASTContext.h:1044
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:3594
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:226
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:475
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:131
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:3558
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:1827
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:2971
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:462
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:78
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.
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:2573
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:971
Kind getKind() const
Definition: DeclBase.h:421
bool isBooleanType() const
Definition: Type.h:6657
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:3516
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3772
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:1598
static Expr * lookThroughRangesV3Condition(Preprocessor &PP, Expr *Cond)
Represents an enum.
Definition: Decl.h:3326
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2756
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:583
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
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:508
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
Definition: APValue.cpp:702
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:6663
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:1064
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:2693
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
Definition: SemaDecl.cpp:1153
void addConst()
Definition: Type.h:261
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
unsigned getNumParams() const
Definition: TypeLoc.h:1402
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2022
Represents a pointer to an Objective C object.
Definition: Type.h:5794
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:151
Pointer to a block type.
Definition: Type.h:2639
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:4370
Complex values, per C99 6.2.5p11.
Definition: Type.h:2477
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:3923
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:3575
CheckTemplateArgumentKind
Specifies the context in which a particular template argument is being checked.
Definition: Sema.h:6398
QualType getCanonicalTypeInternal() const
Definition: Type.h:2355
SourceLocation getVirtualSpecLoc() const
Definition: DeclSpec.h:575
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:156
TypedefNameDecl * getTypedefNameDecl() const
Definition: TypeLoc.h:668
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:527
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:1865
CanQualType DependentTy
Definition: ASTContext.h:1045
bool isFunctionType() const
Definition: Type.h:6292
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:2524
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:716
ExtVectorType - Extended vector type.
Definition: Type.h:3287
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2673
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1730
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2269
Wrapper for source info for record types.
Definition: TypeLoc.h:716
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:4234
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:1133
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1507
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:2806
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:2596
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:2070
This is a scope that can contain a declaration.
Definition: Scope.h:60
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:2031
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:2133
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:2253
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:238
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:1619
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:4565
DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II)
Get the name of the literal operator function with II as the identifier.
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\, const ASTContext *Context=nullptr) const
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:1009
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:6152
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
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:2427
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:5264
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:2926
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:2189
void setConstexpr(bool IC)
Definition: Decl.h:2095
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6099
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1409
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:96
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:1854
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4624
Location information for a TemplateArgument.
Definition: TemplateBase.h:393
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:336
The "enum" keyword.
Definition: Type.h:5045
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:1047
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:574
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:2391
void addAttr(Attr *A)
Definition: DeclBase.cpp:840
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:276
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:517
bool isInlineSpecified() const
Definition: DeclSpec.h:567
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1576
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:276
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:954
CanQualType IntTy
Definition: ASTContext.h:1025
std::pair< Expr *, std::string > findFailedBooleanCondition(Expr *Cond)
Find the failed Boolean condition within a given Boolean constant expression, and describe it with a ...
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:578
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:2079
The name refers to a variable template whose specialization produces a variable.
Definition: TemplateKinds.h:33
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:728
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:1041
Represents an extended address space qualifier where the input address space value is dependent...
Definition: Type.h:3086
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4841
NamedDecl * getMostRecentDecl()
Definition: Decl.h:446
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2136
bool isPointerType() const
Definition: Type.h:6296
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:3316
SourceLocation getTemplateNameLoc() const
Definition: TemplateBase.h:539
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:1135
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:732
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:324
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2983
This represents a decl that may have a name.
Definition: Decl.h:249
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:562
bool isTranslationUnit() const
Definition: DeclBase.h:1823
void dropAttr()
Definition: DeclBase.h:502
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
Definition: Expr.h:1141
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:76
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:457
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:2971
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:1600
No keyword precedes the qualified type name.
Definition: Type.h:5071
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:3259
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:572
unsigned NumArgs
NumArgs - The number of template arguments.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Lookup.h:513
NamedDecl * Previous
Definition: Sema.h:1713
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:2144
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:2872
Defines enum values for all the target-independent builtin functions.
Declaration of a template function.
Definition: DeclTemplate.h:969
bool IsInsideALocalClassWithinATemplateFunction()
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1943
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:44
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:762
SourceLocation getLocation() const
Definition: DeclBase.h:418
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type...
Definition: Type.h:1861
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:2776
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:98
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:125
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1058
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:1110
A RAII object to temporarily push a declaration context.
Definition: Sema.h:728