clang  6.0.0
SemaTemplateInstantiateDecl.cpp
Go to the documentation of this file.
1 //===--- SemaTemplateInstantiateDecl.cpp - C++ Template Decl Instantiation ===/
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 C++ template instantiation for declarations.
10 //
11 //===----------------------------------------------------------------------===/
13 #include "clang/AST/ASTConsumer.h"
14 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclTemplate.h"
17 #include "clang/AST/DeclVisitor.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/ExprCXX.h"
21 #include "clang/AST/TypeLoc.h"
23 #include "clang/Sema/Lookup.h"
25 #include "clang/Sema/Template.h"
26 
27 using namespace clang;
28 
29 static bool isDeclWithinFunction(const Decl *D) {
30  const DeclContext *DC = D->getDeclContext();
31  if (DC->isFunctionOrMethod())
32  return true;
33 
34  if (DC->isRecord())
35  return cast<CXXRecordDecl>(DC)->isLocalClass();
36 
37  return false;
38 }
39 
40 template<typename DeclT>
41 static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl,
42  const MultiLevelTemplateArgumentList &TemplateArgs) {
43  if (!OldDecl->getQualifierLoc())
44  return false;
45 
46  assert((NewDecl->getFriendObjectKind() ||
47  !OldDecl->getLexicalDeclContext()->isDependentContext()) &&
48  "non-friend with qualified name defined in dependent context");
49  Sema::ContextRAII SavedContext(
50  SemaRef,
51  const_cast<DeclContext *>(NewDecl->getFriendObjectKind()
52  ? NewDecl->getLexicalDeclContext()
53  : OldDecl->getLexicalDeclContext()));
54 
55  NestedNameSpecifierLoc NewQualifierLoc
56  = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
57  TemplateArgs);
58 
59  if (!NewQualifierLoc)
60  return true;
61 
62  NewDecl->setQualifierInfo(NewQualifierLoc);
63  return false;
64 }
65 
67  DeclaratorDecl *NewDecl) {
68  return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
69 }
70 
72  TagDecl *NewDecl) {
73  return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
74 }
75 
76 // Include attribute instantiation code.
77 #include "clang/Sema/AttrTemplateInstantiate.inc"
78 
80  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
81  const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion) {
82  if (Aligned->isAlignmentExpr()) {
83  // The alignment expression is a constant expression.
86  ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs);
87  if (!Result.isInvalid())
88  S.AddAlignedAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
89  Aligned->getSpellingListIndex(), IsPackExpansion);
90  } else {
91  TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(),
92  TemplateArgs, Aligned->getLocation(),
93  DeclarationName());
94  if (Result)
95  S.AddAlignedAttr(Aligned->getLocation(), New, Result,
96  Aligned->getSpellingListIndex(), IsPackExpansion);
97  }
98 }
99 
101  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
102  const AlignedAttr *Aligned, Decl *New) {
103  if (!Aligned->isPackExpansion()) {
104  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
105  return;
106  }
107 
109  if (Aligned->isAlignmentExpr())
110  S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(),
111  Unexpanded);
112  else
113  S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(),
114  Unexpanded);
115  assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
116 
117  // Determine whether we can expand this attribute pack yet.
118  bool Expand = true, RetainExpansion = false;
119  Optional<unsigned> NumExpansions;
120  // FIXME: Use the actual location of the ellipsis.
121  SourceLocation EllipsisLoc = Aligned->getLocation();
122  if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(),
123  Unexpanded, TemplateArgs, Expand,
124  RetainExpansion, NumExpansions))
125  return;
126 
127  if (!Expand) {
128  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1);
129  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true);
130  } else {
131  for (unsigned I = 0; I != *NumExpansions; ++I) {
133  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
134  }
135  }
136 }
137 
139  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
140  const AssumeAlignedAttr *Aligned, Decl *New) {
141  // The alignment expression is a constant expression.
144 
145  Expr *E, *OE = nullptr;
146  ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
147  if (Result.isInvalid())
148  return;
149  E = Result.getAs<Expr>();
150 
151  if (Aligned->getOffset()) {
152  Result = S.SubstExpr(Aligned->getOffset(), TemplateArgs);
153  if (Result.isInvalid())
154  return;
155  OE = Result.getAs<Expr>();
156  }
157 
158  S.AddAssumeAlignedAttr(Aligned->getLocation(), New, E, OE,
159  Aligned->getSpellingListIndex());
160 }
161 
163  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
164  const AlignValueAttr *Aligned, Decl *New) {
165  // The alignment expression is a constant expression.
168  ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
169  if (!Result.isInvalid())
170  S.AddAlignValueAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
171  Aligned->getSpellingListIndex());
172 }
173 
175  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
176  const AllocAlignAttr *Align, Decl *New) {
177  Expr *Param = IntegerLiteral::Create(
178  S.getASTContext(), llvm::APInt(64, Align->getParamIndex()),
179  S.getASTContext().UnsignedLongLongTy, Align->getLocation());
180  S.AddAllocAlignAttr(Align->getLocation(), New, Param,
181  Align->getSpellingListIndex());
182 }
183 
185  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
186  const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) {
187  Expr *Cond = nullptr;
188  {
189  Sema::ContextRAII SwitchContext(S, New);
192  ExprResult Result = S.SubstExpr(OldCond, TemplateArgs);
193  if (Result.isInvalid())
194  return nullptr;
195  Cond = Result.getAs<Expr>();
196  }
197  if (!Cond->isTypeDependent()) {
198  ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
199  if (Converted.isInvalid())
200  return nullptr;
201  Cond = Converted.get();
202  }
203 
205  if (OldCond->isValueDependent() && !Cond->isValueDependent() &&
206  !Expr::isPotentialConstantExprUnevaluated(Cond, New, Diags)) {
207  S.Diag(A->getLocation(), diag::err_attr_cond_never_constant_expr) << A;
208  for (const auto &P : Diags)
209  S.Diag(P.first, P.second);
210  return nullptr;
211  }
212  return Cond;
213 }
214 
216  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
217  const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New) {
219  S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);
220 
221  if (Cond)
222  New->addAttr(new (S.getASTContext()) EnableIfAttr(
223  EIA->getLocation(), S.getASTContext(), Cond, EIA->getMessage(),
224  EIA->getSpellingListIndex()));
225 }
226 
228  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
229  const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New) {
231  S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);
232 
233  if (Cond)
234  New->addAttr(new (S.getASTContext()) DiagnoseIfAttr(
235  DIA->getLocation(), S.getASTContext(), Cond, DIA->getMessage(),
236  DIA->getDiagnosticType(), DIA->getArgDependent(), New,
237  DIA->getSpellingListIndex()));
238 }
239 
240 // Constructs and adds to New a new instance of CUDALaunchBoundsAttr using
241 // template A as the base and arguments from TemplateArgs.
243  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
244  const CUDALaunchBoundsAttr &Attr, Decl *New) {
245  // The alignment expression is a constant expression.
248 
249  ExprResult Result = S.SubstExpr(Attr.getMaxThreads(), TemplateArgs);
250  if (Result.isInvalid())
251  return;
252  Expr *MaxThreads = Result.getAs<Expr>();
253 
254  Expr *MinBlocks = nullptr;
255  if (Attr.getMinBlocks()) {
256  Result = S.SubstExpr(Attr.getMinBlocks(), TemplateArgs);
257  if (Result.isInvalid())
258  return;
259  MinBlocks = Result.getAs<Expr>();
260  }
261 
262  S.AddLaunchBoundsAttr(Attr.getLocation(), New, MaxThreads, MinBlocks,
263  Attr.getSpellingListIndex());
264 }
265 
266 static void
268  const MultiLevelTemplateArgumentList &TemplateArgs,
269  const ModeAttr &Attr, Decl *New) {
270  S.AddModeAttr(Attr.getRange(), New, Attr.getMode(),
271  Attr.getSpellingListIndex(), /*InInstantiation=*/true);
272 }
273 
274 /// Instantiation of 'declare simd' attribute and its arguments.
276  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
277  const OMPDeclareSimdDeclAttr &Attr, Decl *New) {
278  // Allow 'this' in clauses with varlists.
279  if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
280  New = FTD->getTemplatedDecl();
281  auto *FD = cast<FunctionDecl>(New);
282  auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
283  SmallVector<Expr *, 4> Uniforms, Aligneds, Alignments, Linears, Steps;
284  SmallVector<unsigned, 4> LinModifiers;
285 
286  auto &&Subst = [&](Expr *E) -> ExprResult {
287  if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
288  if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
289  Sema::ContextRAII SavedContext(S, FD);
290  LocalInstantiationScope Local(S);
291  if (FD->getNumParams() > PVD->getFunctionScopeIndex())
292  Local.InstantiatedLocal(
293  PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
294  return S.SubstExpr(E, TemplateArgs);
295  }
296  Sema::CXXThisScopeRAII ThisScope(S, ThisContext, /*TypeQuals=*/0,
297  FD->isCXXInstanceMember());
298  return S.SubstExpr(E, TemplateArgs);
299  };
300 
301  ExprResult Simdlen;
302  if (auto *E = Attr.getSimdlen())
303  Simdlen = Subst(E);
304 
305  if (Attr.uniforms_size() > 0) {
306  for(auto *E : Attr.uniforms()) {
307  ExprResult Inst = Subst(E);
308  if (Inst.isInvalid())
309  continue;
310  Uniforms.push_back(Inst.get());
311  }
312  }
313 
314  auto AI = Attr.alignments_begin();
315  for (auto *E : Attr.aligneds()) {
316  ExprResult Inst = Subst(E);
317  if (Inst.isInvalid())
318  continue;
319  Aligneds.push_back(Inst.get());
320  Inst = ExprEmpty();
321  if (*AI)
322  Inst = S.SubstExpr(*AI, TemplateArgs);
323  Alignments.push_back(Inst.get());
324  ++AI;
325  }
326 
327  auto SI = Attr.steps_begin();
328  for (auto *E : Attr.linears()) {
329  ExprResult Inst = Subst(E);
330  if (Inst.isInvalid())
331  continue;
332  Linears.push_back(Inst.get());
333  Inst = ExprEmpty();
334  if (*SI)
335  Inst = S.SubstExpr(*SI, TemplateArgs);
336  Steps.push_back(Inst.get());
337  ++SI;
338  }
339  LinModifiers.append(Attr.modifiers_begin(), Attr.modifiers_end());
341  S.ConvertDeclToDeclGroup(New), Attr.getBranchState(), Simdlen.get(),
342  Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps,
343  Attr.getRange());
344 }
345 
346 static bool DeclContainsAttr(const Decl *D, const Attr *NewAttr) {
347  if (!D->hasAttrs() || NewAttr->duplicatesAllowed())
348  return false;
349  return llvm::find_if(D->getAttrs(), [NewAttr](const Attr *Attr) {
350  return Attr->getKind() == NewAttr->getKind();
351  }) != D->getAttrs().end();
352 }
353 
355  const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl,
356  Decl *New, LateInstantiatedAttrVec *LateAttrs,
357  LocalInstantiationScope *OuterMostScope) {
358  if (NamedDecl *ND = dyn_cast<NamedDecl>(New)) {
359  for (const auto *TmplAttr : Tmpl->attrs()) {
360  // FIXME: If any of the special case versions from InstantiateAttrs become
361  // applicable to template declaration, we'll need to add them here.
362  CXXThisScopeRAII ThisScope(
363  *this, dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()),
364  /*TypeQuals*/ 0, ND->isCXXInstanceMember());
365 
367  TmplAttr, Context, *this, TemplateArgs);
368  if (NewAttr && !DeclContainsAttr(New, NewAttr))
369  New->addAttr(NewAttr);
370  }
371  }
372 }
373 
375  const Decl *Tmpl, Decl *New,
376  LateInstantiatedAttrVec *LateAttrs,
377  LocalInstantiationScope *OuterMostScope) {
378  for (const auto *TmplAttr : Tmpl->attrs()) {
379  // FIXME: This should be generalized to more than just the AlignedAttr.
380  const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
381  if (Aligned && Aligned->isAlignmentDependent()) {
382  instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New);
383  continue;
384  }
385 
386  const AssumeAlignedAttr *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr);
387  if (AssumeAligned) {
388  instantiateDependentAssumeAlignedAttr(*this, TemplateArgs, AssumeAligned, New);
389  continue;
390  }
391 
392  const AlignValueAttr *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr);
393  if (AlignValue) {
394  instantiateDependentAlignValueAttr(*this, TemplateArgs, AlignValue, New);
395  continue;
396  }
397 
398  if (const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) {
399  instantiateDependentAllocAlignAttr(*this, TemplateArgs, AllocAlign, New);
400  continue;
401  }
402 
403 
404  if (const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
405  instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl,
406  cast<FunctionDecl>(New));
407  continue;
408  }
409 
410  if (const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
411  instantiateDependentDiagnoseIfAttr(*this, TemplateArgs, DiagnoseIf, Tmpl,
412  cast<FunctionDecl>(New));
413  continue;
414  }
415 
416  if (const CUDALaunchBoundsAttr *CUDALaunchBounds =
417  dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
418  instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs,
419  *CUDALaunchBounds, New);
420  continue;
421  }
422 
423  if (const ModeAttr *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
424  instantiateDependentModeAttr(*this, TemplateArgs, *Mode, New);
425  continue;
426  }
427 
428  if (const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
429  instantiateOMPDeclareSimdDeclAttr(*this, TemplateArgs, *OMPAttr, New);
430  continue;
431  }
432 
433  // Existing DLL attribute on the instantiation takes precedence.
434  if (TmplAttr->getKind() == attr::DLLExport ||
435  TmplAttr->getKind() == attr::DLLImport) {
436  if (New->hasAttr<DLLExportAttr>() || New->hasAttr<DLLImportAttr>()) {
437  continue;
438  }
439  }
440 
441  if (auto ABIAttr = dyn_cast<ParameterABIAttr>(TmplAttr)) {
442  AddParameterABIAttr(ABIAttr->getRange(), New, ABIAttr->getABI(),
443  ABIAttr->getSpellingListIndex());
444  continue;
445  }
446 
447  if (isa<NSConsumedAttr>(TmplAttr) || isa<CFConsumedAttr>(TmplAttr)) {
448  AddNSConsumedAttr(TmplAttr->getRange(), New,
449  TmplAttr->getSpellingListIndex(),
450  isa<NSConsumedAttr>(TmplAttr),
451  /*template instantiation*/ true);
452  continue;
453  }
454 
455  assert(!TmplAttr->isPackExpansion());
456  if (TmplAttr->isLateParsed() && LateAttrs) {
457  // Late parsed attributes must be instantiated and attached after the
458  // enclosing class has been instantiated. See Sema::InstantiateClass.
459  LocalInstantiationScope *Saved = nullptr;
460  if (CurrentInstantiationScope)
461  Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope);
462  LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New));
463  } else {
464  // Allow 'this' within late-parsed attributes.
465  NamedDecl *ND = dyn_cast<NamedDecl>(New);
466  CXXRecordDecl *ThisContext =
467  dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
468  CXXThisScopeRAII ThisScope(*this, ThisContext, /*TypeQuals*/0,
469  ND && ND->isCXXInstanceMember());
470 
471  Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
472  *this, TemplateArgs);
473 
474  if (NewAttr && !DeclContainsAttr(New, NewAttr))
475  New->addAttr(NewAttr);
476  }
477  }
478 }
479 
480 /// Get the previous declaration of a declaration for the purposes of template
481 /// instantiation. If this finds a previous declaration, then the previous
482 /// declaration of the instantiation of D should be an instantiation of the
483 /// result of this function.
484 template<typename DeclT>
485 static DeclT *getPreviousDeclForInstantiation(DeclT *D) {
486  DeclT *Result = D->getPreviousDecl();
487 
488  // If the declaration is within a class, and the previous declaration was
489  // merged from a different definition of that class, then we don't have a
490  // previous declaration for the purpose of template instantiation.
491  if (Result && isa<CXXRecordDecl>(D->getDeclContext()) &&
492  D->getLexicalDeclContext() != Result->getLexicalDeclContext())
493  return nullptr;
494 
495  return Result;
496 }
497 
498 Decl *
499 TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
500  llvm_unreachable("Translation units cannot be instantiated");
501 }
502 
503 Decl *
504 TemplateDeclInstantiator::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
505  llvm_unreachable("pragma comment cannot be instantiated");
506 }
507 
508 Decl *TemplateDeclInstantiator::VisitPragmaDetectMismatchDecl(
510  llvm_unreachable("pragma comment cannot be instantiated");
511 }
512 
513 Decl *
514 TemplateDeclInstantiator::VisitExternCContextDecl(ExternCContextDecl *D) {
515  llvm_unreachable("extern \"C\" context cannot be instantiated");
516 }
517 
518 Decl *
519 TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) {
520  LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(),
521  D->getIdentifier());
522  Owner->addDecl(Inst);
523  return Inst;
524 }
525 
526 Decl *
527 TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
528  llvm_unreachable("Namespaces cannot be instantiated");
529 }
530 
531 Decl *
532 TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
533  NamespaceAliasDecl *Inst
534  = NamespaceAliasDecl::Create(SemaRef.Context, Owner,
535  D->getNamespaceLoc(),
536  D->getAliasLoc(),
537  D->getIdentifier(),
538  D->getQualifierLoc(),
539  D->getTargetNameLoc(),
540  D->getNamespace());
541  Owner->addDecl(Inst);
542  return Inst;
543 }
544 
546  bool IsTypeAlias) {
547  bool Invalid = false;
549  if (DI->getType()->isInstantiationDependentType() ||
550  DI->getType()->isVariablyModifiedType()) {
551  DI = SemaRef.SubstType(DI, TemplateArgs,
552  D->getLocation(), D->getDeclName());
553  if (!DI) {
554  Invalid = true;
555  DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
556  }
557  } else {
559  }
560 
561  // HACK: g++ has a bug where it gets the value kind of ?: wrong.
562  // libstdc++ relies upon this bug in its implementation of common_type.
563  // If we happen to be processing that implementation, fake up the g++ ?:
564  // semantics. See LWG issue 2141 for more information on the bug.
565  const DecltypeType *DT = DI->getType()->getAs<DecltypeType>();
566  CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
567  if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) &&
568  DT->isReferenceType() &&
569  RD->getEnclosingNamespaceContext() == SemaRef.getStdNamespace() &&
570  RD->getIdentifier() && RD->getIdentifier()->isStr("common_type") &&
571  D->getIdentifier() && D->getIdentifier()->isStr("type") &&
573  // Fold it to the (non-reference) type which g++ would have produced.
574  DI = SemaRef.Context.getTrivialTypeSourceInfo(
575  DI->getType().getNonReferenceType());
576 
577  // Create the new typedef
578  TypedefNameDecl *Typedef;
579  if (IsTypeAlias)
580  Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
581  D->getLocation(), D->getIdentifier(), DI);
582  else
583  Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
584  D->getLocation(), D->getIdentifier(), DI);
585  if (Invalid)
586  Typedef->setInvalidDecl();
587 
588  // If the old typedef was the name for linkage purposes of an anonymous
589  // tag decl, re-establish that relationship for the new typedef.
590  if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
591  TagDecl *oldTag = oldTagType->getDecl();
592  if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) {
593  TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
594  assert(!newTag->hasNameForLinkage());
595  newTag->setTypedefNameForAnonDecl(Typedef);
596  }
597  }
598 
600  NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
601  TemplateArgs);
602  if (!InstPrev)
603  return nullptr;
604 
605  TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev);
606 
607  // If the typedef types are not identical, reject them.
608  SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef);
609 
610  Typedef->setPreviousDecl(InstPrevTypedef);
611  }
612 
613  SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);
614 
615  Typedef->setAccess(D->getAccess());
616 
617  return Typedef;
618 }
619 
620 Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
621  Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false);
622  if (Typedef)
623  Owner->addDecl(Typedef);
624  return Typedef;
625 }
626 
627 Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
628  Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true);
629  if (Typedef)
630  Owner->addDecl(Typedef);
631  return Typedef;
632 }
633 
634 Decl *
635 TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
636  // Create a local instantiation scope for this type alias template, which
637  // will contain the instantiations of the template parameters.
639 
640  TemplateParameterList *TempParams = D->getTemplateParameters();
641  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
642  if (!InstParams)
643  return nullptr;
644 
645  TypeAliasDecl *Pattern = D->getTemplatedDecl();
646 
647  TypeAliasTemplateDecl *PrevAliasTemplate = nullptr;
648  if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
649  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
650  if (!Found.empty()) {
651  PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front());
652  }
653  }
654 
655  TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
656  InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
657  if (!AliasInst)
658  return nullptr;
659 
661  = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
662  D->getDeclName(), InstParams, AliasInst);
663  AliasInst->setDescribedAliasTemplate(Inst);
664  if (PrevAliasTemplate)
665  Inst->setPreviousDecl(PrevAliasTemplate);
666 
667  Inst->setAccess(D->getAccess());
668 
669  if (!PrevAliasTemplate)
671 
672  Owner->addDecl(Inst);
673 
674  return Inst;
675 }
676 
677 Decl *TemplateDeclInstantiator::VisitBindingDecl(BindingDecl *D) {
678  auto *NewBD = BindingDecl::Create(SemaRef.Context, Owner, D->getLocation(),
679  D->getIdentifier());
680  NewBD->setReferenced(D->isReferenced());
681  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewBD);
682  return NewBD;
683 }
684 
685 Decl *TemplateDeclInstantiator::VisitDecompositionDecl(DecompositionDecl *D) {
686  // Transform the bindings first.
687  SmallVector<BindingDecl*, 16> NewBindings;
688  for (auto *OldBD : D->bindings())
689  NewBindings.push_back(cast<BindingDecl>(VisitBindingDecl(OldBD)));
690  ArrayRef<BindingDecl*> NewBindingArray = NewBindings;
691 
692  auto *NewDD = cast_or_null<DecompositionDecl>(
693  VisitVarDecl(D, /*InstantiatingVarTemplate=*/false, &NewBindingArray));
694 
695  if (!NewDD || NewDD->isInvalidDecl())
696  for (auto *NewBD : NewBindings)
697  NewBD->setInvalidDecl();
698 
699  return NewDD;
700 }
701 
703  return VisitVarDecl(D, /*InstantiatingVarTemplate=*/false);
704 }
705 
707  bool InstantiatingVarTemplate,
708  ArrayRef<BindingDecl*> *Bindings) {
709 
710  // Do substitution on the type of the declaration
711  TypeSourceInfo *DI = SemaRef.SubstType(
712  D->getTypeSourceInfo(), TemplateArgs, D->getTypeSpecStartLoc(),
713  D->getDeclName(), /*AllowDeducedTST*/true);
714  if (!DI)
715  return nullptr;
716 
717  if (DI->getType()->isFunctionType()) {
718  SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
719  << D->isStaticDataMember() << DI->getType();
720  return nullptr;
721  }
722 
723  DeclContext *DC = Owner;
724  if (D->isLocalExternDecl())
726 
727  // Build the instantiated declaration.
728  VarDecl *Var;
729  if (Bindings)
730  Var = DecompositionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
731  D->getLocation(), DI->getType(), DI,
732  D->getStorageClass(), *Bindings);
733  else
734  Var = VarDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
735  D->getLocation(), D->getIdentifier(), DI->getType(),
736  DI, D->getStorageClass());
737 
738  // In ARC, infer 'retaining' for variables of retainable type.
739  if (SemaRef.getLangOpts().ObjCAutoRefCount &&
740  SemaRef.inferObjCARCLifetime(Var))
741  Var->setInvalidDecl();
742 
743  // Substitute the nested name specifier, if any.
744  if (SubstQualifier(D, Var))
745  return nullptr;
746 
747  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
748  StartingScope, InstantiatingVarTemplate);
749 
750  if (D->isNRVOVariable()) {
751  QualType ReturnType = cast<FunctionDecl>(DC)->getReturnType();
752  if (SemaRef.isCopyElisionCandidate(ReturnType, Var, false))
753  Var->setNRVOVariable(true);
754  }
755 
756  Var->setImplicit(D->isImplicit());
757 
758  return Var;
759 }
760 
761 Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
762  AccessSpecDecl* AD
763  = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner,
765  Owner->addHiddenDecl(AD);
766  return AD;
767 }
768 
769 Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
770  bool Invalid = false;
772  if (DI->getType()->isInstantiationDependentType() ||
773  DI->getType()->isVariablyModifiedType()) {
774  DI = SemaRef.SubstType(DI, TemplateArgs,
775  D->getLocation(), D->getDeclName());
776  if (!DI) {
777  DI = D->getTypeSourceInfo();
778  Invalid = true;
779  } else if (DI->getType()->isFunctionType()) {
780  // C++ [temp.arg.type]p3:
781  // If a declaration acquires a function type through a type
782  // dependent on a template-parameter and this causes a
783  // declaration that does not use the syntactic form of a
784  // function declarator to have function type, the program is
785  // ill-formed.
786  SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
787  << DI->getType();
788  Invalid = true;
789  }
790  } else {
792  }
793 
794  Expr *BitWidth = D->getBitWidth();
795  if (Invalid)
796  BitWidth = nullptr;
797  else if (BitWidth) {
798  // The bit-width expression is a constant expression.
801 
802  ExprResult InstantiatedBitWidth
803  = SemaRef.SubstExpr(BitWidth, TemplateArgs);
804  if (InstantiatedBitWidth.isInvalid()) {
805  Invalid = true;
806  BitWidth = nullptr;
807  } else
808  BitWidth = InstantiatedBitWidth.getAs<Expr>();
809  }
810 
811  FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
812  DI->getType(), DI,
813  cast<RecordDecl>(Owner),
814  D->getLocation(),
815  D->isMutable(),
816  BitWidth,
817  D->getInClassInitStyle(),
818  D->getInnerLocStart(),
819  D->getAccess(),
820  nullptr);
821  if (!Field) {
822  cast<Decl>(Owner)->setInvalidDecl();
823  return nullptr;
824  }
825 
826  SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);
827 
828  if (Field->hasAttrs())
829  SemaRef.CheckAlignasUnderalignment(Field);
830 
831  if (Invalid)
832  Field->setInvalidDecl();
833 
834  if (!Field->getDeclName()) {
835  // Keep track of where this decl came from.
837  }
838  if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) {
839  if (Parent->isAnonymousStructOrUnion() &&
840  Parent->getRedeclContext()->isFunctionOrMethod())
841  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field);
842  }
843 
844  Field->setImplicit(D->isImplicit());
845  Field->setAccess(D->getAccess());
846  Owner->addDecl(Field);
847 
848  return Field;
849 }
850 
851 Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) {
852  bool Invalid = false;
854 
855  if (DI->getType()->isVariablyModifiedType()) {
856  SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified)
857  << D;
858  Invalid = true;
859  } else if (DI->getType()->isInstantiationDependentType()) {
860  DI = SemaRef.SubstType(DI, TemplateArgs,
861  D->getLocation(), D->getDeclName());
862  if (!DI) {
863  DI = D->getTypeSourceInfo();
864  Invalid = true;
865  } else if (DI->getType()->isFunctionType()) {
866  // C++ [temp.arg.type]p3:
867  // If a declaration acquires a function type through a type
868  // dependent on a template-parameter and this causes a
869  // declaration that does not use the syntactic form of a
870  // function declarator to have function type, the program is
871  // ill-formed.
872  SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
873  << DI->getType();
874  Invalid = true;
875  }
876  } else {
878  }
879 
881  SemaRef.Context, Owner, D->getLocation(), D->getDeclName(), DI->getType(),
882  DI, D->getLocStart(), D->getGetterId(), D->getSetterId());
883 
884  SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs,
885  StartingScope);
886 
887  if (Invalid)
888  Property->setInvalidDecl();
889 
890  Property->setAccess(D->getAccess());
891  Owner->addDecl(Property);
892 
893  return Property;
894 }
895 
896 Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
897  NamedDecl **NamedChain =
898  new (SemaRef.Context)NamedDecl*[D->getChainingSize()];
899 
900  int i = 0;
901  for (auto *PI : D->chain()) {
902  NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), PI,
903  TemplateArgs);
904  if (!Next)
905  return nullptr;
906 
907  NamedChain[i++] = Next;
908  }
909 
910  QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
912  SemaRef.Context, Owner, D->getLocation(), D->getIdentifier(), T,
913  {NamedChain, D->getChainingSize()});
914 
915  for (const auto *Attr : D->attrs())
916  IndirectField->addAttr(Attr->clone(SemaRef.Context));
917 
918  IndirectField->setImplicit(D->isImplicit());
919  IndirectField->setAccess(D->getAccess());
920  Owner->addDecl(IndirectField);
921  return IndirectField;
922 }
923 
924 Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) {
925  // Handle friend type expressions by simply substituting template
926  // parameters into the pattern type and checking the result.
927  if (TypeSourceInfo *Ty = D->getFriendType()) {
928  TypeSourceInfo *InstTy;
929  // If this is an unsupported friend, don't bother substituting template
930  // arguments into it. The actual type referred to won't be used by any
931  // parts of Clang, and may not be valid for instantiating. Just use the
932  // same info for the instantiated friend.
933  if (D->isUnsupportedFriend()) {
934  InstTy = Ty;
935  } else {
936  InstTy = SemaRef.SubstType(Ty, TemplateArgs,
937  D->getLocation(), DeclarationName());
938  }
939  if (!InstTy)
940  return nullptr;
941 
942  FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getLocStart(),
943  D->getFriendLoc(), InstTy);
944  if (!FD)
945  return nullptr;
946 
947  FD->setAccess(AS_public);
949  Owner->addDecl(FD);
950  return FD;
951  }
952 
953  NamedDecl *ND = D->getFriendDecl();
954  assert(ND && "friend decl must be a decl or a type!");
955 
956  // All of the Visit implementations for the various potential friend
957  // declarations have to be carefully written to work for friend
958  // objects, with the most important detail being that the target
959  // decl should almost certainly not be placed in Owner.
960  Decl *NewND = Visit(ND);
961  if (!NewND) return nullptr;
962 
963  FriendDecl *FD =
964  FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(),
965  cast<NamedDecl>(NewND), D->getFriendLoc());
966  FD->setAccess(AS_public);
968  Owner->addDecl(FD);
969  return FD;
970 }
971 
972 Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
973  Expr *AssertExpr = D->getAssertExpr();
974 
975  // The expression in a static assertion is a constant expression.
978 
979  ExprResult InstantiatedAssertExpr
980  = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
981  if (InstantiatedAssertExpr.isInvalid())
982  return nullptr;
983 
984  return SemaRef.BuildStaticAssertDeclaration(D->getLocation(),
985  InstantiatedAssertExpr.get(),
986  D->getMessage(),
987  D->getRParenLoc(),
988  D->isFailed());
989 }
990 
991 Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
992  EnumDecl *PrevDecl = nullptr;
993  if (EnumDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
994  NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
995  PatternPrev,
996  TemplateArgs);
997  if (!Prev) return nullptr;
998  PrevDecl = cast<EnumDecl>(Prev);
999  }
1000 
1001  EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
1002  D->getLocation(), D->getIdentifier(),
1003  PrevDecl, D->isScoped(),
1004  D->isScopedUsingClassTag(), D->isFixed());
1005  if (D->isFixed()) {
1006  if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) {
1007  // If we have type source information for the underlying type, it means it
1008  // has been explicitly set by the user. Perform substitution on it before
1009  // moving on.
1010  SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
1011  TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc,
1012  DeclarationName());
1013  if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI))
1014  Enum->setIntegerType(SemaRef.Context.IntTy);
1015  else
1016  Enum->setIntegerTypeSourceInfo(NewTI);
1017  } else {
1018  assert(!D->getIntegerType()->isDependentType()
1019  && "Dependent type without type source info");
1020  Enum->setIntegerType(D->getIntegerType());
1021  }
1022  }
1023 
1024  SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);
1025 
1026  Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation);
1027  Enum->setAccess(D->getAccess());
1028  // Forward the mangling number from the template to the instantiated decl.
1029  SemaRef.Context.setManglingNumber(Enum, SemaRef.Context.getManglingNumber(D));
1030  // See if the old tag was defined along with a declarator.
1031  // If it did, mark the new tag as being associated with that declarator.
1033  SemaRef.Context.addDeclaratorForUnnamedTagDecl(Enum, DD);
1034  // See if the old tag was defined along with a typedef.
1035  // If it did, mark the new tag as being associated with that typedef.
1037  SemaRef.Context.addTypedefNameForUnnamedTagDecl(Enum, TND);
1038  if (SubstQualifier(D, Enum)) return nullptr;
1039  Owner->addDecl(Enum);
1040 
1041  EnumDecl *Def = D->getDefinition();
1042  if (Def && Def != D) {
1043  // If this is an out-of-line definition of an enum member template, check
1044  // that the underlying types match in the instantiation of both
1045  // declarations.
1046  if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) {
1047  SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
1048  QualType DefnUnderlying =
1049  SemaRef.SubstType(TI->getType(), TemplateArgs,
1050  UnderlyingLoc, DeclarationName());
1051  SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(),
1052  DefnUnderlying,
1053  /*EnumUnderlyingIsImplicit=*/false, Enum);
1054  }
1055  }
1056 
1057  // C++11 [temp.inst]p1: The implicit instantiation of a class template
1058  // specialization causes the implicit instantiation of the declarations, but
1059  // not the definitions of scoped member enumerations.
1060  //
1061  // DR1484 clarifies that enumeration definitions inside of a template
1062  // declaration aren't considered entities that can be separately instantiated
1063  // from the rest of the entity they are declared inside of.
1064  if (isDeclWithinFunction(D) ? D == Def : Def && !Enum->isScoped()) {
1065  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Enum);
1066  InstantiateEnumDefinition(Enum, Def);
1067  }
1068 
1069  return Enum;
1070 }
1071 
1073  EnumDecl *Enum, EnumDecl *Pattern) {
1074  Enum->startDefinition();
1075 
1076  // Update the location to refer to the definition.
1077  Enum->setLocation(Pattern->getLocation());
1078 
1079  SmallVector<Decl*, 4> Enumerators;
1080 
1081  EnumConstantDecl *LastEnumConst = nullptr;
1082  for (auto *EC : Pattern->enumerators()) {
1083  // The specified value for the enumerator.
1084  ExprResult Value((Expr *)nullptr);
1085  if (Expr *UninstValue = EC->getInitExpr()) {
1086  // The enumerator's value expression is a constant expression.
1089 
1090  Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
1091  }
1092 
1093  // Drop the initial value and continue.
1094  bool isInvalid = false;
1095  if (Value.isInvalid()) {
1096  Value = nullptr;
1097  isInvalid = true;
1098  }
1099 
1100  EnumConstantDecl *EnumConst
1101  = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
1102  EC->getLocation(), EC->getIdentifier(),
1103  Value.get());
1104 
1105  if (isInvalid) {
1106  if (EnumConst)
1107  EnumConst->setInvalidDecl();
1108  Enum->setInvalidDecl();
1109  }
1110 
1111  if (EnumConst) {
1112  SemaRef.InstantiateAttrs(TemplateArgs, EC, EnumConst);
1113 
1114  EnumConst->setAccess(Enum->getAccess());
1115  Enum->addDecl(EnumConst);
1116  Enumerators.push_back(EnumConst);
1117  LastEnumConst = EnumConst;
1118 
1119  if (Pattern->getDeclContext()->isFunctionOrMethod() &&
1120  !Enum->isScoped()) {
1121  // If the enumeration is within a function or method, record the enum
1122  // constant as a local.
1123  SemaRef.CurrentInstantiationScope->InstantiatedLocal(EC, EnumConst);
1124  }
1125  }
1126  }
1127 
1128  SemaRef.ActOnEnumBody(Enum->getLocation(), Enum->getBraceRange(), Enum,
1129  Enumerators,
1130  nullptr, nullptr);
1131 }
1132 
1133 Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
1134  llvm_unreachable("EnumConstantDecls can only occur within EnumDecls.");
1135 }
1136 
1137 Decl *
1138 TemplateDeclInstantiator::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
1139  llvm_unreachable("BuiltinTemplateDecls cannot be instantiated.");
1140 }
1141 
1142 Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1143  bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1144 
1145  // Create a local instantiation scope for this class template, which
1146  // will contain the instantiations of the template parameters.
1147  LocalInstantiationScope Scope(SemaRef);
1148  TemplateParameterList *TempParams = D->getTemplateParameters();
1149  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1150  if (!InstParams)
1151  return nullptr;
1152 
1153  CXXRecordDecl *Pattern = D->getTemplatedDecl();
1154 
1155  // Instantiate the qualifier. We have to do this first in case
1156  // we're a friend declaration, because if we are then we need to put
1157  // the new declaration in the appropriate context.
1158  NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
1159  if (QualifierLoc) {
1160  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1161  TemplateArgs);
1162  if (!QualifierLoc)
1163  return nullptr;
1164  }
1165 
1166  CXXRecordDecl *PrevDecl = nullptr;
1167  ClassTemplateDecl *PrevClassTemplate = nullptr;
1168 
1169  if (!isFriend && getPreviousDeclForInstantiation(Pattern)) {
1170  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
1171  if (!Found.empty()) {
1172  PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.front());
1173  if (PrevClassTemplate)
1174  PrevDecl = PrevClassTemplate->getTemplatedDecl();
1175  }
1176  }
1177 
1178  // If this isn't a friend, then it's a member template, in which
1179  // case we just want to build the instantiation in the
1180  // specialization. If it is a friend, we want to build it in
1181  // the appropriate context.
1182  DeclContext *DC = Owner;
1183  if (isFriend) {
1184  if (QualifierLoc) {
1185  CXXScopeSpec SS;
1186  SS.Adopt(QualifierLoc);
1187  DC = SemaRef.computeDeclContext(SS);
1188  if (!DC) return nullptr;
1189  } else {
1190  DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
1191  Pattern->getDeclContext(),
1192  TemplateArgs);
1193  }
1194 
1195  // Look for a previous declaration of the template in the owning
1196  // context.
1197  LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
1199  SemaRef.forRedeclarationInCurContext());
1200  SemaRef.LookupQualifiedName(R, DC);
1201 
1202  if (R.isSingleResult()) {
1203  PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>();
1204  if (PrevClassTemplate)
1205  PrevDecl = PrevClassTemplate->getTemplatedDecl();
1206  }
1207 
1208  if (!PrevClassTemplate && QualifierLoc) {
1209  SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
1210  << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
1211  << QualifierLoc.getSourceRange();
1212  return nullptr;
1213  }
1214 
1215  bool AdoptedPreviousTemplateParams = false;
1216  if (PrevClassTemplate) {
1217  bool Complain = true;
1218 
1219  // HACK: libstdc++ 4.2.1 contains an ill-formed friend class
1220  // template for struct std::tr1::__detail::_Map_base, where the
1221  // template parameters of the friend declaration don't match the
1222  // template parameters of the original declaration. In this one
1223  // case, we don't complain about the ill-formed friend
1224  // declaration.
1225  if (isFriend && Pattern->getIdentifier() &&
1226  Pattern->getIdentifier()->isStr("_Map_base") &&
1227  DC->isNamespace() &&
1228  cast<NamespaceDecl>(DC)->getIdentifier() &&
1229  cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) {
1230  DeclContext *DCParent = DC->getParent();
1231  if (DCParent->isNamespace() &&
1232  cast<NamespaceDecl>(DCParent)->getIdentifier() &&
1233  cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) {
1234  if (cast<Decl>(DCParent)->isInStdNamespace())
1235  Complain = false;
1236  }
1237  }
1238 
1239  TemplateParameterList *PrevParams
1240  = PrevClassTemplate->getTemplateParameters();
1241 
1242  // Make sure the parameter lists match.
1243  if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams,
1244  Complain,
1246  if (Complain)
1247  return nullptr;
1248 
1249  AdoptedPreviousTemplateParams = true;
1250  InstParams = PrevParams;
1251  }
1252 
1253  // Do some additional validation, then merge default arguments
1254  // from the existing declarations.
1255  if (!AdoptedPreviousTemplateParams &&
1256  SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
1258  return nullptr;
1259  }
1260  }
1261 
1262  CXXRecordDecl *RecordInst
1263  = CXXRecordDecl::Create(SemaRef.Context, Pattern->getTagKind(), DC,
1264  Pattern->getLocStart(), Pattern->getLocation(),
1265  Pattern->getIdentifier(), PrevDecl,
1266  /*DelayTypeCreation=*/true);
1267 
1268  if (QualifierLoc)
1269  RecordInst->setQualifierInfo(QualifierLoc);
1270 
1271  ClassTemplateDecl *Inst
1272  = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
1273  D->getIdentifier(), InstParams, RecordInst);
1274  assert(!(isFriend && Owner->isDependentContext()));
1275  Inst->setPreviousDecl(PrevClassTemplate);
1276 
1277  RecordInst->setDescribedClassTemplate(Inst);
1278 
1279  if (isFriend) {
1280  if (PrevClassTemplate)
1281  Inst->setAccess(PrevClassTemplate->getAccess());
1282  else
1283  Inst->setAccess(D->getAccess());
1284 
1285  Inst->setObjectOfFriendDecl();
1286  // TODO: do we want to track the instantiation progeny of this
1287  // friend target decl?
1288  } else {
1289  Inst->setAccess(D->getAccess());
1290  if (!PrevClassTemplate)
1292  }
1293 
1294  // Trigger creation of the type for the instantiation.
1295  SemaRef.Context.getInjectedClassNameType(RecordInst,
1297 
1298  // Finish handling of friends.
1299  if (isFriend) {
1300  DC->makeDeclVisibleInContext(Inst);
1301  Inst->setLexicalDeclContext(Owner);
1302  RecordInst->setLexicalDeclContext(Owner);
1303  return Inst;
1304  }
1305 
1306  if (D->isOutOfLine()) {
1308  RecordInst->setLexicalDeclContext(D->getLexicalDeclContext());
1309  }
1310 
1311  Owner->addDecl(Inst);
1312 
1313  if (!PrevClassTemplate) {
1314  // Queue up any out-of-line partial specializations of this member
1315  // class template; the client will force their instantiation once
1316  // the enclosing class has been instantiated.
1318  D->getPartialSpecializations(PartialSpecs);
1319  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1320  if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1321  OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
1322  }
1323 
1324  return Inst;
1325 }
1326 
1327 Decl *
1328 TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
1330  ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
1331 
1332  // Lookup the already-instantiated declaration in the instantiation
1333  // of the class template and return that.
1335  = Owner->lookup(ClassTemplate->getDeclName());
1336  if (Found.empty())
1337  return nullptr;
1338 
1339  ClassTemplateDecl *InstClassTemplate
1340  = dyn_cast<ClassTemplateDecl>(Found.front());
1341  if (!InstClassTemplate)
1342  return nullptr;
1343 
1345  = InstClassTemplate->findPartialSpecInstantiatedFromMember(D))
1346  return Result;
1347 
1348  return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
1349 }
1350 
1351 Decl *TemplateDeclInstantiator::VisitVarTemplateDecl(VarTemplateDecl *D) {
1352  assert(D->getTemplatedDecl()->isStaticDataMember() &&
1353  "Only static data member templates are allowed.");
1354 
1355  // Create a local instantiation scope for this variable template, which
1356  // will contain the instantiations of the template parameters.
1357  LocalInstantiationScope Scope(SemaRef);
1358  TemplateParameterList *TempParams = D->getTemplateParameters();
1359  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1360  if (!InstParams)
1361  return nullptr;
1362 
1363  VarDecl *Pattern = D->getTemplatedDecl();
1364  VarTemplateDecl *PrevVarTemplate = nullptr;
1365 
1366  if (getPreviousDeclForInstantiation(Pattern)) {
1367  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
1368  if (!Found.empty())
1369  PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1370  }
1371 
1372  VarDecl *VarInst =
1373  cast_or_null<VarDecl>(VisitVarDecl(Pattern,
1374  /*InstantiatingVarTemplate=*/true));
1375  if (!VarInst) return nullptr;
1376 
1377  DeclContext *DC = Owner;
1378 
1380  SemaRef.Context, DC, D->getLocation(), D->getIdentifier(), InstParams,
1381  VarInst);
1382  VarInst->setDescribedVarTemplate(Inst);
1383  Inst->setPreviousDecl(PrevVarTemplate);
1384 
1385  Inst->setAccess(D->getAccess());
1386  if (!PrevVarTemplate)
1388 
1389  if (D->isOutOfLine()) {
1392  }
1393 
1394  Owner->addDecl(Inst);
1395 
1396  if (!PrevVarTemplate) {
1397  // Queue up any out-of-line partial specializations of this member
1398  // variable template; the client will force their instantiation once
1399  // the enclosing class has been instantiated.
1401  D->getPartialSpecializations(PartialSpecs);
1402  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1403  if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1404  OutOfLineVarPartialSpecs.push_back(
1405  std::make_pair(Inst, PartialSpecs[I]));
1406  }
1407 
1408  return Inst;
1409 }
1410 
1411 Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
1413  assert(D->isStaticDataMember() &&
1414  "Only static data member templates are allowed.");
1415 
1416  VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
1417 
1418  // Lookup the already-instantiated declaration and return that.
1419  DeclContext::lookup_result Found = Owner->lookup(VarTemplate->getDeclName());
1420  assert(!Found.empty() && "Instantiation found nothing?");
1421 
1422  VarTemplateDecl *InstVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1423  assert(InstVarTemplate && "Instantiation did not find a variable template?");
1424 
1426  InstVarTemplate->findPartialSpecInstantiatedFromMember(D))
1427  return Result;
1428 
1429  return InstantiateVarTemplatePartialSpecialization(InstVarTemplate, D);
1430 }
1431 
1432 Decl *
1433 TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1434  // Create a local instantiation scope for this function template, which
1435  // will contain the instantiations of the template parameters and then get
1436  // merged with the local instantiation scope for the function template
1437  // itself.
1438  LocalInstantiationScope Scope(SemaRef);
1439 
1440  TemplateParameterList *TempParams = D->getTemplateParameters();
1441  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1442  if (!InstParams)
1443  return nullptr;
1444 
1445  FunctionDecl *Instantiated = nullptr;
1446  if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
1447  Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod,
1448  InstParams));
1449  else
1450  Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl(
1451  D->getTemplatedDecl(),
1452  InstParams));
1453 
1454  if (!Instantiated)
1455  return nullptr;
1456 
1457  // Link the instantiated function template declaration to the function
1458  // template from which it was instantiated.
1459  FunctionTemplateDecl *InstTemplate
1460  = Instantiated->getDescribedFunctionTemplate();
1461  InstTemplate->setAccess(D->getAccess());
1462  assert(InstTemplate &&
1463  "VisitFunctionDecl/CXXMethodDecl didn't create a template!");
1464 
1465  bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None);
1466 
1467  // Link the instantiation back to the pattern *unless* this is a
1468  // non-definition friend declaration.
1469  if (!InstTemplate->getInstantiatedFromMemberTemplate() &&
1470  !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition()))
1471  InstTemplate->setInstantiatedFromMemberTemplate(D);
1472 
1473  // Make declarations visible in the appropriate context.
1474  if (!isFriend) {
1475  Owner->addDecl(InstTemplate);
1476  } else if (InstTemplate->getDeclContext()->isRecord() &&
1478  SemaRef.CheckFriendAccess(InstTemplate);
1479  }
1480 
1481  return InstTemplate;
1482 }
1483 
1484 Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
1485  CXXRecordDecl *PrevDecl = nullptr;
1486  if (D->isInjectedClassName())
1487  PrevDecl = cast<CXXRecordDecl>(Owner);
1488  else if (CXXRecordDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
1489  NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
1490  PatternPrev,
1491  TemplateArgs);
1492  if (!Prev) return nullptr;
1493  PrevDecl = cast<CXXRecordDecl>(Prev);
1494  }
1495 
1496  CXXRecordDecl *Record
1497  = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
1498  D->getLocStart(), D->getLocation(),
1499  D->getIdentifier(), PrevDecl);
1500 
1501  // Substitute the nested name specifier, if any.
1502  if (SubstQualifier(D, Record))
1503  return nullptr;
1504 
1505  Record->setImplicit(D->isImplicit());
1506  // FIXME: Check against AS_none is an ugly hack to work around the issue that
1507  // the tag decls introduced by friend class declarations don't have an access
1508  // specifier. Remove once this area of the code gets sorted out.
1509  if (D->getAccess() != AS_none)
1510  Record->setAccess(D->getAccess());
1511  if (!D->isInjectedClassName())
1512  Record->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
1513 
1514  // If the original function was part of a friend declaration,
1515  // inherit its namespace state.
1516  if (D->getFriendObjectKind())
1517  Record->setObjectOfFriendDecl();
1518 
1519  // Make sure that anonymous structs and unions are recorded.
1520  if (D->isAnonymousStructOrUnion())
1521  Record->setAnonymousStructOrUnion(true);
1522 
1523  if (D->isLocalClass())
1524  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record);
1525 
1526  // Forward the mangling number from the template to the instantiated decl.
1527  SemaRef.Context.setManglingNumber(Record,
1528  SemaRef.Context.getManglingNumber(D));
1529 
1530  // See if the old tag was defined along with a declarator.
1531  // If it did, mark the new tag as being associated with that declarator.
1533  SemaRef.Context.addDeclaratorForUnnamedTagDecl(Record, DD);
1534 
1535  // See if the old tag was defined along with a typedef.
1536  // If it did, mark the new tag as being associated with that typedef.
1538  SemaRef.Context.addTypedefNameForUnnamedTagDecl(Record, TND);
1539 
1540  Owner->addDecl(Record);
1541 
1542  // DR1484 clarifies that the members of a local class are instantiated as part
1543  // of the instantiation of their enclosing entity.
1544  if (D->isCompleteDefinition() && D->isLocalClass()) {
1545  Sema::LocalEagerInstantiationScope LocalInstantiations(SemaRef);
1546 
1547  SemaRef.InstantiateClass(D->getLocation(), Record, D, TemplateArgs,
1549  /*Complain=*/true);
1550 
1551  // For nested local classes, we will instantiate the members when we
1552  // reach the end of the outermost (non-nested) local class.
1553  if (!D->isCXXClassMember())
1554  SemaRef.InstantiateClassMembers(D->getLocation(), Record, TemplateArgs,
1556 
1557  // This class may have local implicit instantiations that need to be
1558  // performed within this scope.
1559  LocalInstantiations.perform();
1560  }
1561 
1562  SemaRef.DiagnoseUnusedNestedTypedefs(Record);
1563 
1564  return Record;
1565 }
1566 
1567 /// \brief Adjust the given function type for an instantiation of the
1568 /// given declaration, to cope with modifications to the function's type that
1569 /// aren't reflected in the type-source information.
1570 ///
1571 /// \param D The declaration we're instantiating.
1572 /// \param TInfo The already-instantiated type.
1574  FunctionDecl *D,
1575  TypeSourceInfo *TInfo) {
1576  const FunctionProtoType *OrigFunc
1577  = D->getType()->castAs<FunctionProtoType>();
1578  const FunctionProtoType *NewFunc
1579  = TInfo->getType()->castAs<FunctionProtoType>();
1580  if (OrigFunc->getExtInfo() == NewFunc->getExtInfo())
1581  return TInfo->getType();
1582 
1583  FunctionProtoType::ExtProtoInfo NewEPI = NewFunc->getExtProtoInfo();
1584  NewEPI.ExtInfo = OrigFunc->getExtInfo();
1585  return Context.getFunctionType(NewFunc->getReturnType(),
1586  NewFunc->getParamTypes(), NewEPI);
1587 }
1588 
1589 /// Normal class members are of more specific types and therefore
1590 /// don't make it here. This function serves three purposes:
1591 /// 1) instantiating function templates
1592 /// 2) substituting friend declarations
1593 /// 3) substituting deduction guide declarations for nested class templates
1595  TemplateParameterList *TemplateParams) {
1596  // Check whether there is already a function template specialization for
1597  // this declaration.
1598  FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1599  if (FunctionTemplate && !TemplateParams) {
1600  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1601 
1602  void *InsertPos = nullptr;
1603  FunctionDecl *SpecFunc
1604  = FunctionTemplate->findSpecialization(Innermost, InsertPos);
1605 
1606  // If we already have a function template specialization, return it.
1607  if (SpecFunc)
1608  return SpecFunc;
1609  }
1610 
1611  bool isFriend;
1612  if (FunctionTemplate)
1613  isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1614  else
1615  isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1616 
1617  bool MergeWithParentScope = (TemplateParams != nullptr) ||
1618  Owner->isFunctionOrMethod() ||
1619  !(isa<Decl>(Owner) &&
1620  cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1621  LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1622 
1624  TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1625  if (!TInfo)
1626  return nullptr;
1628 
1629  NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1630  if (QualifierLoc) {
1631  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1632  TemplateArgs);
1633  if (!QualifierLoc)
1634  return nullptr;
1635  }
1636 
1637  // If we're instantiating a local function declaration, put the result
1638  // in the enclosing namespace; otherwise we need to find the instantiated
1639  // context.
1640  DeclContext *DC;
1641  if (D->isLocalExternDecl()) {
1642  DC = Owner;
1643  SemaRef.adjustContextForLocalExternDecl(DC);
1644  } else if (isFriend && QualifierLoc) {
1645  CXXScopeSpec SS;
1646  SS.Adopt(QualifierLoc);
1647  DC = SemaRef.computeDeclContext(SS);
1648  if (!DC) return nullptr;
1649  } else {
1650  DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
1651  TemplateArgs);
1652  }
1653 
1654  DeclarationNameInfo NameInfo
1655  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1656 
1657  FunctionDecl *Function;
1658  if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
1659  Function = CXXDeductionGuideDecl::Create(
1660  SemaRef.Context, DC, D->getInnerLocStart(), DGuide->isExplicit(),
1661  NameInfo, T, TInfo, D->getSourceRange().getEnd());
1662  if (DGuide->isCopyDeductionCandidate())
1663  cast<CXXDeductionGuideDecl>(Function)->setIsCopyDeductionCandidate();
1664  } else {
1665  Function = FunctionDecl::Create(
1666  SemaRef.Context, DC, D->getInnerLocStart(), NameInfo, T, TInfo,
1668  D->hasWrittenPrototype(), D->isConstexpr());
1669  Function->setRangeEnd(D->getSourceRange().getEnd());
1670  }
1671 
1672  if (D->isInlined())
1673  Function->setImplicitlyInline();
1674 
1675  if (QualifierLoc)
1676  Function->setQualifierInfo(QualifierLoc);
1677 
1678  if (D->isLocalExternDecl())
1679  Function->setLocalExternDecl();
1680 
1681  DeclContext *LexicalDC = Owner;
1682  if (!isFriend && D->isOutOfLine() && !D->isLocalExternDecl()) {
1683  assert(D->getDeclContext()->isFileContext());
1684  LexicalDC = D->getDeclContext();
1685  }
1686 
1687  Function->setLexicalDeclContext(LexicalDC);
1688 
1689  // Attach the parameters
1690  for (unsigned P = 0; P < Params.size(); ++P)
1691  if (Params[P])
1692  Params[P]->setOwningFunction(Function);
1693  Function->setParams(Params);
1694 
1695  if (TemplateParams) {
1696  // Our resulting instantiation is actually a function template, since we
1697  // are substituting only the outer template parameters. For example, given
1698  //
1699  // template<typename T>
1700  // struct X {
1701  // template<typename U> friend void f(T, U);
1702  // };
1703  //
1704  // X<int> x;
1705  //
1706  // We are instantiating the friend function template "f" within X<int>,
1707  // which means substituting int for T, but leaving "f" as a friend function
1708  // template.
1709  // Build the function template itself.
1710  FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
1711  Function->getLocation(),
1712  Function->getDeclName(),
1713  TemplateParams, Function);
1714  Function->setDescribedFunctionTemplate(FunctionTemplate);
1715 
1716  FunctionTemplate->setLexicalDeclContext(LexicalDC);
1717 
1718  if (isFriend && D->isThisDeclarationADefinition()) {
1719  FunctionTemplate->setInstantiatedFromMemberTemplate(
1721  }
1722  } else if (FunctionTemplate) {
1723  // Record this function template specialization.
1724  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1725  Function->setFunctionTemplateSpecialization(FunctionTemplate,
1727  Innermost),
1728  /*InsertPos=*/nullptr);
1729  } else if (isFriend && D->isThisDeclarationADefinition()) {
1730  // Do not connect the friend to the template unless it's actually a
1731  // definition. We don't want non-template functions to be marked as being
1732  // template instantiations.
1733  Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1734  }
1735 
1736  if (InitFunctionInstantiation(Function, D))
1737  Function->setInvalidDecl();
1738 
1739  bool isExplicitSpecialization = false;
1740 
1742  SemaRef, Function->getDeclName(), SourceLocation(),
1746  : SemaRef.forRedeclarationInCurContext());
1747 
1750  assert(isFriend && "non-friend has dependent specialization info?");
1751 
1752  // This needs to be set now for future sanity.
1753  Function->setObjectOfFriendDecl();
1754 
1755  // Instantiate the explicit template arguments.
1756  TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
1757  Info->getRAngleLoc());
1758  if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
1759  ExplicitArgs, TemplateArgs))
1760  return nullptr;
1761 
1762  // Map the candidate templates to their instantiations.
1763  for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
1764  Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
1765  Info->getTemplate(I),
1766  TemplateArgs);
1767  if (!Temp) return nullptr;
1768 
1769  Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
1770  }
1771 
1772  if (SemaRef.CheckFunctionTemplateSpecialization(Function,
1773  &ExplicitArgs,
1774  Previous))
1775  Function->setInvalidDecl();
1776 
1777  isExplicitSpecialization = true;
1778 
1779  } else if (TemplateParams || !FunctionTemplate) {
1780  // Look only into the namespace where the friend would be declared to
1781  // find a previous declaration. This is the innermost enclosing namespace,
1782  // as described in ActOnFriendFunctionDecl.
1783  SemaRef.LookupQualifiedName(Previous, DC);
1784 
1785  // In C++, the previous declaration we find might be a tag type
1786  // (class or enum). In this case, the new declaration will hide the
1787  // tag type. Note that this does does not apply if we're declaring a
1788  // typedef (C++ [dcl.typedef]p4).
1789  if (Previous.isSingleTagDecl())
1790  Previous.clear();
1791  }
1792 
1793  if (isFriend)
1794  Function->setObjectOfFriendDecl();
1795 
1796  SemaRef.CheckFunctionDeclaration(/*Scope*/ nullptr, Function, Previous,
1797  isExplicitSpecialization);
1798 
1799  NamedDecl *PrincipalDecl = (TemplateParams
1800  ? cast<NamedDecl>(FunctionTemplate)
1801  : Function);
1802 
1803  // If the original function was part of a friend declaration,
1804  // inherit its namespace state and add it to the owner.
1805  if (isFriend) {
1806  PrincipalDecl->setObjectOfFriendDecl();
1807  DC->makeDeclVisibleInContext(PrincipalDecl);
1808 
1809  bool QueuedInstantiation = false;
1810 
1811  // C++11 [temp.friend]p4 (DR329):
1812  // When a function is defined in a friend function declaration in a class
1813  // template, the function is instantiated when the function is odr-used.
1814  // The same restrictions on multiple declarations and definitions that
1815  // apply to non-template function declarations and definitions also apply
1816  // to these implicit definitions.
1817  if (D->isThisDeclarationADefinition()) {
1818  // Check for a function body.
1819  const FunctionDecl *Definition = nullptr;
1820  if (Function->isDefined(Definition) &&
1821  Definition->getTemplateSpecializationKind() == TSK_Undeclared) {
1822  SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
1823  << Function->getDeclName();
1824  SemaRef.Diag(Definition->getLocation(), diag::note_previous_definition);
1825  }
1826  // Check for redefinitions due to other instantiations of this or
1827  // a similar friend function.
1828  else for (auto R : Function->redecls()) {
1829  if (R == Function)
1830  continue;
1831 
1832  // If some prior declaration of this function has been used, we need
1833  // to instantiate its definition.
1834  if (!QueuedInstantiation && R->isUsed(false)) {
1835  if (MemberSpecializationInfo *MSInfo =
1836  Function->getMemberSpecializationInfo()) {
1837  if (MSInfo->getPointOfInstantiation().isInvalid()) {
1838  SourceLocation Loc = R->getLocation(); // FIXME
1839  MSInfo->setPointOfInstantiation(Loc);
1840  SemaRef.PendingLocalImplicitInstantiations.push_back(
1841  std::make_pair(Function, Loc));
1842  QueuedInstantiation = true;
1843  }
1844  }
1845  }
1846 
1847  // If some prior declaration of this function was a friend with an
1848  // uninstantiated definition, reject it.
1849  if (R->getFriendObjectKind()) {
1850  if (const FunctionDecl *RPattern =
1852  if (RPattern->isDefined(RPattern)) {
1853  SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
1854  << Function->getDeclName();
1855  SemaRef.Diag(R->getLocation(), diag::note_previous_definition);
1856  break;
1857  }
1858  }
1859  }
1860  }
1861  }
1862 
1863  // Check the template parameter list against the previous declaration. The
1864  // goal here is to pick up default arguments added since the friend was
1865  // declared; we know the template parameter lists match, since otherwise
1866  // we would not have picked this template as the previous declaration.
1867  if (TemplateParams && FunctionTemplate->getPreviousDecl()) {
1869  TemplateParams,
1870  FunctionTemplate->getPreviousDecl()->getTemplateParameters(),
1871  Function->isThisDeclarationADefinition()
1874  }
1875  }
1876 
1877  if (Function->isLocalExternDecl() && !Function->getPreviousDecl())
1878  DC->makeDeclVisibleInContext(PrincipalDecl);
1879 
1880  if (Function->isOverloadedOperator() && !DC->isRecord() &&
1882  PrincipalDecl->setNonMemberOperator();
1883 
1884  assert(!D->isDefaulted() && "only methods should be defaulted");
1885  return Function;
1886 }
1887 
1888 Decl *
1890  TemplateParameterList *TemplateParams,
1891  bool IsClassScopeSpecialization) {
1892  FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1893  if (FunctionTemplate && !TemplateParams) {
1894  // We are creating a function template specialization from a function
1895  // template. Check whether there is already a function template
1896  // specialization for this particular set of template arguments.
1897  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1898 
1899  void *InsertPos = nullptr;
1900  FunctionDecl *SpecFunc
1901  = FunctionTemplate->findSpecialization(Innermost, InsertPos);
1902 
1903  // If we already have a function template specialization, return it.
1904  if (SpecFunc)
1905  return SpecFunc;
1906  }
1907 
1908  bool isFriend;
1909  if (FunctionTemplate)
1910  isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1911  else
1912  isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1913 
1914  bool MergeWithParentScope = (TemplateParams != nullptr) ||
1915  !(isa<Decl>(Owner) &&
1916  cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1917  LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1918 
1919  // Instantiate enclosing template arguments for friends.
1921  unsigned NumTempParamLists = 0;
1922  if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
1923  TempParamLists.resize(NumTempParamLists);
1924  for (unsigned I = 0; I != NumTempParamLists; ++I) {
1925  TemplateParameterList *TempParams = D->getTemplateParameterList(I);
1926  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1927  if (!InstParams)
1928  return nullptr;
1929  TempParamLists[I] = InstParams;
1930  }
1931  }
1932 
1934  TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1935  if (!TInfo)
1936  return nullptr;
1938 
1939  NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1940  if (QualifierLoc) {
1941  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1942  TemplateArgs);
1943  if (!QualifierLoc)
1944  return nullptr;
1945  }
1946 
1947  DeclContext *DC = Owner;
1948  if (isFriend) {
1949  if (QualifierLoc) {
1950  CXXScopeSpec SS;
1951  SS.Adopt(QualifierLoc);
1952  DC = SemaRef.computeDeclContext(SS);
1953 
1954  if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
1955  return nullptr;
1956  } else {
1957  DC = SemaRef.FindInstantiatedContext(D->getLocation(),
1958  D->getDeclContext(),
1959  TemplateArgs);
1960  }
1961  if (!DC) return nullptr;
1962  }
1963 
1964  // Build the instantiated method declaration.
1965  CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
1966  CXXMethodDecl *Method = nullptr;
1967 
1968  SourceLocation StartLoc = D->getInnerLocStart();
1969  DeclarationNameInfo NameInfo
1970  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1971  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
1972  Method = CXXConstructorDecl::Create(SemaRef.Context, Record,
1973  StartLoc, NameInfo, T, TInfo,
1974  Constructor->isExplicit(),
1975  Constructor->isInlineSpecified(),
1976  false, Constructor->isConstexpr());
1977  Method->setRangeEnd(Constructor->getLocEnd());
1978  } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
1979  Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
1980  StartLoc, NameInfo, T, TInfo,
1981  Destructor->isInlineSpecified(),
1982  false);
1983  Method->setRangeEnd(Destructor->getLocEnd());
1984  } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
1985  Method = CXXConversionDecl::Create(SemaRef.Context, Record,
1986  StartLoc, NameInfo, T, TInfo,
1987  Conversion->isInlineSpecified(),
1988  Conversion->isExplicit(),
1989  Conversion->isConstexpr(),
1990  Conversion->getLocEnd());
1991  } else {
1992  StorageClass SC = D->isStatic() ? SC_Static : SC_None;
1993  Method = CXXMethodDecl::Create(SemaRef.Context, Record,
1994  StartLoc, NameInfo, T, TInfo,
1995  SC, D->isInlineSpecified(),
1996  D->isConstexpr(), D->getLocEnd());
1997  }
1998 
1999  if (D->isInlined())
2000  Method->setImplicitlyInline();
2001 
2002  if (QualifierLoc)
2003  Method->setQualifierInfo(QualifierLoc);
2004 
2005  if (TemplateParams) {
2006  // Our resulting instantiation is actually a function template, since we
2007  // are substituting only the outer template parameters. For example, given
2008  //
2009  // template<typename T>
2010  // struct X {
2011  // template<typename U> void f(T, U);
2012  // };
2013  //
2014  // X<int> x;
2015  //
2016  // We are instantiating the member template "f" within X<int>, which means
2017  // substituting int for T, but leaving "f" as a member function template.
2018  // Build the function template itself.
2019  FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
2020  Method->getLocation(),
2021  Method->getDeclName(),
2022  TemplateParams, Method);
2023  if (isFriend) {
2024  FunctionTemplate->setLexicalDeclContext(Owner);
2025  FunctionTemplate->setObjectOfFriendDecl();
2026  } else if (D->isOutOfLine())
2027  FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
2028  Method->setDescribedFunctionTemplate(FunctionTemplate);
2029  } else if (FunctionTemplate) {
2030  // Record this function template specialization.
2031  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
2032  Method->setFunctionTemplateSpecialization(FunctionTemplate,
2034  Innermost),
2035  /*InsertPos=*/nullptr);
2036  } else if (!isFriend) {
2037  // Record that this is an instantiation of a member function.
2038  Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
2039  }
2040 
2041  // If we are instantiating a member function defined
2042  // out-of-line, the instantiation will have the same lexical
2043  // context (which will be a namespace scope) as the template.
2044  if (isFriend) {
2045  if (NumTempParamLists)
2046  Method->setTemplateParameterListsInfo(
2047  SemaRef.Context,
2048  llvm::makeArrayRef(TempParamLists.data(), NumTempParamLists));
2049 
2050  Method->setLexicalDeclContext(Owner);
2051  Method->setObjectOfFriendDecl();
2052  } else if (D->isOutOfLine())
2053  Method->setLexicalDeclContext(D->getLexicalDeclContext());
2054 
2055  // Attach the parameters
2056  for (unsigned P = 0; P < Params.size(); ++P)
2057  Params[P]->setOwningFunction(Method);
2058  Method->setParams(Params);
2059 
2060  if (InitMethodInstantiation(Method, D))
2061  Method->setInvalidDecl();
2062 
2063  LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
2065 
2066  if (!FunctionTemplate || TemplateParams || isFriend) {
2067  SemaRef.LookupQualifiedName(Previous, Record);
2068 
2069  // In C++, the previous declaration we find might be a tag type
2070  // (class or enum). In this case, the new declaration will hide the
2071  // tag type. Note that this does does not apply if we're declaring a
2072  // typedef (C++ [dcl.typedef]p4).
2073  if (Previous.isSingleTagDecl())
2074  Previous.clear();
2075  }
2076 
2077  if (!IsClassScopeSpecialization)
2078  SemaRef.CheckFunctionDeclaration(nullptr, Method, Previous, false);
2079 
2080  if (D->isPure())
2081  SemaRef.CheckPureMethod(Method, SourceRange());
2082 
2083  // Propagate access. For a non-friend declaration, the access is
2084  // whatever we're propagating from. For a friend, it should be the
2085  // previous declaration we just found.
2086  if (isFriend && Method->getPreviousDecl())
2087  Method->setAccess(Method->getPreviousDecl()->getAccess());
2088  else
2089  Method->setAccess(D->getAccess());
2090  if (FunctionTemplate)
2091  FunctionTemplate->setAccess(Method->getAccess());
2092 
2093  SemaRef.CheckOverrideControl(Method);
2094 
2095  // If a function is defined as defaulted or deleted, mark it as such now.
2096  if (D->isExplicitlyDefaulted())
2097  SemaRef.SetDeclDefaulted(Method, Method->getLocation());
2098  if (D->isDeletedAsWritten())
2099  SemaRef.SetDeclDeleted(Method, Method->getLocation());
2100 
2101  // If there's a function template, let our caller handle it.
2102  if (FunctionTemplate) {
2103  // do nothing
2104 
2105  // Don't hide a (potentially) valid declaration with an invalid one.
2106  } else if (Method->isInvalidDecl() && !Previous.empty()) {
2107  // do nothing
2108 
2109  // Otherwise, check access to friends and make them visible.
2110  } else if (isFriend) {
2111  // We only need to re-check access for methods which we didn't
2112  // manage to match during parsing.
2113  if (!D->getPreviousDecl())
2114  SemaRef.CheckFriendAccess(Method);
2115 
2116  Record->makeDeclVisibleInContext(Method);
2117 
2118  // Otherwise, add the declaration. We don't need to do this for
2119  // class-scope specializations because we'll have matched them with
2120  // the appropriate template.
2121  } else if (!IsClassScopeSpecialization) {
2122  Owner->addDecl(Method);
2123  }
2124 
2125  return Method;
2126 }
2127 
2128 Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2129  return VisitCXXMethodDecl(D);
2130 }
2131 
2132 Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2133  return VisitCXXMethodDecl(D);
2134 }
2135 
2136 Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
2137  return VisitCXXMethodDecl(D);
2138 }
2139 
2140 Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
2141  return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None,
2142  /*ExpectParameterPack=*/ false);
2143 }
2144 
2145 Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
2146  TemplateTypeParmDecl *D) {
2147  // TODO: don't always clone when decls are refcounted.
2148  assert(D->getTypeForDecl()->isTemplateTypeParmType());
2149 
2151  SemaRef.Context, Owner, D->getLocStart(), D->getLocation(),
2152  D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),
2154  Inst->setAccess(AS_public);
2155 
2156  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2157  TypeSourceInfo *InstantiatedDefaultArg =
2158  SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
2159  D->getDefaultArgumentLoc(), D->getDeclName());
2160  if (InstantiatedDefaultArg)
2161  Inst->setDefaultArgument(InstantiatedDefaultArg);
2162  }
2163 
2164  // Introduce this template parameter's instantiation into the instantiation
2165  // scope.
2166  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
2167 
2168  return Inst;
2169 }
2170 
2171 Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
2173  // Substitute into the type of the non-type template parameter.
2174  TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
2175  SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
2176  SmallVector<QualType, 4> ExpandedParameterPackTypes;
2177  bool IsExpandedParameterPack = false;
2178  TypeSourceInfo *DI;
2179  QualType T;
2180  bool Invalid = false;
2181 
2182  if (D->isExpandedParameterPack()) {
2183  // The non-type template parameter pack is an already-expanded pack
2184  // expansion of types. Substitute into each of the expanded types.
2185  ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
2186  ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
2187  for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2188  TypeSourceInfo *NewDI =
2189  SemaRef.SubstType(D->getExpansionTypeSourceInfo(I), TemplateArgs,
2190  D->getLocation(), D->getDeclName());
2191  if (!NewDI)
2192  return nullptr;
2193 
2194  QualType NewT =
2195  SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
2196  if (NewT.isNull())
2197  return nullptr;
2198 
2199  ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2200  ExpandedParameterPackTypes.push_back(NewT);
2201  }
2202 
2203  IsExpandedParameterPack = true;
2204  DI = D->getTypeSourceInfo();
2205  T = DI->getType();
2206  } else if (D->isPackExpansion()) {
2207  // The non-type template parameter pack's type is a pack expansion of types.
2208  // Determine whether we need to expand this parameter pack into separate
2209  // types.
2211  TypeLoc Pattern = Expansion.getPatternLoc();
2213  SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
2214 
2215  // Determine whether the set of unexpanded parameter packs can and should
2216  // be expanded.
2217  bool Expand = true;
2218  bool RetainExpansion = false;
2219  Optional<unsigned> OrigNumExpansions
2220  = Expansion.getTypePtr()->getNumExpansions();
2221  Optional<unsigned> NumExpansions = OrigNumExpansions;
2222  if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
2223  Pattern.getSourceRange(),
2224  Unexpanded,
2225  TemplateArgs,
2226  Expand, RetainExpansion,
2227  NumExpansions))
2228  return nullptr;
2229 
2230  if (Expand) {
2231  for (unsigned I = 0; I != *NumExpansions; ++I) {
2232  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2233  TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
2234  D->getLocation(),
2235  D->getDeclName());
2236  if (!NewDI)
2237  return nullptr;
2238 
2239  QualType NewT =
2240  SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
2241  if (NewT.isNull())
2242  return nullptr;
2243 
2244  ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2245  ExpandedParameterPackTypes.push_back(NewT);
2246  }
2247 
2248  // Note that we have an expanded parameter pack. The "type" of this
2249  // expanded parameter pack is the original expansion type, but callers
2250  // will end up using the expanded parameter pack types for type-checking.
2251  IsExpandedParameterPack = true;
2252  DI = D->getTypeSourceInfo();
2253  T = DI->getType();
2254  } else {
2255  // We cannot fully expand the pack expansion now, so substitute into the
2256  // pattern and create a new pack expansion type.
2257  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2258  TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
2259  D->getLocation(),
2260  D->getDeclName());
2261  if (!NewPattern)
2262  return nullptr;
2263 
2264  SemaRef.CheckNonTypeTemplateParameterType(NewPattern, D->getLocation());
2265  DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
2266  NumExpansions);
2267  if (!DI)
2268  return nullptr;
2269 
2270  T = DI->getType();
2271  }
2272  } else {
2273  // Simple case: substitution into a parameter that is not a parameter pack.
2274  DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
2275  D->getLocation(), D->getDeclName());
2276  if (!DI)
2277  return nullptr;
2278 
2279  // Check that this type is acceptable for a non-type template parameter.
2280  T = SemaRef.CheckNonTypeTemplateParameterType(DI, D->getLocation());
2281  if (T.isNull()) {
2282  T = SemaRef.Context.IntTy;
2283  Invalid = true;
2284  }
2285  }
2286 
2287  NonTypeTemplateParmDecl *Param;
2288  if (IsExpandedParameterPack)
2290  SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2291  D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2292  D->getPosition(), D->getIdentifier(), T, DI, ExpandedParameterPackTypes,
2293  ExpandedParameterPackTypesAsWritten);
2294  else
2296  SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2297  D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2298  D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI);
2299 
2300  Param->setAccess(AS_public);
2301  if (Invalid)
2302  Param->setInvalidDecl();
2303 
2304  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2305  EnterExpressionEvaluationContext ConstantEvaluated(
2307  ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
2308  if (!Value.isInvalid())
2309  Param->setDefaultArgument(Value.get());
2310  }
2311 
2312  // Introduce this template parameter's instantiation into the instantiation
2313  // scope.
2314  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2315  return Param;
2316 }
2317 
2319  Sema &S,
2320  TemplateParameterList *Params,
2322  for (const auto &P : *Params) {
2323  if (P->isTemplateParameterPack())
2324  continue;
2325  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
2326  S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(),
2327  Unexpanded);
2328  if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
2329  collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(),
2330  Unexpanded);
2331  }
2332 }
2333 
2334 Decl *
2335 TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
2337  // Instantiate the template parameter list of the template template parameter.
2338  TemplateParameterList *TempParams = D->getTemplateParameters();
2339  TemplateParameterList *InstParams;
2341 
2342  bool IsExpandedParameterPack = false;
2343 
2344  if (D->isExpandedParameterPack()) {
2345  // The template template parameter pack is an already-expanded pack
2346  // expansion of template parameters. Substitute into each of the expanded
2347  // parameters.
2348  ExpandedParams.reserve(D->getNumExpansionTemplateParameters());
2349  for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2350  I != N; ++I) {
2351  LocalInstantiationScope Scope(SemaRef);
2352  TemplateParameterList *Expansion =
2354  if (!Expansion)
2355  return nullptr;
2356  ExpandedParams.push_back(Expansion);
2357  }
2358 
2359  IsExpandedParameterPack = true;
2360  InstParams = TempParams;
2361  } else if (D->isPackExpansion()) {
2362  // The template template parameter pack expands to a pack of template
2363  // template parameters. Determine whether we need to expand this parameter
2364  // pack into separate parameters.
2367  Unexpanded);
2368 
2369  // Determine whether the set of unexpanded parameter packs can and should
2370  // be expanded.
2371  bool Expand = true;
2372  bool RetainExpansion = false;
2373  Optional<unsigned> NumExpansions;
2375  TempParams->getSourceRange(),
2376  Unexpanded,
2377  TemplateArgs,
2378  Expand, RetainExpansion,
2379  NumExpansions))
2380  return nullptr;
2381 
2382  if (Expand) {
2383  for (unsigned I = 0; I != *NumExpansions; ++I) {
2384  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2385  LocalInstantiationScope Scope(SemaRef);
2386  TemplateParameterList *Expansion = SubstTemplateParams(TempParams);
2387  if (!Expansion)
2388  return nullptr;
2389  ExpandedParams.push_back(Expansion);
2390  }
2391 
2392  // Note that we have an expanded parameter pack. The "type" of this
2393  // expanded parameter pack is the original expansion type, but callers
2394  // will end up using the expanded parameter pack types for type-checking.
2395  IsExpandedParameterPack = true;
2396  InstParams = TempParams;
2397  } else {
2398  // We cannot fully expand the pack expansion now, so just substitute
2399  // into the pattern.
2400  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2401 
2402  LocalInstantiationScope Scope(SemaRef);
2403  InstParams = SubstTemplateParams(TempParams);
2404  if (!InstParams)
2405  return nullptr;
2406  }
2407  } else {
2408  // Perform the actual substitution of template parameters within a new,
2409  // local instantiation scope.
2410  LocalInstantiationScope Scope(SemaRef);
2411  InstParams = SubstTemplateParams(TempParams);
2412  if (!InstParams)
2413  return nullptr;
2414  }
2415 
2416  // Build the template template parameter.
2417  TemplateTemplateParmDecl *Param;
2418  if (IsExpandedParameterPack)
2420  SemaRef.Context, Owner, D->getLocation(),
2421  D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2422  D->getPosition(), D->getIdentifier(), InstParams, ExpandedParams);
2423  else
2425  SemaRef.Context, Owner, D->getLocation(),
2426  D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
2427  D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams);
2428  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2429  NestedNameSpecifierLoc QualifierLoc =
2431  QualifierLoc =
2432  SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
2433  TemplateName TName = SemaRef.SubstTemplateName(
2434  QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
2435  D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
2436  if (!TName.isNull())
2437  Param->setDefaultArgument(
2438  SemaRef.Context,
2442  }
2443  Param->setAccess(AS_public);
2444 
2445  // Introduce this template parameter's instantiation into the instantiation
2446  // scope.
2447  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2448 
2449  return Param;
2450 }
2451 
2452 Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
2453  // Using directives are never dependent (and never contain any types or
2454  // expressions), so they require no explicit instantiation work.
2455 
2456  UsingDirectiveDecl *Inst
2457  = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
2459  D->getQualifierLoc(),
2460  D->getIdentLocation(),
2461  D->getNominatedNamespace(),
2462  D->getCommonAncestor());
2463 
2464  // Add the using directive to its declaration context
2465  // only if this is not a function or method.
2466  if (!Owner->isFunctionOrMethod())
2467  Owner->addDecl(Inst);
2468 
2469  return Inst;
2470 }
2471 
2472 Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
2473 
2474  // The nested name specifier may be dependent, for example
2475  // template <typename T> struct t {
2476  // struct s1 { T f1(); };
2477  // struct s2 : s1 { using s1::f1; };
2478  // };
2479  // template struct t<int>;
2480  // Here, in using s1::f1, s1 refers to t<T>::s1;
2481  // we need to substitute for t<int>::s1.
2482  NestedNameSpecifierLoc QualifierLoc
2484  TemplateArgs);
2485  if (!QualifierLoc)
2486  return nullptr;
2487 
2488  // For an inheriting constructor declaration, the name of the using
2489  // declaration is the name of a constructor in this class, not in the
2490  // base class.
2491  DeclarationNameInfo NameInfo = D->getNameInfo();
2493  if (auto *RD = dyn_cast<CXXRecordDecl>(SemaRef.CurContext))
2495  SemaRef.Context.getCanonicalType(SemaRef.Context.getRecordType(RD))));
2496 
2497  // We only need to do redeclaration lookups if we're in a class
2498  // scope (in fact, it's not really even possible in non-class
2499  // scopes).
2500  bool CheckRedeclaration = Owner->isRecord();
2501 
2502  LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
2504 
2505  UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
2506  D->getUsingLoc(),
2507  QualifierLoc,
2508  NameInfo,
2509  D->hasTypename());
2510 
2511  CXXScopeSpec SS;
2512  SS.Adopt(QualifierLoc);
2513  if (CheckRedeclaration) {
2514  Prev.setHideTags(false);
2515  SemaRef.LookupQualifiedName(Prev, Owner);
2516 
2517  // Check for invalid redeclarations.
2518  if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLoc(),
2519  D->hasTypename(), SS,
2520  D->getLocation(), Prev))
2521  NewUD->setInvalidDecl();
2522 
2523  }
2524 
2525  if (!NewUD->isInvalidDecl() &&
2526  SemaRef.CheckUsingDeclQualifier(D->getUsingLoc(), D->hasTypename(),
2527  SS, NameInfo, D->getLocation()))
2528  NewUD->setInvalidDecl();
2529 
2530  SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
2531  NewUD->setAccess(D->getAccess());
2532  Owner->addDecl(NewUD);
2533 
2534  // Don't process the shadow decls for an invalid decl.
2535  if (NewUD->isInvalidDecl())
2536  return NewUD;
2537 
2538  if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
2539  SemaRef.CheckInheritingConstructorUsingDecl(NewUD);
2540 
2541  bool isFunctionScope = Owner->isFunctionOrMethod();
2542 
2543  // Process the shadow decls.
2544  for (auto *Shadow : D->shadows()) {
2545  // FIXME: UsingShadowDecl doesn't preserve its immediate target, so
2546  // reconstruct it in the case where it matters.
2547  NamedDecl *OldTarget = Shadow->getTargetDecl();
2548  if (auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
2549  if (auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
2550  OldTarget = BaseShadow;
2551 
2552  NamedDecl *InstTarget =
2553  cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
2554  Shadow->getLocation(), OldTarget, TemplateArgs));
2555  if (!InstTarget)
2556  return nullptr;
2557 
2558  UsingShadowDecl *PrevDecl = nullptr;
2559  if (CheckRedeclaration) {
2560  if (SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev, PrevDecl))
2561  continue;
2562  } else if (UsingShadowDecl *OldPrev =
2564  PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
2565  Shadow->getLocation(), OldPrev, TemplateArgs));
2566  }
2567 
2568  UsingShadowDecl *InstShadow =
2569  SemaRef.BuildUsingShadowDecl(/*Scope*/nullptr, NewUD, InstTarget,
2570  PrevDecl);
2571  SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
2572 
2573  if (isFunctionScope)
2574  SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
2575  }
2576 
2577  return NewUD;
2578 }
2579 
2580 Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
2581  // Ignore these; we handle them in bulk when processing the UsingDecl.
2582  return nullptr;
2583 }
2584 
2585 Decl *TemplateDeclInstantiator::VisitConstructorUsingShadowDecl(
2587  // Ignore these; we handle them in bulk when processing the UsingDecl.
2588  return nullptr;
2589 }
2590 
2591 template <typename T>
2592 Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(
2593  T *D, bool InstantiatingPackElement) {
2594  // If this is a pack expansion, expand it now.
2595  if (D->isPackExpansion() && !InstantiatingPackElement) {
2597  SemaRef.collectUnexpandedParameterPacks(D->getQualifierLoc(), Unexpanded);
2598  SemaRef.collectUnexpandedParameterPacks(D->getNameInfo(), Unexpanded);
2599 
2600  // Determine whether the set of unexpanded parameter packs can and should
2601  // be expanded.
2602  bool Expand = true;
2603  bool RetainExpansion = false;
2604  Optional<unsigned> NumExpansions;
2605  if (SemaRef.CheckParameterPacksForExpansion(
2606  D->getEllipsisLoc(), D->getSourceRange(), Unexpanded, TemplateArgs,
2607  Expand, RetainExpansion, NumExpansions))
2608  return nullptr;
2609 
2610  // This declaration cannot appear within a function template signature,
2611  // so we can't have a partial argument list for a parameter pack.
2612  assert(!RetainExpansion &&
2613  "should never need to retain an expansion for UsingPackDecl");
2614 
2615  if (!Expand) {
2616  // We cannot fully expand the pack expansion now, so substitute into the
2617  // pattern and create a new pack expansion.
2618  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2619  return instantiateUnresolvedUsingDecl(D, true);
2620  }
2621 
2622  // Within a function, we don't have any normal way to check for conflicts
2623  // between shadow declarations from different using declarations in the
2624  // same pack expansion, but this is always ill-formed because all expansions
2625  // must produce (conflicting) enumerators.
2626  //
2627  // Sadly we can't just reject this in the template definition because it
2628  // could be valid if the pack is empty or has exactly one expansion.
2629  if (D->getDeclContext()->isFunctionOrMethod() && *NumExpansions > 1) {
2630  SemaRef.Diag(D->getEllipsisLoc(),
2631  diag::err_using_decl_redeclaration_expansion);
2632  return nullptr;
2633  }
2634 
2635  // Instantiate the slices of this pack and build a UsingPackDecl.
2636  SmallVector<NamedDecl*, 8> Expansions;
2637  for (unsigned I = 0; I != *NumExpansions; ++I) {
2638  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2639  Decl *Slice = instantiateUnresolvedUsingDecl(D, true);
2640  if (!Slice)
2641  return nullptr;
2642  // Note that we can still get unresolved using declarations here, if we
2643  // had arguments for all packs but the pattern also contained other
2644  // template arguments (this only happens during partial substitution, eg
2645  // into the body of a generic lambda in a function template).
2646  Expansions.push_back(cast<NamedDecl>(Slice));
2647  }
2648 
2649  auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
2650  if (isDeclWithinFunction(D))
2651  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
2652  return NewD;
2653  }
2654 
2656  SourceLocation TypenameLoc = TD ? TD->getTypenameLoc() : SourceLocation();
2657 
2658  NestedNameSpecifierLoc QualifierLoc
2659  = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
2660  TemplateArgs);
2661  if (!QualifierLoc)
2662  return nullptr;
2663 
2664  CXXScopeSpec SS;
2665  SS.Adopt(QualifierLoc);
2666 
2667  DeclarationNameInfo NameInfo
2668  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
2669 
2670  // Produce a pack expansion only if we're not instantiating a particular
2671  // slice of a pack expansion.
2672  bool InstantiatingSlice = D->getEllipsisLoc().isValid() &&
2673  SemaRef.ArgumentPackSubstitutionIndex != -1;
2674  SourceLocation EllipsisLoc =
2675  InstantiatingSlice ? SourceLocation() : D->getEllipsisLoc();
2676 
2677  NamedDecl *UD = SemaRef.BuildUsingDeclaration(
2678  /*Scope*/ nullptr, D->getAccess(), D->getUsingLoc(),
2679  /*HasTypename*/ TD, TypenameLoc, SS, NameInfo, EllipsisLoc, nullptr,
2680  /*IsInstantiation*/ true);
2681  if (UD)
2682  SemaRef.Context.setInstantiatedFromUsingDecl(UD, D);
2683 
2684  return UD;
2685 }
2686 
2687 Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
2689  return instantiateUnresolvedUsingDecl(D);
2690 }
2691 
2692 Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
2694  return instantiateUnresolvedUsingDecl(D);
2695 }
2696 
2697 Decl *TemplateDeclInstantiator::VisitUsingPackDecl(UsingPackDecl *D) {
2698  SmallVector<NamedDecl*, 8> Expansions;
2699  for (auto *UD : D->expansions()) {
2700  if (auto *NewUD =
2701  SemaRef.FindInstantiatedDecl(D->getLocation(), UD, TemplateArgs))
2702  Expansions.push_back(cast<NamedDecl>(NewUD));
2703  else
2704  return nullptr;
2705  }
2706 
2707  auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
2708  if (isDeclWithinFunction(D))
2709  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
2710  return NewD;
2711 }
2712 
2713 Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
2715  CXXMethodDecl *OldFD = Decl->getSpecialization();
2716  CXXMethodDecl *NewFD =
2717  cast_or_null<CXXMethodDecl>(VisitCXXMethodDecl(OldFD, nullptr, true));
2718  if (!NewFD)
2719  return nullptr;
2720 
2723 
2724  TemplateArgumentListInfo TemplateArgs;
2725  TemplateArgumentListInfo *TemplateArgsPtr = nullptr;
2726  if (Decl->hasExplicitTemplateArgs()) {
2727  TemplateArgs = Decl->templateArgs();
2728  TemplateArgsPtr = &TemplateArgs;
2729  }
2730 
2731  SemaRef.LookupQualifiedName(Previous, SemaRef.CurContext);
2732  if (SemaRef.CheckFunctionTemplateSpecialization(NewFD, TemplateArgsPtr,
2733  Previous)) {
2734  NewFD->setInvalidDecl();
2735  return NewFD;
2736  }
2737 
2738  // Associate the specialization with the pattern.
2739  FunctionDecl *Specialization = cast<FunctionDecl>(Previous.getFoundDecl());
2740  assert(Specialization && "Class scope Specialization is null");
2741  SemaRef.Context.setClassScopeSpecializationPattern(Specialization, OldFD);
2742 
2743  return NewFD;
2744 }
2745 
2746 Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
2747  OMPThreadPrivateDecl *D) {
2749  for (auto *I : D->varlists()) {
2750  Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
2751  assert(isa<DeclRefExpr>(Var) && "threadprivate arg is not a DeclRefExpr");
2752  Vars.push_back(Var);
2753  }
2754 
2755  OMPThreadPrivateDecl *TD =
2756  SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);
2757 
2758  TD->setAccess(AS_public);
2759  Owner->addDecl(TD);
2760 
2761  return TD;
2762 }
2763 
2764 Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
2766  // Instantiate type and check if it is allowed.
2767  QualType SubstReductionType = SemaRef.ActOnOpenMPDeclareReductionType(
2768  D->getLocation(),
2769  ParsedType::make(SemaRef.SubstType(D->getType(), TemplateArgs,
2770  D->getLocation(), DeclarationName())));
2771  if (SubstReductionType.isNull())
2772  return nullptr;
2773  bool IsCorrect = !SubstReductionType.isNull();
2774  // Create instantiated copy.
2775  std::pair<QualType, SourceLocation> ReductionTypes[] = {
2776  std::make_pair(SubstReductionType, D->getLocation())};
2777  auto *PrevDeclInScope = D->getPrevDeclInScope();
2778  if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
2779  PrevDeclInScope = cast<OMPDeclareReductionDecl>(
2780  SemaRef.CurrentInstantiationScope->findInstantiationOf(PrevDeclInScope)
2781  ->get<Decl *>());
2782  }
2783  auto DRD = SemaRef.ActOnOpenMPDeclareReductionDirectiveStart(
2784  /*S=*/nullptr, Owner, D->getDeclName(), ReductionTypes, D->getAccess(),
2785  PrevDeclInScope);
2786  auto *NewDRD = cast<OMPDeclareReductionDecl>(DRD.get().getSingleDecl());
2787  if (isDeclWithinFunction(NewDRD))
2788  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewDRD);
2789  Expr *SubstCombiner = nullptr;
2790  Expr *SubstInitializer = nullptr;
2791  // Combiners instantiation sequence.
2792  if (D->getCombiner()) {
2794  /*S=*/nullptr, NewDRD);
2795  const char *Names[] = {"omp_in", "omp_out"};
2796  for (auto &Name : Names) {
2797  DeclarationName DN(&SemaRef.Context.Idents.get(Name));
2798  auto OldLookup = D->lookup(DN);
2799  auto Lookup = NewDRD->lookup(DN);
2800  if (!OldLookup.empty() && !Lookup.empty()) {
2801  assert(Lookup.size() == 1 && OldLookup.size() == 1);
2802  SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldLookup.front(),
2803  Lookup.front());
2804  }
2805  }
2806  SubstCombiner = SemaRef.SubstExpr(D->getCombiner(), TemplateArgs).get();
2807  SemaRef.ActOnOpenMPDeclareReductionCombinerEnd(NewDRD, SubstCombiner);
2808  // Initializers instantiation sequence.
2809  if (D->getInitializer()) {
2810  VarDecl *OmpPrivParm =
2812  /*S=*/nullptr, NewDRD);
2813  const char *Names[] = {"omp_orig", "omp_priv"};
2814  for (auto &Name : Names) {
2815  DeclarationName DN(&SemaRef.Context.Idents.get(Name));
2816  auto OldLookup = D->lookup(DN);
2817  auto Lookup = NewDRD->lookup(DN);
2818  if (!OldLookup.empty() && !Lookup.empty()) {
2819  assert(Lookup.size() == 1 && OldLookup.size() == 1);
2820  auto *OldVD = cast<VarDecl>(OldLookup.front());
2821  auto *NewVD = cast<VarDecl>(Lookup.front());
2822  SemaRef.InstantiateVariableInitializer(NewVD, OldVD, TemplateArgs);
2823  SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldVD, NewVD);
2824  }
2825  }
2827  SubstInitializer =
2828  SemaRef.SubstExpr(D->getInitializer(), TemplateArgs).get();
2829  } else {
2830  IsCorrect = IsCorrect && OmpPrivParm->hasInit();
2831  }
2833  NewDRD, SubstInitializer, OmpPrivParm);
2834  }
2835  IsCorrect =
2836  IsCorrect && SubstCombiner &&
2837  (!D->getInitializer() ||
2839  SubstInitializer) ||
2841  !SubstInitializer && !SubstInitializer));
2842  } else
2843  IsCorrect = false;
2844 
2845  (void)SemaRef.ActOnOpenMPDeclareReductionDirectiveEnd(/*S=*/nullptr, DRD,
2846  IsCorrect);
2847 
2848  return NewDRD;
2849 }
2850 
2851 Decl *TemplateDeclInstantiator::VisitOMPCapturedExprDecl(
2852  OMPCapturedExprDecl * /*D*/) {
2853  llvm_unreachable("Should not be met in templates");
2854 }
2855 
2857  return VisitFunctionDecl(D, nullptr);
2858 }
2859 
2860 Decl *
2861 TemplateDeclInstantiator::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
2862  return VisitFunctionDecl(D, nullptr);
2863 }
2864 
2866  return VisitCXXMethodDecl(D, nullptr);
2867 }
2868 
2869 Decl *TemplateDeclInstantiator::VisitRecordDecl(RecordDecl *D) {
2870  llvm_unreachable("There are only CXXRecordDecls in C++");
2871 }
2872 
2873 Decl *
2874 TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
2876  // As a MS extension, we permit class-scope explicit specialization
2877  // of member class templates.
2878  ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
2879  assert(ClassTemplate->getDeclContext()->isRecord() &&
2881  "can only instantiate an explicit specialization "
2882  "for a member class template");
2883 
2884  // Lookup the already-instantiated declaration in the instantiation
2885  // of the class template. FIXME: Diagnose or assert if this fails?
2887  = Owner->lookup(ClassTemplate->getDeclName());
2888  if (Found.empty())
2889  return nullptr;
2890  ClassTemplateDecl *InstClassTemplate
2891  = dyn_cast<ClassTemplateDecl>(Found.front());
2892  if (!InstClassTemplate)
2893  return nullptr;
2894 
2895  // Substitute into the template arguments of the class template explicit
2896  // specialization.
2898  castAs<TemplateSpecializationTypeLoc>();
2899  TemplateArgumentListInfo InstTemplateArgs(Loc.getLAngleLoc(),
2900  Loc.getRAngleLoc());
2902  for (unsigned I = 0; I != Loc.getNumArgs(); ++I)
2903  ArgLocs.push_back(Loc.getArgLoc(I));
2904  if (SemaRef.Subst(ArgLocs.data(), ArgLocs.size(),
2905  InstTemplateArgs, TemplateArgs))
2906  return nullptr;
2907 
2908  // Check that the template argument list is well-formed for this
2909  // class template.
2911  if (SemaRef.CheckTemplateArgumentList(InstClassTemplate,
2912  D->getLocation(),
2913  InstTemplateArgs,
2914  false,
2915  Converted))
2916  return nullptr;
2917 
2918  // Figure out where to insert this class template explicit specialization
2919  // in the member template's set of class template explicit specializations.
2920  void *InsertPos = nullptr;
2922  InstClassTemplate->findSpecialization(Converted, InsertPos);
2923 
2924  // Check whether we've already seen a conflicting instantiation of this
2925  // declaration (for instance, if there was a prior implicit instantiation).
2926  bool Ignored;
2927  if (PrevDecl &&
2929  D->getSpecializationKind(),
2930  PrevDecl,
2931  PrevDecl->getSpecializationKind(),
2932  PrevDecl->getPointOfInstantiation(),
2933  Ignored))
2934  return nullptr;
2935 
2936  // If PrevDecl was a definition and D is also a definition, diagnose.
2937  // This happens in cases like:
2938  //
2939  // template<typename T, typename U>
2940  // struct Outer {
2941  // template<typename X> struct Inner;
2942  // template<> struct Inner<T> {};
2943  // template<> struct Inner<U> {};
2944  // };
2945  //
2946  // Outer<int, int> outer; // error: the explicit specializations of Inner
2947  // // have the same signature.
2948  if (PrevDecl && PrevDecl->getDefinition() &&
2950  SemaRef.Diag(D->getLocation(), diag::err_redefinition) << PrevDecl;
2951  SemaRef.Diag(PrevDecl->getDefinition()->getLocation(),
2952  diag::note_previous_definition);
2953  return nullptr;
2954  }
2955 
2956  // Create the class template partial specialization declaration.
2959  D->getTagKind(),
2960  Owner,
2961  D->getLocStart(),
2962  D->getLocation(),
2963  InstClassTemplate,
2964  Converted,
2965  PrevDecl);
2966 
2967  // Add this partial specialization to the set of class template partial
2968  // specializations.
2969  if (!PrevDecl)
2970  InstClassTemplate->AddSpecialization(InstD, InsertPos);
2971 
2972  // Substitute the nested name specifier, if any.
2973  if (SubstQualifier(D, InstD))
2974  return nullptr;
2975 
2976  // Build the canonical type that describes the converted template
2977  // arguments of the class template explicit specialization.
2978  QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
2979  TemplateName(InstClassTemplate), Converted,
2980  SemaRef.Context.getRecordType(InstD));
2981 
2982  // Build the fully-sugared type for this class template
2983  // specialization as the user wrote in the specialization
2984  // itself. This means that we'll pretty-print the type retrieved
2985  // from the specialization's declaration the way that the user
2986  // actually wrote the specialization, rather than formatting the
2987  // name based on the "canonical" representation used to store the
2988  // template arguments in the specialization.
2990  TemplateName(InstClassTemplate), D->getLocation(), InstTemplateArgs,
2991  CanonType);
2992 
2993  InstD->setAccess(D->getAccess());
2996  InstD->setTypeAsWritten(WrittenTy);
2997  InstD->setExternLoc(D->getExternLoc());
2999 
3000  Owner->addDecl(InstD);
3001 
3002  // Instantiate the members of the class-scope explicit specialization eagerly.
3003  // We don't have support for lazy instantiation of an explicit specialization
3004  // yet, and MSVC eagerly instantiates in this case.
3005  if (D->isThisDeclarationADefinition() &&
3006  SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
3008  /*Complain=*/true))
3009  return nullptr;
3010 
3011  return InstD;
3012 }
3013 
3016 
3017  TemplateArgumentListInfo VarTemplateArgsInfo;
3018  VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
3019  assert(VarTemplate &&
3020  "A template specialization without specialized template?");
3021 
3022  // Substitute the current template arguments.
3023  const TemplateArgumentListInfo &TemplateArgsInfo = D->getTemplateArgsInfo();
3024  VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
3025  VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());
3026 
3027  if (SemaRef.Subst(TemplateArgsInfo.getArgumentArray(),
3028  TemplateArgsInfo.size(), VarTemplateArgsInfo, TemplateArgs))
3029  return nullptr;
3030 
3031  // Check that the template argument list is well-formed for this template.
3033  if (SemaRef.CheckTemplateArgumentList(
3034  VarTemplate, VarTemplate->getLocStart(),
3035  const_cast<TemplateArgumentListInfo &>(VarTemplateArgsInfo), false,
3036  Converted))
3037  return nullptr;
3038 
3039  // Find the variable template specialization declaration that
3040  // corresponds to these arguments.
3041  void *InsertPos = nullptr;
3042  if (VarTemplateSpecializationDecl *VarSpec = VarTemplate->findSpecialization(
3043  Converted, InsertPos))
3044  // If we already have a variable template specialization, return it.
3045  return VarSpec;
3046 
3047  return VisitVarTemplateSpecializationDecl(VarTemplate, D, InsertPos,
3048  VarTemplateArgsInfo, Converted);
3049 }
3050 
3052  VarTemplateDecl *VarTemplate, VarDecl *D, void *InsertPos,
3053  const TemplateArgumentListInfo &TemplateArgsInfo,
3054  ArrayRef<TemplateArgument> Converted) {
3055 
3056  // Do substitution on the type of the declaration
3057  TypeSourceInfo *DI =
3058  SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
3059  D->getTypeSpecStartLoc(), D->getDeclName());
3060  if (!DI)
3061  return nullptr;
3062 
3063  if (DI->getType()->isFunctionType()) {
3064  SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
3065  << D->isStaticDataMember() << DI->getType();
3066  return nullptr;
3067  }
3068 
3069  // Build the instantiated declaration
3071  SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
3072  VarTemplate, DI->getType(), DI, D->getStorageClass(), Converted);
3073  Var->setTemplateArgsInfo(TemplateArgsInfo);
3074  if (InsertPos)
3075  VarTemplate->AddSpecialization(Var, InsertPos);
3076 
3077  // Substitute the nested name specifier, if any.
3078  if (SubstQualifier(D, Var))
3079  return nullptr;
3080 
3081  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs,
3082  Owner, StartingScope);
3083 
3084  return Var;
3085 }
3086 
3087 Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
3088  llvm_unreachable("@defs is not supported in Objective-C++");
3089 }
3090 
3091 Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
3092  // FIXME: We need to be able to instantiate FriendTemplateDecls.
3093  unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID(
3095  "cannot instantiate %0 yet");
3096  SemaRef.Diag(D->getLocation(), DiagID)
3097  << D->getDeclKindName();
3098 
3099  return nullptr;
3100 }
3101 
3103  llvm_unreachable("Unexpected decl");
3104 }
3105 
3106 Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
3107  const MultiLevelTemplateArgumentList &TemplateArgs) {
3108  TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
3109  if (D->isInvalidDecl())
3110  return nullptr;
3111 
3112  return Instantiator.Visit(D);
3113 }
3114 
3115 /// \brief Instantiates a nested template parameter list in the current
3116 /// instantiation context.
3117 ///
3118 /// \param L The parameter list to instantiate
3119 ///
3120 /// \returns NULL if there was an error
3123  // Get errors for all the parameters before bailing out.
3124  bool Invalid = false;
3125 
3126  unsigned N = L->size();
3127  typedef SmallVector<NamedDecl *, 8> ParamVector;
3128  ParamVector Params;
3129  Params.reserve(N);
3130  for (auto &P : *L) {
3131  NamedDecl *D = cast_or_null<NamedDecl>(Visit(P));
3132  Params.push_back(D);
3133  Invalid = Invalid || !D || D->isInvalidDecl();
3134  }
3135 
3136  // Clean up if we had an error.
3137  if (Invalid)
3138  return nullptr;
3139 
3140  // Note: we substitute into associated constraints later
3141  Expr *const UninstantiatedRequiresClause = L->getRequiresClause();
3142 
3143  TemplateParameterList *InstL
3144  = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
3145  L->getLAngleLoc(), Params,
3146  L->getRAngleLoc(),
3147  UninstantiatedRequiresClause);
3148  return InstL;
3149 }
3150 
3151 /// \brief Instantiate the declaration of a class template partial
3152 /// specialization.
3153 ///
3154 /// \param ClassTemplate the (instantiated) class template that is partially
3155 // specialized by the instantiation of \p PartialSpec.
3156 ///
3157 /// \param PartialSpec the (uninstantiated) class template partial
3158 /// specialization that we are instantiating.
3159 ///
3160 /// \returns The instantiated partial specialization, if successful; otherwise,
3161 /// NULL to indicate an error.
3164  ClassTemplateDecl *ClassTemplate,
3166  // Create a local instantiation scope for this class template partial
3167  // specialization, which will contain the instantiations of the template
3168  // parameters.
3169  LocalInstantiationScope Scope(SemaRef);
3170 
3171  // Substitute into the template parameters of the class template partial
3172  // specialization.
3173  TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
3174  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
3175  if (!InstParams)
3176  return nullptr;
3177 
3178  // Substitute into the template arguments of the class template partial
3179  // specialization.
3180  const ASTTemplateArgumentListInfo *TemplArgInfo
3181  = PartialSpec->getTemplateArgsAsWritten();
3182  TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
3183  TemplArgInfo->RAngleLoc);
3184  if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
3185  TemplArgInfo->NumTemplateArgs,
3186  InstTemplateArgs, TemplateArgs))
3187  return nullptr;
3188 
3189  // Check that the template argument list is well-formed for this
3190  // class template.
3192  if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
3193  PartialSpec->getLocation(),
3194  InstTemplateArgs,
3195  false,
3196  Converted))
3197  return nullptr;
3198 
3199  // Check these arguments are valid for a template partial specialization.
3201  PartialSpec->getLocation(), ClassTemplate, InstTemplateArgs.size(),
3202  Converted))
3203  return nullptr;
3204 
3205  // Figure out where to insert this class template partial specialization
3206  // in the member template's set of class template partial specializations.
3207  void *InsertPos = nullptr;
3209  = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
3210 
3211  // Build the canonical type that describes the converted template
3212  // arguments of the class template partial specialization.
3213  QualType CanonType
3214  = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
3215  Converted);
3216 
3217  // Build the fully-sugared type for this class template
3218  // specialization as the user wrote in the specialization
3219  // itself. This means that we'll pretty-print the type retrieved
3220  // from the specialization's declaration the way that the user
3221  // actually wrote the specialization, rather than formatting the
3222  // name based on the "canonical" representation used to store the
3223  // template arguments in the specialization.
3224  TypeSourceInfo *WrittenTy
3226  TemplateName(ClassTemplate),
3227  PartialSpec->getLocation(),
3228  InstTemplateArgs,
3229  CanonType);
3230 
3231  if (PrevDecl) {
3232  // We've already seen a partial specialization with the same template
3233  // parameters and template arguments. This can happen, for example, when
3234  // substituting the outer template arguments ends up causing two
3235  // class template partial specializations of a member class template
3236  // to have identical forms, e.g.,
3237  //
3238  // template<typename T, typename U>
3239  // struct Outer {
3240  // template<typename X, typename Y> struct Inner;
3241  // template<typename Y> struct Inner<T, Y>;
3242  // template<typename Y> struct Inner<U, Y>;
3243  // };
3244  //
3245  // Outer<int, int> outer; // error: the partial specializations of Inner
3246  // // have the same signature.
3247  SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
3248  << WrittenTy->getType();
3249  SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
3250  << SemaRef.Context.getTypeDeclType(PrevDecl);
3251  return nullptr;
3252  }
3253 
3254 
3255  // Create the class template partial specialization declaration.
3258  PartialSpec->getTagKind(),
3259  Owner,
3260  PartialSpec->getLocStart(),
3261  PartialSpec->getLocation(),
3262  InstParams,
3263  ClassTemplate,
3264  Converted,
3265  InstTemplateArgs,
3266  CanonType,
3267  nullptr);
3268  // Substitute the nested name specifier, if any.
3269  if (SubstQualifier(PartialSpec, InstPartialSpec))
3270  return nullptr;
3271 
3272  InstPartialSpec->setInstantiatedFromMember(PartialSpec);
3273  InstPartialSpec->setTypeAsWritten(WrittenTy);
3274 
3275  // Check the completed partial specialization.
3276  SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
3277 
3278  // Add this partial specialization to the set of class template partial
3279  // specializations.
3280  ClassTemplate->AddPartialSpecialization(InstPartialSpec,
3281  /*InsertPos=*/nullptr);
3282  return InstPartialSpec;
3283 }
3284 
3285 /// \brief Instantiate the declaration of a variable template partial
3286 /// specialization.
3287 ///
3288 /// \param VarTemplate the (instantiated) variable template that is partially
3289 /// specialized by the instantiation of \p PartialSpec.
3290 ///
3291 /// \param PartialSpec the (uninstantiated) variable template partial
3292 /// specialization that we are instantiating.
3293 ///
3294 /// \returns The instantiated partial specialization, if successful; otherwise,
3295 /// NULL to indicate an error.
3298  VarTemplateDecl *VarTemplate,
3299  VarTemplatePartialSpecializationDecl *PartialSpec) {
3300  // Create a local instantiation scope for this variable template partial
3301  // specialization, which will contain the instantiations of the template
3302  // parameters.
3303  LocalInstantiationScope Scope(SemaRef);
3304 
3305  // Substitute into the template parameters of the variable template partial
3306  // specialization.
3307  TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
3308  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
3309  if (!InstParams)
3310  return nullptr;
3311 
3312  // Substitute into the template arguments of the variable template partial
3313  // specialization.
3314  const ASTTemplateArgumentListInfo *TemplArgInfo
3315  = PartialSpec->getTemplateArgsAsWritten();
3316  TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
3317  TemplArgInfo->RAngleLoc);
3318  if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
3319  TemplArgInfo->NumTemplateArgs,
3320  InstTemplateArgs, TemplateArgs))
3321  return nullptr;
3322 
3323  // Check that the template argument list is well-formed for this
3324  // class template.
3326  if (SemaRef.CheckTemplateArgumentList(VarTemplate, PartialSpec->getLocation(),
3327  InstTemplateArgs, false, Converted))
3328  return nullptr;
3329 
3330  // Check these arguments are valid for a template partial specialization.
3332  PartialSpec->getLocation(), VarTemplate, InstTemplateArgs.size(),
3333  Converted))
3334  return nullptr;
3335 
3336  // Figure out where to insert this variable template partial specialization
3337  // in the member template's set of variable template partial specializations.
3338  void *InsertPos = nullptr;
3339  VarTemplateSpecializationDecl *PrevDecl =
3340  VarTemplate->findPartialSpecialization(Converted, InsertPos);
3341 
3342  // Build the canonical type that describes the converted template
3343  // arguments of the variable template partial specialization.
3344  QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
3345  TemplateName(VarTemplate), Converted);
3346 
3347  // Build the fully-sugared type for this variable template
3348  // specialization as the user wrote in the specialization
3349  // itself. This means that we'll pretty-print the type retrieved
3350  // from the specialization's declaration the way that the user
3351  // actually wrote the specialization, rather than formatting the
3352  // name based on the "canonical" representation used to store the
3353  // template arguments in the specialization.
3355  TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
3356  CanonType);
3357 
3358  if (PrevDecl) {
3359  // We've already seen a partial specialization with the same template
3360  // parameters and template arguments. This can happen, for example, when
3361  // substituting the outer template arguments ends up causing two
3362  // variable template partial specializations of a member variable template
3363  // to have identical forms, e.g.,
3364  //
3365  // template<typename T, typename U>
3366  // struct Outer {
3367  // template<typename X, typename Y> pair<X,Y> p;
3368  // template<typename Y> pair<T, Y> p;
3369  // template<typename Y> pair<U, Y> p;
3370  // };
3371  //
3372  // Outer<int, int> outer; // error: the partial specializations of Inner
3373  // // have the same signature.
3374  SemaRef.Diag(PartialSpec->getLocation(),
3375  diag::err_var_partial_spec_redeclared)
3376  << WrittenTy->getType();
3377  SemaRef.Diag(PrevDecl->getLocation(),
3378  diag::note_var_prev_partial_spec_here);
3379  return nullptr;
3380  }
3381 
3382  // Do substitution on the type of the declaration
3383  TypeSourceInfo *DI = SemaRef.SubstType(
3384  PartialSpec->getTypeSourceInfo(), TemplateArgs,
3385  PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName());
3386  if (!DI)
3387  return nullptr;
3388 
3389  if (DI->getType()->isFunctionType()) {
3390  SemaRef.Diag(PartialSpec->getLocation(),
3391  diag::err_variable_instantiates_to_function)
3392  << PartialSpec->isStaticDataMember() << DI->getType();
3393  return nullptr;
3394  }
3395 
3396  // Create the variable template partial specialization declaration.
3397  VarTemplatePartialSpecializationDecl *InstPartialSpec =
3399  SemaRef.Context, Owner, PartialSpec->getInnerLocStart(),
3400  PartialSpec->getLocation(), InstParams, VarTemplate, DI->getType(),
3401  DI, PartialSpec->getStorageClass(), Converted, InstTemplateArgs);
3402 
3403  // Substitute the nested name specifier, if any.
3404  if (SubstQualifier(PartialSpec, InstPartialSpec))
3405  return nullptr;
3406 
3407  InstPartialSpec->setInstantiatedFromMember(PartialSpec);
3408  InstPartialSpec->setTypeAsWritten(WrittenTy);
3409 
3410  // Check the completed partial specialization.
3411  SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
3412 
3413  // Add this partial specialization to the set of variable template partial
3414  // specializations. The instantiation of the initializer is not necessary.
3415  VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/nullptr);
3416 
3417  SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs,
3418  LateAttrs, Owner, StartingScope);
3419 
3420  return InstPartialSpec;
3421 }
3422 
3426  TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
3427  assert(OldTInfo && "substituting function without type source info");
3428  assert(Params.empty() && "parameter vector is non-empty at start");
3429 
3430  CXXRecordDecl *ThisContext = nullptr;
3431  unsigned ThisTypeQuals = 0;
3432  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
3433  ThisContext = cast<CXXRecordDecl>(Owner);
3434  ThisTypeQuals = Method->getTypeQualifiers();
3435  }
3436 
3437  TypeSourceInfo *NewTInfo
3438  = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
3439  D->getTypeSpecStartLoc(),
3440  D->getDeclName(),
3441  ThisContext, ThisTypeQuals);
3442  if (!NewTInfo)
3443  return nullptr;
3444 
3445  TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
3446  if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
3447  if (NewTInfo != OldTInfo) {
3448  // Get parameters from the new type info.
3449  TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
3450  FunctionProtoTypeLoc NewProtoLoc = NewTL.castAs<FunctionProtoTypeLoc>();
3451  unsigned NewIdx = 0;
3452  for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
3453  OldIdx != NumOldParams; ++OldIdx) {
3454  ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
3456 
3457  Optional<unsigned> NumArgumentsInExpansion;
3458  if (OldParam->isParameterPack())
3459  NumArgumentsInExpansion =
3460  SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
3461  TemplateArgs);
3462  if (!NumArgumentsInExpansion) {
3463  // Simple case: normal parameter, or a parameter pack that's
3464  // instantiated to a (still-dependent) parameter pack.
3465  ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
3466  Params.push_back(NewParam);
3467  Scope->InstantiatedLocal(OldParam, NewParam);
3468  } else {
3469  // Parameter pack expansion: make the instantiation an argument pack.
3470  Scope->MakeInstantiatedLocalArgPack(OldParam);
3471  for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
3472  ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
3473  Params.push_back(NewParam);
3474  Scope->InstantiatedLocalPackArg(OldParam, NewParam);
3475  }
3476  }
3477  }
3478  } else {
3479  // The function type itself was not dependent and therefore no
3480  // substitution occurred. However, we still need to instantiate
3481  // the function parameters themselves.
3482  const FunctionProtoType *OldProto =
3483  cast<FunctionProtoType>(OldProtoLoc.getType());
3484  for (unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
3485  ++i) {
3486  ParmVarDecl *OldParam = OldProtoLoc.getParam(i);
3487  if (!OldParam) {
3488  Params.push_back(SemaRef.BuildParmVarDeclForTypedef(
3489  D, D->getLocation(), OldProto->getParamType(i)));
3490  continue;
3491  }
3492 
3493  ParmVarDecl *Parm =
3494  cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
3495  if (!Parm)
3496  return nullptr;
3497  Params.push_back(Parm);
3498  }
3499  }
3500  } else {
3501  // If the type of this function, after ignoring parentheses, is not
3502  // *directly* a function type, then we're instantiating a function that
3503  // was declared via a typedef or with attributes, e.g.,
3504  //
3505  // typedef int functype(int, int);
3506  // functype func;
3507  // int __cdecl meth(int, int);
3508  //
3509  // In this case, we'll just go instantiate the ParmVarDecls that we
3510  // synthesized in the method declaration.
3511  SmallVector<QualType, 4> ParamTypes;
3512  Sema::ExtParameterInfoBuilder ExtParamInfos;
3513  if (SemaRef.SubstParmTypes(D->getLocation(), D->parameters(), nullptr,
3514  TemplateArgs, ParamTypes, &Params,
3515  ExtParamInfos))
3516  return nullptr;
3517  }
3518 
3519  return NewTInfo;
3520 }
3521 
3522 /// Introduce the instantiated function parameters into the local
3523 /// instantiation scope, and set the parameter names to those used
3524 /// in the template.
3526  const FunctionDecl *PatternDecl,
3528  const MultiLevelTemplateArgumentList &TemplateArgs) {
3529  unsigned FParamIdx = 0;
3530  for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
3531  const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
3532  if (!PatternParam->isParameterPack()) {
3533  // Simple case: not a parameter pack.
3534  assert(FParamIdx < Function->getNumParams());
3535  ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
3536  FunctionParam->setDeclName(PatternParam->getDeclName());
3537  // If the parameter's type is not dependent, update it to match the type
3538  // in the pattern. They can differ in top-level cv-qualifiers, and we want
3539  // the pattern's type here. If the type is dependent, they can't differ,
3540  // per core issue 1668. Substitute into the type from the pattern, in case
3541  // it's instantiation-dependent.
3542  // FIXME: Updating the type to work around this is at best fragile.
3543  if (!PatternDecl->getType()->isDependentType()) {
3544  QualType T = S.SubstType(PatternParam->getType(), TemplateArgs,
3545  FunctionParam->getLocation(),
3546  FunctionParam->getDeclName());
3547  if (T.isNull())
3548  return true;
3549  FunctionParam->setType(T);
3550  }
3551 
3552  Scope.InstantiatedLocal(PatternParam, FunctionParam);
3553  ++FParamIdx;
3554  continue;
3555  }
3556 
3557  // Expand the parameter pack.
3558  Scope.MakeInstantiatedLocalArgPack(PatternParam);
3559  Optional<unsigned> NumArgumentsInExpansion
3560  = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
3561  assert(NumArgumentsInExpansion &&
3562  "should only be called when all template arguments are known");
3563  QualType PatternType =
3564  PatternParam->getType()->castAs<PackExpansionType>()->getPattern();
3565  for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
3566  ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
3567  FunctionParam->setDeclName(PatternParam->getDeclName());
3568  if (!PatternDecl->getType()->isDependentType()) {
3569  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, Arg);
3570  QualType T = S.SubstType(PatternType, TemplateArgs,
3571  FunctionParam->getLocation(),
3572  FunctionParam->getDeclName());
3573  if (T.isNull())
3574  return true;
3575  FunctionParam->setType(T);
3576  }
3577 
3578  Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
3579  ++FParamIdx;
3580  }
3581  }
3582 
3583  return false;
3584 }
3585 
3587  FunctionDecl *Decl) {
3588  const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>();
3589  if (Proto->getExceptionSpecType() != EST_Uninstantiated)
3590  return;
3591 
3592  InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl,
3594  if (Inst.isInvalid()) {
3595  // We hit the instantiation depth limit. Clear the exception specification
3596  // so that our callers don't have to cope with EST_Uninstantiated.
3597  UpdateExceptionSpec(Decl, EST_None);
3598  return;
3599  }
3600  if (Inst.isAlreadyInstantiating()) {
3601  // This exception specification indirectly depends on itself. Reject.
3602  // FIXME: Corresponding rule in the standard?
3603  Diag(PointOfInstantiation, diag::err_exception_spec_cycle) << Decl;
3604  UpdateExceptionSpec(Decl, EST_None);
3605  return;
3606  }
3607 
3608  // Enter the scope of this instantiation. We don't use
3609  // PushDeclContext because we don't have a scope.
3610  Sema::ContextRAII savedContext(*this, Decl);
3612 
3613  MultiLevelTemplateArgumentList TemplateArgs =
3614  getTemplateInstantiationArgs(Decl, nullptr, /*RelativeToPrimary*/true);
3615 
3616  FunctionDecl *Template = Proto->getExceptionSpecTemplate();
3617  if (addInstantiatedParametersToScope(*this, Decl, Template, Scope,
3618  TemplateArgs)) {
3619  UpdateExceptionSpec(Decl, EST_None);
3620  return;
3621  }
3622 
3623  SubstExceptionSpec(Decl, Template->getType()->castAs<FunctionProtoType>(),
3624  TemplateArgs);
3625 }
3626 
3627 /// \brief Initializes the common fields of an instantiation function
3628 /// declaration (New) from the corresponding fields of its template (Tmpl).
3629 ///
3630 /// \returns true if there was an error
3631 bool
3633  FunctionDecl *Tmpl) {
3634  if (Tmpl->isDeleted())
3635  New->setDeletedAsWritten();
3636 
3637  New->setImplicit(Tmpl->isImplicit());
3638 
3639  // Forward the mangling number from the template to the instantiated decl.
3640  SemaRef.Context.setManglingNumber(New,
3641  SemaRef.Context.getManglingNumber(Tmpl));
3642 
3643  // If we are performing substituting explicitly-specified template arguments
3644  // or deduced template arguments into a function template and we reach this
3645  // point, we are now past the point where SFINAE applies and have committed
3646  // to keeping the new function template specialization. We therefore
3647  // convert the active template instantiation for the function template
3648  // into a template instantiation for this specific function template
3649  // specialization, which is not a SFINAE context, so that we diagnose any
3650  // further errors in the declaration itself.
3651  typedef Sema::CodeSynthesisContext ActiveInstType;
3652  ActiveInstType &ActiveInst = SemaRef.CodeSynthesisContexts.back();
3653  if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
3654  ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
3655  if (FunctionTemplateDecl *FunTmpl
3656  = dyn_cast<FunctionTemplateDecl>(ActiveInst.Entity)) {
3657  assert(FunTmpl->getTemplatedDecl() == Tmpl &&
3658  "Deduction from the wrong function template?");
3659  (void) FunTmpl;
3660  ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
3661  ActiveInst.Entity = New;
3662  }
3663  }
3664 
3665  const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
3666  assert(Proto && "Function template without prototype?");
3667 
3668  if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
3670 
3671  // DR1330: In C++11, defer instantiation of a non-trivial
3672  // exception specification.
3673  // DR1484: Local classes and their members are instantiated along with the
3674  // containing function.
3675  if (SemaRef.getLangOpts().CPlusPlus11 &&
3676  EPI.ExceptionSpec.Type != EST_None &&
3680  FunctionDecl *ExceptionSpecTemplate = Tmpl;
3682  ExceptionSpecTemplate = EPI.ExceptionSpec.SourceTemplate;
3684  if (EPI.ExceptionSpec.Type == EST_Unevaluated)
3685  NewEST = EST_Unevaluated;
3686 
3687  // Mark the function has having an uninstantiated exception specification.
3688  const FunctionProtoType *NewProto
3689  = New->getType()->getAs<FunctionProtoType>();
3690  assert(NewProto && "Template instantiation without function prototype?");
3691  EPI = NewProto->getExtProtoInfo();
3692  EPI.ExceptionSpec.Type = NewEST;
3693  EPI.ExceptionSpec.SourceDecl = New;
3694  EPI.ExceptionSpec.SourceTemplate = ExceptionSpecTemplate;
3695  New->setType(SemaRef.Context.getFunctionType(
3696  NewProto->getReturnType(), NewProto->getParamTypes(), EPI));
3697  } else {
3698  Sema::ContextRAII SwitchContext(SemaRef, New);
3699  SemaRef.SubstExceptionSpec(New, Proto, TemplateArgs);
3700  }
3701  }
3702 
3703  // Get the definition. Leaves the variable unchanged if undefined.
3704  const FunctionDecl *Definition = Tmpl;
3705  Tmpl->isDefined(Definition);
3706 
3707  SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
3708  LateAttrs, StartingScope);
3709 
3710  return false;
3711 }
3712 
3713 /// \brief Initializes common fields of an instantiated method
3714 /// declaration (New) from the corresponding fields of its template
3715 /// (Tmpl).
3716 ///
3717 /// \returns true if there was an error
3718 bool
3720  CXXMethodDecl *Tmpl) {
3721  if (InitFunctionInstantiation(New, Tmpl))
3722  return true;
3723 
3724  New->setAccess(Tmpl->getAccess());
3725  if (Tmpl->isVirtualAsWritten())
3726  New->setVirtualAsWritten(true);
3727 
3728  // FIXME: New needs a pointer to Tmpl
3729  return false;
3730 }
3731 
3732 /// Instantiate (or find existing instantiation of) a function template with a
3733 /// given set of template arguments.
3734 ///
3735 /// Usually this should not be used, and template argument deduction should be
3736 /// used in its place.
3737 FunctionDecl *
3739  const TemplateArgumentList *Args,
3740  SourceLocation Loc) {
3741  FunctionDecl *FD = FTD->getTemplatedDecl();
3742 
3743  sema::TemplateDeductionInfo Info(Loc);
3744  InstantiatingTemplate Inst(
3745  *this, Loc, FTD, Args->asArray(),
3746  CodeSynthesisContext::ExplicitTemplateArgumentSubstitution, Info);
3747  if (Inst.isInvalid())
3748  return nullptr;
3749 
3750  ContextRAII SavedContext(*this, FD);
3751  MultiLevelTemplateArgumentList MArgs(*Args);
3752 
3753  return cast_or_null<FunctionDecl>(SubstDecl(FD, FD->getParent(), MArgs));
3754 }
3755 
3756 /// In the MS ABI, we need to instantiate default arguments of dllexported
3757 /// default constructors along with the constructor definition. This allows IR
3758 /// gen to emit a constructor closure which calls the default constructor with
3759 /// its default arguments.
3761  CXXConstructorDecl *Ctor) {
3762  assert(S.Context.getTargetInfo().getCXXABI().isMicrosoft() &&
3763  Ctor->isDefaultConstructor());
3764  unsigned NumParams = Ctor->getNumParams();
3765  if (NumParams == 0)
3766  return;
3767  DLLExportAttr *Attr = Ctor->getAttr<DLLExportAttr>();
3768  if (!Attr)
3769  return;
3770  for (unsigned I = 0; I != NumParams; ++I) {
3771  (void)S.CheckCXXDefaultArgExpr(Attr->getLocation(), Ctor,
3772  Ctor->getParamDecl(I));
3774  }
3775 }
3776 
3777 /// \brief Instantiate the definition of the given function from its
3778 /// template.
3779 ///
3780 /// \param PointOfInstantiation the point at which the instantiation was
3781 /// required. Note that this is not precisely a "point of instantiation"
3782 /// for the function, but it's close.
3783 ///
3784 /// \param Function the already-instantiated declaration of a
3785 /// function template specialization or member function of a class template
3786 /// specialization.
3787 ///
3788 /// \param Recursive if true, recursively instantiates any functions that
3789 /// are required by this instantiation.
3790 ///
3791 /// \param DefinitionRequired if true, then we are performing an explicit
3792 /// instantiation where the body of the function is required. Complain if
3793 /// there is no such body.
3795  FunctionDecl *Function,
3796  bool Recursive,
3797  bool DefinitionRequired,
3798  bool AtEndOfTU) {
3799  if (Function->isInvalidDecl() || Function->isDefined() ||
3800  isa<CXXDeductionGuideDecl>(Function))
3801  return;
3802 
3803  // Never instantiate an explicit specialization except if it is a class scope
3804  // explicit specialization.
3806  if (TSK == TSK_ExplicitSpecialization &&
3808  return;
3809 
3810  // Find the function body that we'll be substituting.
3811  const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
3812  assert(PatternDecl && "instantiating a non-template");
3813 
3814  const FunctionDecl *PatternDef = PatternDecl->getDefinition();
3815  Stmt *Pattern = nullptr;
3816  if (PatternDef) {
3817  Pattern = PatternDef->getBody(PatternDef);
3818  PatternDecl = PatternDef;
3819  if (PatternDef->willHaveBody())
3820  PatternDef = nullptr;
3821  }
3822 
3823  // FIXME: We need to track the instantiation stack in order to know which
3824  // definitions should be visible within this instantiation.
3825  if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Function,
3827  PatternDecl, PatternDef, TSK,
3828  /*Complain*/DefinitionRequired)) {
3829  if (DefinitionRequired)
3830  Function->setInvalidDecl();
3831  else if (TSK == TSK_ExplicitInstantiationDefinition) {
3832  // Try again at the end of the translation unit (at which point a
3833  // definition will be required).
3834  assert(!Recursive);
3835  Function->setInstantiationIsPending(true);
3836  PendingInstantiations.push_back(
3837  std::make_pair(Function, PointOfInstantiation));
3838  } else if (TSK == TSK_ImplicitInstantiation) {
3839  if (AtEndOfTU && !getDiagnostics().hasErrorOccurred() &&
3840  !getSourceManager().isInSystemHeader(PatternDecl->getLocStart())) {
3841  Diag(PointOfInstantiation, diag::warn_func_template_missing)
3842  << Function;
3843  Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
3844  if (getLangOpts().CPlusPlus11)
3845  Diag(PointOfInstantiation, diag::note_inst_declaration_hint)
3846  << Function;
3847  }
3848  }
3849 
3850  return;
3851  }
3852 
3853  // Postpone late parsed template instantiations.
3854  if (PatternDecl->isLateTemplateParsed() &&
3855  !LateTemplateParser) {
3856  Function->setInstantiationIsPending(true);
3857  PendingInstantiations.push_back(
3858  std::make_pair(Function, PointOfInstantiation));
3859  return;
3860  }
3861 
3862  // If we're performing recursive template instantiation, create our own
3863  // queue of pending implicit instantiations that we will instantiate later,
3864  // while we're still within our own instantiation context.
3865  // This has to happen before LateTemplateParser below is called, so that
3866  // it marks vtables used in late parsed templates as used.
3867  GlobalEagerInstantiationScope GlobalInstantiations(*this,
3868  /*Enabled=*/Recursive);
3869  LocalEagerInstantiationScope LocalInstantiations(*this);
3870 
3871  // Call the LateTemplateParser callback if there is a need to late parse
3872  // a templated function definition.
3873  if (!Pattern && PatternDecl->isLateTemplateParsed() &&
3874  LateTemplateParser) {
3875  // FIXME: Optimize to allow individual templates to be deserialized.
3876  if (PatternDecl->isFromASTFile())
3877  ExternalSource->ReadLateParsedTemplates(LateParsedTemplateMap);
3878 
3879  auto LPTIter = LateParsedTemplateMap.find(PatternDecl);
3880  assert(LPTIter != LateParsedTemplateMap.end() &&
3881  "missing LateParsedTemplate");
3882  LateTemplateParser(OpaqueParser, *LPTIter->second);
3883  Pattern = PatternDecl->getBody(PatternDecl);
3884  }
3885 
3886  // Note, we should never try to instantiate a deleted function template.
3887  assert((Pattern || PatternDecl->isDefaulted() ||
3888  PatternDecl->hasSkippedBody()) &&
3889  "unexpected kind of function template definition");
3890 
3891  // C++1y [temp.explicit]p10:
3892  // Except for inline functions, declarations with types deduced from their
3893  // initializer or return value, and class template specializations, other
3894  // explicit instantiation declarations have the effect of suppressing the
3895  // implicit instantiation of the entity to which they refer.
3897  !PatternDecl->isInlined() &&
3898  !PatternDecl->getReturnType()->getContainedAutoType())
3899  return;
3900 
3901  if (PatternDecl->isInlined()) {
3902  // Function, and all later redeclarations of it (from imported modules,
3903  // for instance), are now implicitly inline.
3904  for (auto *D = Function->getMostRecentDecl(); /**/;
3905  D = D->getPreviousDecl()) {
3906  D->setImplicitlyInline();
3907  if (D == Function)
3908  break;
3909  }
3910  }
3911 
3912  InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
3913  if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
3914  return;
3915  PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(),
3916  "instantiating function definition");
3917 
3918  // The instantiation is visible here, even if it was first declared in an
3919  // unimported module.
3920  Function->setVisibleDespiteOwningModule();
3921 
3922  // Copy the inner loc start from the pattern.
3923  Function->setInnerLocStart(PatternDecl->getInnerLocStart());
3924 
3927 
3928  // Introduce a new scope where local variable instantiations will be
3929  // recorded, unless we're actually a member function within a local
3930  // class, in which case we need to merge our results with the parent
3931  // scope (of the enclosing function).
3932  bool MergeWithParentScope = false;
3933  if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
3934  MergeWithParentScope = Rec->isLocalClass();
3935 
3936  LocalInstantiationScope Scope(*this, MergeWithParentScope);
3937 
3938  if (PatternDecl->isDefaulted())
3939  SetDeclDefaulted(Function, PatternDecl->getLocation());
3940  else {
3941  MultiLevelTemplateArgumentList TemplateArgs =
3942  getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl);
3943 
3944  // Substitute into the qualifier; we can get a substitution failure here
3945  // through evil use of alias templates.
3946  // FIXME: Is CurContext correct for this? Should we go to the (instantiation
3947  // of the) lexical context of the pattern?
3948  SubstQualifier(*this, PatternDecl, Function, TemplateArgs);
3949 
3950  ActOnStartOfFunctionDef(nullptr, Function);
3951 
3952  // Enter the scope of this instantiation. We don't use
3953  // PushDeclContext because we don't have a scope.
3954  Sema::ContextRAII savedContext(*this, Function);
3955 
3956  if (addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope,
3957  TemplateArgs))
3958  return;
3959 
3960  if (PatternDecl->hasSkippedBody()) {
3961  ActOnSkippedFunctionBody(Function);
3962  } else {
3963  if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Function)) {
3964  // If this is a constructor, instantiate the member initializers.
3965  InstantiateMemInitializers(Ctor, cast<CXXConstructorDecl>(PatternDecl),
3966  TemplateArgs);
3967 
3968  // If this is an MS ABI dllexport default constructor, instantiate any
3969  // default arguments.
3970  if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
3971  Ctor->isDefaultConstructor()) {
3972  InstantiateDefaultCtorDefaultArgs(*this, Ctor);
3973  }
3974  }
3975 
3976  // Instantiate the function body.
3977  StmtResult Body = SubstStmt(Pattern, TemplateArgs);
3978 
3979  if (Body.isInvalid())
3980  Function->setInvalidDecl();
3981 
3982  // FIXME: finishing the function body while in an expression evaluation
3983  // context seems wrong. Investigate more.
3984  ActOnFinishFunctionBody(Function, Body.get(),
3985  /*IsInstantiation=*/true);
3986  }
3987 
3988  PerformDependentDiagnostics(PatternDecl, TemplateArgs);
3989 
3990  if (auto *Listener = getASTMutationListener())
3991  Listener->FunctionDefinitionInstantiated(Function);
3992 
3993  savedContext.pop();
3994  }
3995 
3996  DeclGroupRef DG(Function);
3997  Consumer.HandleTopLevelDecl(DG);
3998 
3999  // This class may have local implicit instantiations that need to be
4000  // instantiation within this scope.
4001  LocalInstantiations.perform();
4002  Scope.Exit();
4003  GlobalInstantiations.perform();
4004 }
4005 
4007  VarTemplateDecl *VarTemplate, VarDecl *FromVar,
4008  const TemplateArgumentList &TemplateArgList,
4009  const TemplateArgumentListInfo &TemplateArgsInfo,
4011  SourceLocation PointOfInstantiation, void *InsertPos,
4012  LateInstantiatedAttrVec *LateAttrs,
4013  LocalInstantiationScope *StartingScope) {
4014  if (FromVar->isInvalidDecl())
4015  return nullptr;
4016 
4017  InstantiatingTemplate Inst(*this, PointOfInstantiation, FromVar);
4018  if (Inst.isInvalid())
4019  return nullptr;
4020 
4021  MultiLevelTemplateArgumentList TemplateArgLists;
4022  TemplateArgLists.addOuterTemplateArguments(&TemplateArgList);
4023 
4024  // Instantiate the first declaration of the variable template: for a partial
4025  // specialization of a static data member template, the first declaration may
4026  // or may not be the declaration in the class; if it's in the class, we want
4027  // to instantiate a member in the class (a declaration), and if it's outside,
4028  // we want to instantiate a definition.
4029  //
4030  // If we're instantiating an explicitly-specialized member template or member
4031  // partial specialization, don't do this. The member specialization completely
4032  // replaces the original declaration in this case.
4033  bool IsMemberSpec = false;
4034  if (VarTemplatePartialSpecializationDecl *PartialSpec =
4035  dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar))
4036  IsMemberSpec = PartialSpec->isMemberSpecialization();
4037  else if (VarTemplateDecl *FromTemplate = FromVar->getDescribedVarTemplate())
4038  IsMemberSpec = FromTemplate->isMemberSpecialization();
4039  if (!IsMemberSpec)
4040  FromVar = FromVar->getFirstDecl();
4041 
4042  MultiLevelTemplateArgumentList MultiLevelList(TemplateArgList);
4043  TemplateDeclInstantiator Instantiator(*this, FromVar->getDeclContext(),
4044  MultiLevelList);
4045 
4046  // TODO: Set LateAttrs and StartingScope ...
4047 
4048  return cast_or_null<VarTemplateSpecializationDecl>(
4049  Instantiator.VisitVarTemplateSpecializationDecl(
4050  VarTemplate, FromVar, InsertPos, TemplateArgsInfo, Converted));
4051 }
4052 
4053 /// \brief Instantiates a variable template specialization by completing it
4054 /// with appropriate type information and initializer.
4056  VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
4057  const MultiLevelTemplateArgumentList &TemplateArgs) {
4058  assert(PatternDecl->isThisDeclarationADefinition() &&
4059  "don't have a definition to instantiate from");
4060 
4061  // Do substitution on the type of the declaration
4062  TypeSourceInfo *DI =
4063  SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
4064  PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
4065  if (!DI)
4066  return nullptr;
4067 
4068  // Update the type of this variable template specialization.
4069  VarSpec->setType(DI->getType());
4070 
4071  // Convert the declaration into a definition now.
4072  VarSpec->setCompleteDefinition();
4073 
4074  // Instantiate the initializer.
4075  InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs);
4076 
4077  return VarSpec;
4078 }
4079 
4080 /// BuildVariableInstantiation - Used after a new variable has been created.
4081 /// Sets basic variable data and decides whether to postpone the
4082 /// variable instantiation.
4084  VarDecl *NewVar, VarDecl *OldVar,
4085  const MultiLevelTemplateArgumentList &TemplateArgs,
4086  LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner,
4087  LocalInstantiationScope *StartingScope,
4088  bool InstantiatingVarTemplate) {
4089 
4090  // If we are instantiating a local extern declaration, the
4091  // instantiation belongs lexically to the containing function.
4092  // If we are instantiating a static data member defined
4093  // out-of-line, the instantiation will have the same lexical
4094  // context (which will be a namespace scope) as the template.
4095  if (OldVar->isLocalExternDecl()) {
4096  NewVar->setLocalExternDecl();
4097  NewVar->setLexicalDeclContext(Owner);
4098  } else if (OldVar->isOutOfLine())
4099  NewVar->setLexicalDeclContext(OldVar->getLexicalDeclContext());
4100  NewVar->setTSCSpec(OldVar->getTSCSpec());
4101  NewVar->setInitStyle(OldVar->getInitStyle());
4102  NewVar->setCXXForRangeDecl(OldVar->isCXXForRangeDecl());
4103  NewVar->setConstexpr(OldVar->isConstexpr());
4104  NewVar->setInitCapture(OldVar->isInitCapture());
4106  OldVar->isPreviousDeclInSameBlockScope());
4107  NewVar->setAccess(OldVar->getAccess());
4108 
4109  if (!OldVar->isStaticDataMember()) {
4110  if (OldVar->isUsed(false))
4111  NewVar->setIsUsed();
4112  NewVar->setReferenced(OldVar->isReferenced());
4113  }
4114 
4115  InstantiateAttrs(TemplateArgs, OldVar, NewVar, LateAttrs, StartingScope);
4116 
4118  *this, NewVar->getDeclName(), NewVar->getLocation(),
4122  : forRedeclarationInCurContext());
4123 
4124  if (NewVar->isLocalExternDecl() && OldVar->getPreviousDecl() &&
4126  OldVar->getPreviousDecl()->getDeclContext()==OldVar->getDeclContext())) {
4127  // We have a previous declaration. Use that one, so we merge with the
4128  // right type.
4129  if (NamedDecl *NewPrev = FindInstantiatedDecl(
4130  NewVar->getLocation(), OldVar->getPreviousDecl(), TemplateArgs))
4131  Previous.addDecl(NewPrev);
4132  } else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
4133  OldVar->hasLinkage())
4134  LookupQualifiedName(Previous, NewVar->getDeclContext(), false);
4135  CheckVariableDeclaration(NewVar, Previous);
4136 
4137  if (!InstantiatingVarTemplate) {
4138  NewVar->getLexicalDeclContext()->addHiddenDecl(NewVar);
4139  if (!NewVar->isLocalExternDecl() || !NewVar->getPreviousDecl())
4140  NewVar->getDeclContext()->makeDeclVisibleInContext(NewVar);
4141  }
4142 
4143  if (!OldVar->isOutOfLine()) {
4144  if (NewVar->getDeclContext()->isFunctionOrMethod())
4145  CurrentInstantiationScope->InstantiatedLocal(OldVar, NewVar);
4146  }
4147 
4148  // Link instantiations of static data members back to the template from
4149  // which they were instantiated.
4150  if (NewVar->isStaticDataMember() && !InstantiatingVarTemplate)
4151  NewVar->setInstantiationOfStaticDataMember(OldVar,
4153 
4154  // Forward the mangling number from the template to the instantiated decl.
4155  Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
4156  Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));
4157 
4158  // Delay instantiation of the initializer for variable templates or inline
4159  // static data members until a definition of the variable is needed. We need
4160  // it right away if the type contains 'auto'.
4161  if ((!isa<VarTemplateSpecializationDecl>(NewVar) &&
4162  !InstantiatingVarTemplate &&
4163  !(OldVar->isInline() && OldVar->isThisDeclarationADefinition() &&
4164  !NewVar->isThisDeclarationADefinition())) ||
4165  NewVar->getType()->isUndeducedType())
4166  InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
4167 
4168  // Diagnose unused local variables with dependent types, where the diagnostic
4169  // will have been deferred.
4170  if (!NewVar->isInvalidDecl() &&
4171  NewVar->getDeclContext()->isFunctionOrMethod() &&
4172  OldVar->getType()->isDependentType())
4173  DiagnoseUnusedDecl(NewVar);
4174 }
4175 
4176 /// \brief Instantiate the initializer of a variable.
4178  VarDecl *Var, VarDecl *OldVar,
4179  const MultiLevelTemplateArgumentList &TemplateArgs) {
4180  if (ASTMutationListener *L = getASTContext().getASTMutationListener())
4181  L->VariableDefinitionInstantiated(Var);
4182 
4183  // We propagate the 'inline' flag with the initializer, because it
4184  // would otherwise imply that the variable is a definition for a
4185  // non-static data member.
4186  if (OldVar->isInlineSpecified())
4187  Var->setInlineSpecified();
4188  else if (OldVar->isInline())
4189  Var->setImplicitlyInline();
4190 
4191  if (OldVar->getInit()) {
4194 
4195  // Instantiate the initializer.
4196  ExprResult Init;
4197 
4198  {
4199  ContextRAII SwitchContext(*this, Var->getDeclContext());
4200  Init = SubstInitializer(OldVar->getInit(), TemplateArgs,
4201  OldVar->getInitStyle() == VarDecl::CallInit);
4202  }
4203 
4204  if (!Init.isInvalid()) {
4205  Expr *InitExpr = Init.get();
4206 
4207  if (Var->hasAttr<DLLImportAttr>() &&
4208  (!InitExpr ||
4209  !InitExpr->isConstantInitializer(getASTContext(), false))) {
4210  // Do not dynamically initialize dllimport variables.
4211  } else if (InitExpr) {
4212  bool DirectInit = OldVar->isDirectInit();
4213  AddInitializerToDecl(Var, InitExpr, DirectInit);
4214  } else
4215  ActOnUninitializedDecl(Var);
4216  } else {
4217  // FIXME: Not too happy about invalidating the declaration
4218  // because of a bogus initializer.
4219  Var->setInvalidDecl();
4220  }
4221  } else {
4222  if (Var->isStaticDataMember()) {
4223  if (!Var->isOutOfLine())
4224  return;
4225 
4226  // If the declaration inside the class had an initializer, don't add
4227  // another one to the out-of-line definition.
4228  if (OldVar->getFirstDecl()->hasInit())
4229  return;
4230  }
4231 
4232  // We'll add an initializer to a for-range declaration later.
4233  if (Var->isCXXForRangeDecl())
4234  return;
4235 
4236  ActOnUninitializedDecl(Var);
4237  }
4238 }
4239 
4240 /// \brief Instantiate the definition of the given variable from its
4241 /// template.
4242 ///
4243 /// \param PointOfInstantiation the point at which the instantiation was
4244 /// required. Note that this is not precisely a "point of instantiation"
4245 /// for the variable, but it's close.
4246 ///
4247 /// \param Var the already-instantiated declaration of a templated variable.
4248 ///
4249 /// \param Recursive if true, recursively instantiates any functions that
4250 /// are required by this instantiation.
4251 ///
4252 /// \param DefinitionRequired if true, then we are performing an explicit
4253 /// instantiation where a definition of the variable is required. Complain
4254 /// if there is no such definition.
4256  VarDecl *Var, bool Recursive,
4257  bool DefinitionRequired, bool AtEndOfTU) {
4258  if (Var->isInvalidDecl())
4259  return;
4260 
4262  dyn_cast<VarTemplateSpecializationDecl>(Var);
4263  VarDecl *PatternDecl = nullptr, *Def = nullptr;
4264  MultiLevelTemplateArgumentList TemplateArgs =
4265  getTemplateInstantiationArgs(Var);
4266 
4267  if (VarSpec) {
4268  // If this is a variable template specialization, make sure that it is
4269  // non-dependent, then find its instantiation pattern.
4270  bool InstantiationDependent = false;
4272  VarSpec->getTemplateArgsInfo(), InstantiationDependent) &&
4273  "Only instantiate variable template specializations that are "
4274  "not type-dependent");
4275  (void)InstantiationDependent;
4276 
4277  // Find the variable initialization that we'll be substituting. If the
4278  // pattern was instantiated from a member template, look back further to
4279  // find the real pattern.
4280  assert(VarSpec->getSpecializedTemplate() &&
4281  "Specialization without specialized template?");
4282  llvm::PointerUnion<VarTemplateDecl *,
4283  VarTemplatePartialSpecializationDecl *> PatternPtr =
4285  if (PatternPtr.is<VarTemplatePartialSpecializationDecl *>()) {
4287  PatternPtr.get<VarTemplatePartialSpecializationDecl *>();
4289  Tmpl->getInstantiatedFromMember()) {
4290  if (Tmpl->isMemberSpecialization())
4291  break;
4292 
4293  Tmpl = From;
4294  }
4295  PatternDecl = Tmpl;
4296  } else {
4297  VarTemplateDecl *Tmpl = PatternPtr.get<VarTemplateDecl *>();
4298  while (VarTemplateDecl *From =
4300  if (Tmpl->isMemberSpecialization())
4301  break;
4302 
4303  Tmpl = From;
4304  }
4305  PatternDecl = Tmpl->getTemplatedDecl();
4306  }
4307 
4308  // If this is a static data member template, there might be an
4309  // uninstantiated initializer on the declaration. If so, instantiate
4310  // it now.
4311  //
4312  // FIXME: This largely duplicates what we would do below. The difference
4313  // is that along this path we may instantiate an initializer from an
4314  // in-class declaration of the template and instantiate the definition
4315  // from a separate out-of-class definition.
4316  if (PatternDecl->isStaticDataMember() &&
4317  (PatternDecl = PatternDecl->getFirstDecl())->hasInit() &&
4318  !Var->hasInit()) {
4319  // FIXME: Factor out the duplicated instantiation context setup/tear down
4320  // code here.
4321  InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
4322  if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
4323  return;
4324  PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
4325  "instantiating variable initializer");
4326 
4327  // The instantiation is visible here, even if it was first declared in an
4328  // unimported module.
4330 
4331  // If we're performing recursive template instantiation, create our own
4332  // queue of pending implicit instantiations that we will instantiate
4333  // later, while we're still within our own instantiation context.
4334  GlobalEagerInstantiationScope GlobalInstantiations(*this,
4335  /*Enabled=*/Recursive);
4336  LocalInstantiationScope Local(*this);
4337  LocalEagerInstantiationScope LocalInstantiations(*this);
4338 
4339  // Enter the scope of this instantiation. We don't use
4340  // PushDeclContext because we don't have a scope.
4341  ContextRAII PreviousContext(*this, Var->getDeclContext());
4342  InstantiateVariableInitializer(Var, PatternDecl, TemplateArgs);
4343  PreviousContext.pop();
4344 
4345  // This variable may have local implicit instantiations that need to be
4346  // instantiated within this scope.
4347  LocalInstantiations.perform();
4348  Local.Exit();
4349  GlobalInstantiations.perform();
4350  }
4351 
4352  // Find actual definition
4353  Def = PatternDecl->getDefinition(getASTContext());
4354  } else {
4355  // If this is a static data member, find its out-of-line definition.
4356  assert(Var->isStaticDataMember() && "not a static data member?");
4357  PatternDecl = Var->getInstantiatedFromStaticDataMember();
4358 
4359  assert(PatternDecl && "data member was not instantiated from a template?");
4360  assert(PatternDecl->isStaticDataMember() && "not a static data member?");
4361  Def = PatternDecl->getDefinition();
4362  }
4363 
4365 
4366  // If we don't have a definition of the variable template, we won't perform
4367  // any instantiation. Rather, we rely on the user to instantiate this
4368  // definition (or provide a specialization for it) in another translation
4369  // unit.
4370  if (!Def && !DefinitionRequired) {
4372  PendingInstantiations.push_back(
4373  std::make_pair(Var, PointOfInstantiation));
4374  } else if (TSK == TSK_ImplicitInstantiation) {
4375  // Warn about missing definition at the end of translation unit.
4376  if (AtEndOfTU && !getDiagnostics().hasErrorOccurred() &&
4377  !getSourceManager().isInSystemHeader(PatternDecl->getLocStart())) {
4378  Diag(PointOfInstantiation, diag::warn_var_template_missing)
4379  << Var;
4380  Diag(PatternDecl->getLocation(), diag::note_forward_template_decl);
4381  if (getLangOpts().CPlusPlus11)
4382  Diag(PointOfInstantiation, diag::note_inst_declaration_hint) << Var;
4383  }
4384  return;
4385  }
4386 
4387  }
4388 
4389  // FIXME: We need to track the instantiation stack in order to know which
4390  // definitions should be visible within this instantiation.
4391  // FIXME: Produce diagnostics when Var->getInstantiatedFromStaticDataMember().
4392  if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Var,
4393  /*InstantiatedFromMember*/false,
4394  PatternDecl, Def, TSK,
4395  /*Complain*/DefinitionRequired))
4396  return;
4397 
4398 
4399  // Never instantiate an explicit specialization.
4400  if (TSK == TSK_ExplicitSpecialization)
4401  return;
4402 
4403  // C++11 [temp.explicit]p10:
4404  // Except for inline functions, const variables of literal types, variables
4405  // of reference types, [...] explicit instantiation declarations
4406  // have the effect of suppressing the implicit instantiation of the entity
4407  // to which they refer.
4409  !Var->isUsableInConstantExpressions(getASTContext()))
4410  return;
4411 
4412  // Make sure to pass the instantiated variable to the consumer at the end.
4413  struct PassToConsumerRAII {
4414  ASTConsumer &Consumer;
4415  VarDecl *Var;
4416 
4417  PassToConsumerRAII(ASTConsumer &Consumer, VarDecl *Var)
4418  : Consumer(Consumer), Var(Var) { }
4419 
4420  ~PassToConsumerRAII() {
4422  }
4423  } PassToConsumerRAII(Consumer, Var);
4424 
4425  // If we already have a definition, we're done.
4426  if (VarDecl *Def = Var->getDefinition()) {
4427  // We may be explicitly instantiating something we've already implicitly
4428  // instantiated.
4429  Def->setTemplateSpecializationKind(Var->getTemplateSpecializationKind(),
4430  PointOfInstantiation);
4431  return;
4432  }
4433 
4434  InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
4435  if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
4436  return;
4437  PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
4438  "instantiating variable definition");
4439 
4440  // If we're performing recursive template instantiation, create our own
4441  // queue of pending implicit instantiations that we will instantiate later,
4442  // while we're still within our own instantiation context.
4443  GlobalEagerInstantiationScope GlobalInstantiations(*this,
4444  /*Enabled=*/Recursive);
4445 
4446  // Enter the scope of this instantiation. We don't use
4447  // PushDeclContext because we don't have a scope.
4448  ContextRAII PreviousContext(*this, Var->getDeclContext());
4449  LocalInstantiationScope Local(*this);
4450 
4451  LocalEagerInstantiationScope LocalInstantiations(*this);
4452 
4453  VarDecl *OldVar = Var;
4454  if (Def->isStaticDataMember() && !Def->isOutOfLine()) {
4455  // We're instantiating an inline static data member whose definition was
4456  // provided inside the class.
4457  InstantiateVariableInitializer(Var, Def, TemplateArgs);
4458  } else if (!VarSpec) {
4459  Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
4460  TemplateArgs));
4461  } else if (Var->isStaticDataMember() &&
4462  Var->getLexicalDeclContext()->isRecord()) {
4463  // We need to instantiate the definition of a static data member template,
4464  // and all we have is the in-class declaration of it. Instantiate a separate
4465  // declaration of the definition.
4466  TemplateDeclInstantiator Instantiator(*this, Var->getDeclContext(),
4467  TemplateArgs);
4468  Var = cast_or_null<VarDecl>(Instantiator.VisitVarTemplateSpecializationDecl(
4469  VarSpec->getSpecializedTemplate(), Def, nullptr,
4470  VarSpec->getTemplateArgsInfo(), VarSpec->getTemplateArgs().asArray()));
4471  if (Var) {
4472  llvm::PointerUnion<VarTemplateDecl *,
4473  VarTemplatePartialSpecializationDecl *> PatternPtr =
4476  PatternPtr.dyn_cast<VarTemplatePartialSpecializationDecl *>())
4477  cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
4478  Partial, &VarSpec->getTemplateInstantiationArgs());
4479 
4480  // Merge the definition with the declaration.
4481  LookupResult R(*this, Var->getDeclName(), Var->getLocation(),
4482  LookupOrdinaryName, forRedeclarationInCurContext());
4483  R.addDecl(OldVar);
4484  MergeVarDecl(Var, R);
4485 
4486  // Attach the initializer.
4487  InstantiateVariableInitializer(Var, Def, TemplateArgs);
4488  }
4489  } else
4490  // Complete the existing variable's definition with an appropriately
4491  // substituted type and initializer.
4492  Var = CompleteVarTemplateSpecializationDecl(VarSpec, Def, TemplateArgs);
4493 
4494  PreviousContext.pop();
4495 
4496  if (Var) {
4497  PassToConsumerRAII.Var = Var;
4499  OldVar->getPointOfInstantiation());
4500  }
4501 
4502  // This variable may have local implicit instantiations that need to be
4503  // instantiated within this scope.
4504  LocalInstantiations.perform();
4505  Local.Exit();
4506  GlobalInstantiations.perform();
4507 }
4508 
4509 void
4511  const CXXConstructorDecl *Tmpl,
4512  const MultiLevelTemplateArgumentList &TemplateArgs) {
4513 
4515  bool AnyErrors = Tmpl->isInvalidDecl();
4516 
4517  // Instantiate all the initializers.
4518  for (const auto *Init : Tmpl->inits()) {
4519  // Only instantiate written initializers, let Sema re-construct implicit
4520  // ones.
4521  if (!Init->isWritten())
4522  continue;
4523 
4524  SourceLocation EllipsisLoc;
4525 
4526  if (Init->isPackExpansion()) {
4527  // This is a pack expansion. We should expand it now.
4528  TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc();
4530  collectUnexpandedParameterPacks(BaseTL, Unexpanded);
4531  collectUnexpandedParameterPacks(Init->getInit(), Unexpanded);
4532  bool ShouldExpand = false;
4533  bool RetainExpansion = false;
4534  Optional<unsigned> NumExpansions;
4535  if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
4536  BaseTL.getSourceRange(),
4537  Unexpanded,
4538  TemplateArgs, ShouldExpand,
4539  RetainExpansion,
4540  NumExpansions)) {
4541  AnyErrors = true;
4542  New->setInvalidDecl();
4543  continue;
4544  }
4545  assert(ShouldExpand && "Partial instantiation of base initializer?");
4546 
4547  // Loop over all of the arguments in the argument pack(s),
4548  for (unsigned I = 0; I != *NumExpansions; ++I) {
4549  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
4550 
4551  // Instantiate the initializer.
4552  ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4553  /*CXXDirectInit=*/true);
4554  if (TempInit.isInvalid()) {
4555  AnyErrors = true;
4556  break;
4557  }
4558 
4559  // Instantiate the base type.
4560  TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
4561  TemplateArgs,
4562  Init->getSourceLocation(),
4563  New->getDeclName());
4564  if (!BaseTInfo) {
4565  AnyErrors = true;
4566  break;
4567  }
4568 
4569  // Build the initializer.
4570  MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
4571  BaseTInfo, TempInit.get(),
4572  New->getParent(),
4573  SourceLocation());
4574  if (NewInit.isInvalid()) {
4575  AnyErrors = true;
4576  break;
4577  }
4578 
4579  NewInits.push_back(NewInit.get());
4580  }
4581 
4582  continue;
4583  }
4584 
4585  // Instantiate the initializer.
4586  ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4587  /*CXXDirectInit=*/true);
4588  if (TempInit.isInvalid()) {
4589  AnyErrors = true;
4590  continue;
4591  }
4592 
4593  MemInitResult NewInit;
4594  if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
4595  TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
4596  TemplateArgs,
4597  Init->getSourceLocation(),
4598  New->getDeclName());
4599  if (!TInfo) {
4600  AnyErrors = true;
4601  New->setInvalidDecl();
4602  continue;
4603  }
4604 
4605  if (Init->isBaseInitializer())
4606  NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.get(),
4607  New->getParent(), EllipsisLoc);
4608  else
4609  NewInit = BuildDelegatingInitializer(TInfo, TempInit.get(),
4610  cast<CXXRecordDecl>(CurContext->getParent()));
4611  } else if (Init->isMemberInitializer()) {
4612  FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
4613  Init->getMemberLocation(),
4614  Init->getMember(),
4615  TemplateArgs));
4616  if (!Member) {
4617  AnyErrors = true;
4618  New->setInvalidDecl();
4619  continue;
4620  }
4621 
4622  NewInit = BuildMemberInitializer(Member, TempInit.get(),
4623  Init->getSourceLocation());
4624  } else if (Init->isIndirectMemberInitializer()) {
4625  IndirectFieldDecl *IndirectMember =
4626  cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
4627  Init->getMemberLocation(),
4628  Init->getIndirectMember(), TemplateArgs));
4629 
4630  if (!IndirectMember) {
4631  AnyErrors = true;
4632  New->setInvalidDecl();
4633  continue;
4634  }
4635 
4636  NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(),
4637  Init->getSourceLocation());
4638  }
4639 
4640  if (NewInit.isInvalid()) {
4641  AnyErrors = true;
4642  New->setInvalidDecl();
4643  } else {
4644  NewInits.push_back(NewInit.get());
4645  }
4646  }
4647 
4648  // Assign all the initializers to the new constructor.
4649  ActOnMemInitializers(New,
4650  /*FIXME: ColonLoc */
4651  SourceLocation(),
4652  NewInits,
4653  AnyErrors);
4654 }
4655 
4656 // TODO: this could be templated if the various decl types used the
4657 // same method name.
4659  ClassTemplateDecl *Instance) {
4660  Pattern = Pattern->getCanonicalDecl();
4661 
4662  do {
4663  Instance = Instance->getCanonicalDecl();
4664  if (Pattern == Instance) return true;
4665  Instance = Instance->getInstantiatedFromMemberTemplate();
4666  } while (Instance);
4667 
4668  return false;
4669 }
4670 
4672  FunctionTemplateDecl *Instance) {
4673  Pattern = Pattern->getCanonicalDecl();
4674 
4675  do {
4676  Instance = Instance->getCanonicalDecl();
4677  if (Pattern == Instance) return true;
4678  Instance = Instance->getInstantiatedFromMemberTemplate();
4679  } while (Instance);
4680 
4681  return false;
4682 }
4683 
4684 static bool
4687  Pattern
4688  = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
4689  do {
4690  Instance = cast<ClassTemplatePartialSpecializationDecl>(
4691  Instance->getCanonicalDecl());
4692  if (Pattern == Instance)
4693  return true;
4694  Instance = Instance->getInstantiatedFromMember();
4695  } while (Instance);
4696 
4697  return false;
4698 }
4699 
4700 static bool isInstantiationOf(CXXRecordDecl *Pattern,
4701  CXXRecordDecl *Instance) {
4702  Pattern = Pattern->getCanonicalDecl();
4703 
4704  do {
4705  Instance = Instance->getCanonicalDecl();
4706  if (Pattern == Instance) return true;
4707  Instance = Instance->getInstantiatedFromMemberClass();
4708  } while (Instance);
4709 
4710  return false;
4711 }
4712 
4713 static bool isInstantiationOf(FunctionDecl *Pattern,
4714  FunctionDecl *Instance) {
4715  Pattern = Pattern->getCanonicalDecl();
4716 
4717  do {
4718  Instance = Instance->getCanonicalDecl();
4719  if (Pattern == Instance) return true;
4720  Instance = Instance->getInstantiatedFromMemberFunction();
4721  } while (Instance);
4722 
4723  return false;
4724 }
4725 
4726 static bool isInstantiationOf(EnumDecl *Pattern,
4727  EnumDecl *Instance) {
4728  Pattern = Pattern->getCanonicalDecl();
4729 
4730  do {
4731  Instance = Instance->getCanonicalDecl();
4732  if (Pattern == Instance) return true;
4733  Instance = Instance->getInstantiatedFromMemberEnum();
4734  } while (Instance);
4735 
4736  return false;
4737 }
4738 
4739 static bool isInstantiationOf(UsingShadowDecl *Pattern,
4740  UsingShadowDecl *Instance,
4741  ASTContext &C) {
4743  Pattern);
4744 }
4745 
4746 static bool isInstantiationOf(UsingDecl *Pattern, UsingDecl *Instance,
4747  ASTContext &C) {
4748  return declaresSameEntity(C.getInstantiatedFromUsingDecl(Instance), Pattern);
4749 }
4750 
4751 template<typename T>
4752 static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other,
4753  ASTContext &Ctx) {
4754  // An unresolved using declaration can instantiate to an unresolved using
4755  // declaration, or to a using declaration or a using declaration pack.
4756  //
4757  // Multiple declarations can claim to be instantiated from an unresolved
4758  // using declaration if it's a pack expansion. We want the UsingPackDecl
4759  // in that case, not the individual UsingDecls within the pack.
4760  bool OtherIsPackExpansion;
4761  NamedDecl *OtherFrom;
4762  if (auto *OtherUUD = dyn_cast<T>(Other)) {
4763  OtherIsPackExpansion = OtherUUD->isPackExpansion();
4764  OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUUD);
4765  } else if (auto *OtherUPD = dyn_cast<UsingPackDecl>(Other)) {
4766  OtherIsPackExpansion = true;
4767  OtherFrom = OtherUPD->getInstantiatedFromUsingDecl();
4768  } else if (auto *OtherUD = dyn_cast<UsingDecl>(Other)) {
4769  OtherIsPackExpansion = false;
4770  OtherFrom = Ctx.getInstantiatedFromUsingDecl(OtherUD);
4771  } else {
4772  return false;
4773  }
4774  return Pattern->isPackExpansion() == OtherIsPackExpansion &&
4775  declaresSameEntity(OtherFrom, Pattern);
4776 }
4777 
4779  VarDecl *Instance) {
4780  assert(Instance->isStaticDataMember());
4781 
4782  Pattern = Pattern->getCanonicalDecl();
4783 
4784  do {
4785  Instance = Instance->getCanonicalDecl();
4786  if (Pattern == Instance) return true;
4787  Instance = Instance->getInstantiatedFromStaticDataMember();
4788  } while (Instance);
4789 
4790  return false;
4791 }
4792 
4793 // Other is the prospective instantiation
4794 // D is the prospective pattern
4795 static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
4796  if (auto *UUD = dyn_cast<UnresolvedUsingTypenameDecl>(D))
4797  return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
4798 
4799  if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(D))
4800  return isInstantiationOfUnresolvedUsingDecl(UUD, Other, Ctx);
4801 
4802  if (D->getKind() != Other->getKind())
4803  return false;
4804 
4805  if (auto *Record = dyn_cast<CXXRecordDecl>(Other))
4806  return isInstantiationOf(cast<CXXRecordDecl>(D), Record);
4807 
4808  if (auto *Function = dyn_cast<FunctionDecl>(Other))
4809  return isInstantiationOf(cast<FunctionDecl>(D), Function);
4810 
4811  if (auto *Enum = dyn_cast<EnumDecl>(Other))
4812  return isInstantiationOf(cast<EnumDecl>(D), Enum);
4813 
4814  if (auto *Var = dyn_cast<VarDecl>(Other))
4815  if (Var->isStaticDataMember())
4816  return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);
4817 
4818  if (auto *Temp = dyn_cast<ClassTemplateDecl>(Other))
4819  return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);
4820 
4821  if (auto *Temp = dyn_cast<FunctionTemplateDecl>(Other))
4822  return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);
4823 
4824  if (auto *PartialSpec =
4825  dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
4826  return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
4827  PartialSpec);
4828 
4829  if (auto *Field = dyn_cast<FieldDecl>(Other)) {
4830  if (!Field->getDeclName()) {
4831  // This is an unnamed field.
4833  cast<FieldDecl>(D));
4834  }
4835  }
4836 
4837  if (auto *Using = dyn_cast<UsingDecl>(Other))
4838  return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);
4839 
4840  if (auto *Shadow = dyn_cast<UsingShadowDecl>(Other))
4841  return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);
4842 
4843  return D->getDeclName() &&
4844  D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
4845 }
4846 
4847 template<typename ForwardIterator>
4849  NamedDecl *D,
4850  ForwardIterator first,
4851  ForwardIterator last) {
4852  for (; first != last; ++first)
4853  if (isInstantiationOf(Ctx, D, *first))
4854  return cast<NamedDecl>(*first);
4855 
4856  return nullptr;
4857 }
4858 
4859 /// \brief Finds the instantiation of the given declaration context
4860 /// within the current instantiation.
4861 ///
4862 /// \returns NULL if there was an error
4864  const MultiLevelTemplateArgumentList &TemplateArgs) {
4865  if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
4866  Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs, true);
4867  return cast_or_null<DeclContext>(ID);
4868  } else return DC;
4869 }
4870 
4871 /// \brief Find the instantiation of the given declaration within the
4872 /// current instantiation.
4873 ///
4874 /// This routine is intended to be used when \p D is a declaration
4875 /// referenced from within a template, that needs to mapped into the
4876 /// corresponding declaration within an instantiation. For example,
4877 /// given:
4878 ///
4879 /// \code
4880 /// template<typename T>
4881 /// struct X {
4882 /// enum Kind {
4883 /// KnownValue = sizeof(T)
4884 /// };
4885 ///
4886 /// bool getKind() const { return KnownValue; }
4887 /// };
4888 ///
4889 /// template struct X<int>;
4890 /// \endcode
4891 ///
4892 /// In the instantiation of <tt>X<int>::getKind()</tt>, we need to map the
4893 /// \p EnumConstantDecl for \p KnownValue (which refers to
4894 /// <tt>X<T>::<Kind>::KnownValue</tt>) to its instantiation
4895 /// (<tt>X<int>::<Kind>::KnownValue</tt>). \p FindInstantiatedDecl performs
4896 /// this mapping from within the instantiation of <tt>X<int></tt>.
4898  const MultiLevelTemplateArgumentList &TemplateArgs,
4899  bool FindingInstantiatedContext) {
4900  DeclContext *ParentDC = D->getDeclContext();
4901  // FIXME: Parmeters of pointer to functions (y below) that are themselves
4902  // parameters (p below) can have their ParentDC set to the translation-unit
4903  // - thus we can not consistently check if the ParentDC of such a parameter
4904  // is Dependent or/and a FunctionOrMethod.
4905  // For e.g. this code, during Template argument deduction tries to
4906  // find an instantiated decl for (T y) when the ParentDC for y is
4907  // the translation unit.
4908  // e.g. template <class T> void Foo(auto (*p)(T y) -> decltype(y())) {}
4909  // float baz(float(*)()) { return 0.0; }
4910  // Foo(baz);
4911  // The better fix here is perhaps to ensure that a ParmVarDecl, by the time
4912  // it gets here, always has a FunctionOrMethod as its ParentDC??
4913  // For now:
4914  // - as long as we have a ParmVarDecl whose parent is non-dependent and
4915  // whose type is not instantiation dependent, do nothing to the decl
4916  // - otherwise find its instantiated decl.
4917  if (isa<ParmVarDecl>(D) && !ParentDC->isDependentContext() &&
4918  !cast<ParmVarDecl>(D)->getType()->isInstantiationDependentType())
4919  return D;
4920  if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
4921  isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
4922  (ParentDC->isFunctionOrMethod() && ParentDC->isDependentContext()) ||
4923  (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) {
4924  // D is a local of some kind. Look into the map of local
4925  // declarations to their instantiations.
4926  if (CurrentInstantiationScope) {
4927  if (auto Found = CurrentInstantiationScope->findInstantiationOf(D)) {
4928  if (Decl *FD = Found->dyn_cast<Decl *>())
4929  return cast<NamedDecl>(FD);
4930 
4931  int PackIdx = ArgumentPackSubstitutionIndex;
4932  assert(PackIdx != -1 &&
4933  "found declaration pack but not pack expanding");
4934  typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
4935  return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
4936  }
4937  }
4938 
4939  // If we're performing a partial substitution during template argument
4940  // deduction, we may not have values for template parameters yet. They
4941  // just map to themselves.
4942  if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
4943  isa<TemplateTemplateParmDecl>(D))
4944  return D;
4945 
4946  if (D->isInvalidDecl())
4947  return nullptr;
4948 
4949  // Normally this function only searches for already instantiated declaration
4950  // however we have to make an exclusion for local types used before
4951  // definition as in the code:
4952  //
4953  // template<typename T> void f1() {
4954  // void g1(struct x1);
4955  // struct x1 {};
4956  // }
4957  //
4958  // In this case instantiation of the type of 'g1' requires definition of
4959  // 'x1', which is defined later. Error recovery may produce an enum used
4960  // before definition. In these cases we need to instantiate relevant
4961  // declarations here.
4962  bool NeedInstantiate = false;
4963  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
4964  NeedInstantiate = RD->isLocalClass();
4965  else
4966  NeedInstantiate = isa<EnumDecl>(D);
4967  if (NeedInstantiate) {
4968  Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
4969  CurrentInstantiationScope->InstantiatedLocal(D, Inst);
4970  return cast<TypeDecl>(Inst);
4971  }
4972 
4973  // If we didn't find the decl, then we must have a label decl that hasn't
4974  // been found yet. Lazily instantiate it and return it now.
4975  assert(isa<LabelDecl>(D));
4976 
4977  Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
4978  assert(Inst && "Failed to instantiate label??");
4979 
4980  CurrentInstantiationScope->InstantiatedLocal(D, Inst);
4981  return cast<LabelDecl>(Inst);
4982  }
4983 
4984  // For variable template specializations, update those that are still
4985  // type-dependent.
4986  if (VarTemplateSpecializationDecl *VarSpec =
4987  dyn_cast<VarTemplateSpecializationDecl>(D)) {
4988  bool InstantiationDependent = false;
4989  const TemplateArgumentListInfo &VarTemplateArgs =
4990  VarSpec->getTemplateArgsInfo();
4992  VarTemplateArgs, InstantiationDependent))
4993  D = cast<NamedDecl>(
4994  SubstDecl(D, VarSpec->getDeclContext(), TemplateArgs));
4995  return D;
4996  }
4997 
4998  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
4999  if (!Record->isDependentContext())
5000  return D;
5001 
5002  // Determine whether this record is the "templated" declaration describing
5003  // a class template or class template partial specialization.
5004  ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate();
5005  if (ClassTemplate)
5006  ClassTemplate = ClassTemplate->getCanonicalDecl();
5007  else if (ClassTemplatePartialSpecializationDecl *PartialSpec
5008  = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record))
5009  ClassTemplate = PartialSpec->getSpecializedTemplate()->getCanonicalDecl();
5010 
5011  // Walk the current context to find either the record or an instantiation of
5012  // it.
5013  DeclContext *DC = CurContext;
5014  while (!DC->isFileContext()) {
5015  // If we're performing substitution while we're inside the template
5016  // definition, we'll find our own context. We're done.
5017  if (DC->Equals(Record))
5018  return Record;
5019 
5020  if (CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
5021  // Check whether we're in the process of instantiating a class template
5022  // specialization of the template we're mapping.
5023  if (ClassTemplateSpecializationDecl *InstSpec
5024  = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
5025  ClassTemplateDecl *SpecTemplate = InstSpec->getSpecializedTemplate();
5026  if (ClassTemplate && isInstantiationOf(ClassTemplate, SpecTemplate))
5027  return InstRecord;
5028  }
5029 
5030  // Check whether we're in the process of instantiating a member class.
5031  if (isInstantiationOf(Record, InstRecord))
5032  return InstRecord;
5033  }
5034 
5035  // Move to the outer template scope.
5036  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) {
5037  if (FD->getFriendObjectKind() && FD->getDeclContext()->isFileContext()){
5038  DC = FD->getLexicalDeclContext();
5039  continue;
5040  }
5041  // An implicit deduction guide acts as if it's within the class template
5042  // specialization described by its name and first N template params.
5043  auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FD);
5044  if (Guide && Guide->isImplicit()) {
5045  TemplateDecl *TD = Guide->getDeducedTemplate();
5046  // Convert the arguments to an "as-written" list.
5047  TemplateArgumentListInfo Args(Loc, Loc);
5048  for (TemplateArgument Arg : TemplateArgs.getInnermost().take_front(
5049  TD->getTemplateParameters()->size())) {
5050  ArrayRef<TemplateArgument> Unpacked(Arg);
5051  if (Arg.getKind() == TemplateArgument::Pack)
5052  Unpacked = Arg.pack_elements();
5053  for (TemplateArgument UnpackedArg : Unpacked)
5054  Args.addArgument(
5055  getTrivialTemplateArgumentLoc(UnpackedArg, QualType(), Loc));
5056  }
5057  QualType T = CheckTemplateIdType(TemplateName(TD), Loc, Args);
5058  if (T.isNull())
5059  return nullptr;
5060  auto *SubstRecord = T->getAsCXXRecordDecl();
5061  assert(SubstRecord && "class template id not a class type?");
5062  // Check that this template-id names the primary template and not a
5063  // partial or explicit specialization. (In the latter cases, it's
5064  // meaningless to attempt to find an instantiation of D within the
5065  // specialization.)
5066  // FIXME: The standard doesn't say what should happen here.
5067  if (FindingInstantiatedContext &&
5068  usesPartialOrExplicitSpecialization(
5069  Loc, cast<ClassTemplateSpecializationDecl>(SubstRecord))) {
5070  Diag(Loc, diag::err_specialization_not_primary_template)
5071  << T << (SubstRecord->getTemplateSpecializationKind() ==
5073  return nullptr;
5074  }
5075  DC = SubstRecord;
5076  continue;
5077  }
5078  }
5079 
5080  DC = DC->getParent();
5081  }
5082 
5083  // Fall through to deal with other dependent record types (e.g.,
5084  // anonymous unions in class templates).
5085  }
5086 
5087  if (!ParentDC->isDependentContext())
5088  return D;
5089 
5090  ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
5091  if (!ParentDC)
5092  return nullptr;
5093 
5094  if (ParentDC != D->getDeclContext()) {
5095  // We performed some kind of instantiation in the parent context,
5096  // so now we need to look into the instantiated parent context to
5097  // find the instantiation of the declaration D.
5098 
5099  // If our context used to be dependent, we may need to instantiate
5100  // it before performing lookup into that context.
5101  bool IsBeingInstantiated = false;
5102  if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
5103  if (!Spec->isDependentContext()) {
5104  QualType T = Context.getTypeDeclType(Spec);
5105  const RecordType *Tag = T->getAs<RecordType>();
5106  assert(Tag && "type of non-dependent record is not a RecordType");
5107  if (Tag->isBeingDefined())
5108  IsBeingInstantiated = true;
5109  if (!Tag->isBeingDefined() &&
5110  RequireCompleteType(Loc, T, diag::err_incomplete_type))
5111  return nullptr;
5112 
5113  ParentDC = Tag->getDecl();
5114  }
5115  }
5116 
5117  NamedDecl *Result = nullptr;
5118  // FIXME: If the name is a dependent name, this lookup won't necessarily
5119  // find it. Does that ever matter?
5120  if (auto Name = D->getDeclName()) {
5121  DeclarationNameInfo NameInfo(Name, D->getLocation());
5122  Name = SubstDeclarationNameInfo(NameInfo, TemplateArgs).getName();
5123  if (!Name)
5124  return nullptr;
5125  DeclContext::lookup_result Found = ParentDC->lookup(Name);
5126  Result = findInstantiationOf(Context, D, Found.begin(), Found.end());
5127  } else {
5128  // Since we don't have a name for the entity we're looking for,
5129  // our only option is to walk through all of the declarations to
5130  // find that name. This will occur in a few cases:
5131  //
5132  // - anonymous struct/union within a template
5133  // - unnamed class/struct/union/enum within a template
5134  //
5135  // FIXME: Find a better way to find these instantiations!
5136  Result = findInstantiationOf(Context, D,
5137  ParentDC->decls_begin(),
5138  ParentDC->decls_end());
5139  }
5140 
5141  if (!Result) {
5142  if (isa<UsingShadowDecl>(D)) {
5143  // UsingShadowDecls can instantiate to nothing because of using hiding.
5144  } else if (Diags.hasErrorOccurred()) {
5145  // We've already complained about something, so most likely this
5146  // declaration failed to instantiate. There's no point in complaining
5147  // further, since this is normal in invalid code.
5148  } else if (IsBeingInstantiated) {
5149  // The class in which this member exists is currently being
5150  // instantiated, and we haven't gotten around to instantiating this
5151  // member yet. This can happen when the code uses forward declarations
5152  // of member classes, and introduces ordering dependencies via
5153  // template instantiation.
5154  Diag(Loc, diag::err_member_not_yet_instantiated)
5155  << D->getDeclName()
5156  << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
5157  Diag(D->getLocation(), diag::note_non_instantiated_member_here);
5158  } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
5159  // This enumeration constant was found when the template was defined,
5160  // but can't be found in the instantiation. This can happen if an
5161  // unscoped enumeration member is explicitly specialized.
5162  EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
5163  EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum,
5164  TemplateArgs));
5165  assert(Spec->getTemplateSpecializationKind() ==
5167  Diag(Loc, diag::err_enumerator_does_not_exist)
5168  << D->getDeclName()
5169  << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext()));
5170  Diag(Spec->getLocation(), diag::note_enum_specialized_here)
5171  << Context.getTypeDeclType(Spec);
5172  } else {
5173  // We should have found something, but didn't.
5174  llvm_unreachable("Unable to find instantiation of declaration!");
5175  }
5176  }
5177 
5178  D = Result;
5179  }
5180 
5181  return D;
5182 }
5183 
5184 /// \brief Performs template instantiation for all implicit template
5185 /// instantiations we have seen until this point.
5187  while (!PendingLocalImplicitInstantiations.empty() ||
5188  (!LocalOnly && !PendingInstantiations.empty())) {
5190 
5191  if (PendingLocalImplicitInstantiations.empty()) {
5192  Inst = PendingInstantiations.front();
5193  PendingInstantiations.pop_front();
5194  } else {
5195  Inst = PendingLocalImplicitInstantiations.front();
5196  PendingLocalImplicitInstantiations.pop_front();
5197  }
5198 
5199  // Instantiate function definitions
5200  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
5201  bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
5203  InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true,
5204  DefinitionRequired, true);
5205  if (Function->isDefined())
5206  Function->setInstantiationIsPending(false);
5207  continue;
5208  }
5209 
5210  // Instantiate variable definitions
5211  VarDecl *Var = cast<VarDecl>(Inst.first);
5212 
5213  assert((Var->isStaticDataMember() ||
5214  isa<VarTemplateSpecializationDecl>(Var)) &&
5215  "Not a static data member, nor a variable template"
5216  " specialization?");
5217 
5218  // Don't try to instantiate declarations if the most recent redeclaration
5219  // is invalid.
5220  if (Var->getMostRecentDecl()->isInvalidDecl())
5221  continue;
5222 
5223  // Check if the most recent declaration has changed the specialization kind
5224  // and removed the need for implicit instantiation.
5226  case TSK_Undeclared:
5227  llvm_unreachable("Cannot instantitiate an undeclared specialization.");
5230  continue; // No longer need to instantiate this type.
5232  // We only need an instantiation if the pending instantiation *is* the
5233  // explicit instantiation.
5234  if (Var != Var->getMostRecentDecl())
5235  continue;
5236  break;
5238  break;
5239  }
5240 
5241  PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
5242  "instantiating variable definition");
5243  bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
5245 
5246  // Instantiate static data member definitions or variable template
5247  // specializations.
5248  InstantiateVariableDefinition(/*FIXME:*/ Inst.second, Var, true,
5249  DefinitionRequired, true);
5250  }
5251 }
5252 
5254  const MultiLevelTemplateArgumentList &TemplateArgs) {
5255  for (auto DD : Pattern->ddiags()) {
5256  switch (DD->getKind()) {
5258  HandleDependentAccessCheck(*DD, TemplateArgs);
5259  break;
5260  }
5261  }
5262 }
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2397
The lookup results will be used for redeclaration of a name with external linkage; non-visible lookup...
Definition: Sema.h:3049
Defines the clang::ASTContext interface.
FunctionDecl * getDefinition()
Get the definition for this declaration.
Definition: Decl.h:1945
void InstantiateClassMembers(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK)
Instantiates the definitions of all of the member of the given class, which is an instantiation of a ...
static void collectUnexpandedParameterPacks(Sema &S, TemplateParameterList *Params, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition: Sema.h:3045
void setImplicit(bool I=true)
Definition: DeclBase.h:552
An instance of this class is created to represent a function declaration or definition.
Definition: Decl.h:1697
NamespaceDecl * getStdNamespace() const
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
no exception specification
virtual void HandleCXXStaticMemberVarInstantiation(VarDecl *D)
HandleCXXStaticMemberVarInstantiation - Tell the consumer that this.
Definition: ASTConsumer.h:112
bool TemplateParameterListsAreEqual(TemplateParameterList *New, TemplateParameterList *Old, bool Complain, TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc=SourceLocation())
Determine whether the given template parameter lists are equivalent.
void InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
A (possibly-)qualified type.
Definition: Type.h:653
void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D)
Initialize declare reduction construct initializer.
const char * getDeclKindName() const
Definition: DeclBase.cpp:123
void InstantiatedLocal(const Decl *D, Decl *Inst)
bool CheckTemplateParameterList(TemplateParameterList *NewParams, TemplateParameterList *OldParams, TemplateParamListContext TPC)
Checks the validity of a template parameter list, possibly considering the template parameter list fr...
void setTemplateKeywordLoc(SourceLocation Loc)
Sets the location of the template keyword.
Decl * VisitVarDecl(VarDecl *D, bool InstantiatingVarTemplate, ArrayRef< BindingDecl *> *Bindings=nullptr)
bool isOverloadedOperator() const
isOverloadedOperator - Whether this function declaration represents an C++ overloaded operator...
Definition: Decl.h:2267
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:34
A stack-allocated class that identifies which local variable declaration instantiations are present i...
Definition: Template.h:202
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:404
void InstantiateExceptionSpec(SourceLocation PointOfInstantiation, FunctionDecl *Function)
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2994
SourceRange getBraceRange() const
Definition: Decl.h:3072
bool willHaveBody() const
True if this function will eventually have a body, once it&#39;s fully parsed.
Definition: Decl.h:2154
DeclarationName getCXXConstructorName(CanQualType Ty)
getCXXConstructorName - Returns the name of a C++ constructor for the given Type. ...
static void instantiateDependentAllocAlignAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AllocAlignAttr *Align, Decl *New)
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
Definition: Decl.h:2590
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Definition: TemplateBase.h:526
void addOuterTemplateArguments(const TemplateArgumentList *TemplateArgs)
Add a new outermost level to the multi-level template argument list.
Definition: Template.h:111
Expr * getUnderlyingExpr() const
Definition: Type.h:3862
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl *> CH)
Definition: Decl.cpp:4306
Stmt - This represents one statement.
Definition: Stmt.h:66
Expr * getBitWidth() const
Definition: Decl.h:2556
We are matching the template parameter lists of two templates that might be redeclarations.
Definition: Sema.h:6379
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:4111
Provides information about an attempted template argument deduction, whose success or failure was des...
ClassTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
static bool isDeclWithinFunction(const Decl *D)
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function...
Definition: Decl.cpp:3486
EnumConstantDecl - An instance of this object exists for each enum constant that is defined...
Definition: Decl.h:2671
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1009
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
Definition: Decl.cpp:3716
TypedefDecl - Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier...
Definition: Decl.h:2898
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...
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2042
VarTemplateSpecializationDecl * BuildVarTemplateInstantiation(VarTemplateDecl *VarTemplate, VarDecl *FromVar, const TemplateArgumentList &TemplateArgList, const TemplateArgumentListInfo &TemplateArgsInfo, SmallVectorImpl< TemplateArgument > &Converted, SourceLocation PointOfInstantiation, void *InsertPos, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *StartingScope=nullptr)
unsigned getNumExpansionTypes() const
Retrieves the number of expansion types in an expanded parameter pack.
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, TemplateParameterList *Params)
bool isSingleTagDecl() const
Asks if the result is a single tag decl.
Definition: Lookup.h:533
const Type * getTypeForDecl() const
Definition: Decl.h:2784
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1270
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
void setRangeEnd(SourceLocation E)
Definition: Decl.h:1914
static Expr * instantiateDependentFunctionAttrCondition(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New)
IdentifierInfo * getGetterId() const
Definition: DeclCXX.h:3856
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2083
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:1018
llvm::PointerUnion< Decl *, DeclArgumentPack * > * findInstantiationOf(const Decl *D)
Find the instantiation of the declaration D within the current instantiation scope.
Defines the C++ template declaration subclasses.
StringRef P
bool hasWrittenPrototype() const
Definition: Decl.h:2034
Decl * InstantiateTypedefNameDecl(TypedefNameDecl *D, bool IsTypeAlias)
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:7167
Not a friend object.
Definition: DeclBase.h:1093
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:952
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:5891
FunctionDecl * InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD, const TemplateArgumentList *Args, SourceLocation Loc)
Instantiate (or find existing instantiation of) a function template with a given set of template argu...
SourceLocation getColonLoc() const
The location of the colon following the access specifier.
Definition: DeclCXX.h:153
bool isCXXForRangeDecl() const
Determine whether this variable is the for-range-declaration in a C++0x for-range statement...
Definition: Decl.h:1327
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
Definition: Sema.h:7569
Declaration of a variable template.
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:505
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:671
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
Definition: Type.h:3209
A container of type source information.
Definition: Decl.h:86
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
std::pair< ValueDecl *, SourceLocation > PendingImplicitInstantiation
An entity for which implicit template instantiation is required.
Definition: Sema.h:7518
FieldDecl * getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field)
TypeSourceInfo * getDefaultArgumentInfo() const
Retrieves the default argument&#39;s source information, if any.
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function is defined at all, including a deleted definition.
Definition: Decl.cpp:2605
void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo)
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclBase.h:412
void setInitStyle(InitializationStyle Style)
Definition: Decl.h:1257
VarTemplatePartialSpecializationDecl * InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a variable template partial specialization.
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:2397
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
Instantiate or parse a C++ default argument expression as necessary.
Definition: SemaExpr.cpp:4471
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:1991
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
static void instantiateDependentEnableIfAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New)
SourceLocation getTargetNameLoc() const
Returns the location of the identifier in the named namespace.
Definition: DeclCXX.h:3039
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:3097
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a #pragma comment line.
Definition: Decl.h:139
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2087
NamedDecl * BuildUsingPackDecl(NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl *> Expansions)
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
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:566
unsigned getDepth() const
Get the nesting depth of the template parameter.
enumerator_range enumerators() const
Definition: Decl.h:3336
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
void InstantiatedLocalPackArg(const Decl *D, ParmVarDecl *Inst)
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:10640
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:806
static CXXConversionDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, bool isExplicit, bool isConstexpr, SourceLocation EndLocation)
Definition: DeclCXX.cpp:2229
QualType getReturnType() const
Definition: Decl.h:2207
bool SubstQualifier(const DeclaratorDecl *OldDecl, DeclaratorDecl *NewDecl)
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3426
static void instantiateDependentAlignedAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion)
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6305
void setClassScopeSpecializationPattern(FunctionDecl *FD, FunctionDecl *Pattern)
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
Extra information about a function prototype.
Definition: Type.h:3387
TypeSourceInfo * SubstFunctionDeclType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext, unsigned ThisTypeQuals)
A form of SubstType intended specifically for instantiating the type of a FunctionDecl.
Declaration context for names declared as extern "C" in C++.
Definition: Decl.h:221
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Definition: DeclCXX.cpp:2637
Represents a variable template specialization, which refers to a variable template with a given set o...
RAII object used to temporarily allow the C++ &#39;this&#39; expression to be used, with the given qualifiers...
Definition: Sema.h:5040
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:595
static void instantiateDependentCUDALaunchBoundsAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const CUDALaunchBoundsAttr &Attr, Decl *New)
reference front() const
Definition: DeclBase.h:1230
bool isInvalidDecl() const
Definition: DeclBase.h:546
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
Definition: Sema.h:7061
static void instantiateDependentAssumeAlignedAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AssumeAlignedAttr *Aligned, Decl *New)
bool isStatic() const
Definition: DeclCXX.cpp:1633
Look up an ordinary name that is going to be redeclared as a name with linkage.
Definition: Sema.h:3023
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1513
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Definition: DeclCXX.h:162
Defines the clang::Expr interface and subclasses for C++ expressions.
Provides information about a dependent function-template specialization declaration.
Definition: DeclTemplate.h:671
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
Definition: DeclCXX.h:1572
DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(Scope *S, DeclContext *DC, DeclarationName Name, ArrayRef< std::pair< QualType, SourceLocation >> ReductionTypes, AccessSpecifier AS, Decl *PrevDeclInScope=nullptr)
Called on start of &#39;#pragma omp declare reduction&#39;.
DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen, ArrayRef< Expr *> Uniforms, ArrayRef< Expr *> Aligneds, ArrayRef< Expr *> Alignments, ArrayRef< Expr *> Linears, ArrayRef< unsigned > LinModifiers, ArrayRef< Expr *> Steps, SourceRange SR)
Called on well-formed &#39;#pragma omp declare simd&#39; after parsing of the associated method/function.
void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T)
Mark all of the declarations referenced within a particular AST node as referenced.
Definition: SemaExpr.cpp:15077
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:265
bool isLexicallyWithinFunctionOrMethod() const
Returns true if this declaration lexically is inside a function.
Definition: DeclBase.cpp:337
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
AccessResult CheckFriendAccess(NamedDecl *D)
Checks access to the target of a friend declaration.
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3488
bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc)
Checks that the given nested-name qualifier used in a using decl in the current context is appropriat...
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:291
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists...
Definition: Decl.h:3380
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3388
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:859
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7489
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
Definition: DeclFriend.h:124
unsigned getDepth() const
Retrieve the depth of the template parameter.
StringLiteral * getMessage()
Definition: DeclCXX.h:3695
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
void setManglingNumber(const NamedDecl *ND, unsigned Number)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
A C++ nested-name-specifier augmented with source location information.
ExprResult ExprEmpty()
Definition: Ownership.h:273
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:3496
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1182
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Definition: DeclCXX.h:3020
void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl)
void AddModeAttr(SourceRange AttrRange, Decl *D, IdentifierInfo *Name, unsigned SpellingListIndex, bool InInstantiation=false)
AddModeAttr - Adds a mode attribute to a particular declaration.
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
Definition: SemaDecl.cpp:12807
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
Definition: Type.cpp:3200
VarTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
static DecompositionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation LSquareLoc, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< BindingDecl *> Bindings)
Definition: DeclCXX.cpp:2599
bool hasSkippedBody() const
True if the function was a definition but its body was skipped.
Definition: Decl.h:2150
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2467
The current expression is potentially evaluated at run time, which means that code may be generated t...
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
Definition: SemaDecl.cpp:54
unsigned getStaticLocalNumber(const VarDecl *VD) const
Decl * VisitVarTemplateSpecializationDecl(VarTemplateDecl *VarTemplate, VarDecl *FromVar, void *InsertPos, const TemplateArgumentListInfo &TemplateArgsInfo, ArrayRef< TemplateArgument > Converted)
bool isNamespace() const
Definition: DeclBase.h:1413
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
Definition: DeclBase.h:772
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern)
Remember that the using decl Inst is an instantiation of the using decl Pattern of a class template...
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:3725
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
bool isReferenceType() const
Definition: Type.h:5954
InitKind getInitializerKind() const
Get initializer kind.
Definition: DeclOpenMP.h:157
NamedDecl * getFriendDecl() const
If this friend declaration doesn&#39;t name a type, return the inner declaration.
Definition: DeclFriend.h:139
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:404
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
bool isInIdentifierNamespace(unsigned NS) const
Definition: DeclBase.h:795
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
ParmVarDecl * getParam(unsigned i) const
Definition: TypeLoc.h:1477
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1455
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, bool IsExplicit, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation)
Definition: DeclCXX.cpp:1616
void Exit()
Exit this local instantiation scope early.
Definition: Template.h:285
bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef< UnexpandedParameterPack > Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, Optional< unsigned > &NumExpansions)
Determine whether we could expand a pack expansion with the given set of parameter packs into separat...
Represents an access specifier followed by colon &#39;:&#39;.
Definition: DeclCXX.h:131
DeclarationNameInfo SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, const MultiLevelTemplateArgumentList &TemplateArgs)
Do template substitution on declaration name info.
Declaration of a function specialization at template class scope.
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration&#39;s previous declaration was declared in the same block ...
Definition: Decl.h:1385
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Adjust the DeclContext for a function or variable that might be a function-local external declaration...
Definition: SemaDecl.cpp:6178
IdentifierTable & Idents
Definition: ASTContext.h:537
TypeSourceInfo * getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &Args, QualType Canon=QualType()) const
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2167
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:2387
void InstantiateMemInitializers(CXXConstructorDecl *New, const CXXConstructorDecl *Tmpl, const MultiLevelTemplateArgumentList &TemplateArgs)
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
SourceLocation getLAngleLoc() const
Definition: TypeLoc.h:1633
Represents a C++ using-declaration.
Definition: DeclCXX.h:3275
FunctionTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
void AddAssumeAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E, Expr *OE, unsigned SpellingListIndex)
AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular declaration.
ArrayRef< BindingDecl * > bindings() const
Definition: DeclCXX.h:3798
static void instantiateDependentDiagnoseIfAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New)
Expr * getInitializer()
Get initializer expression (if specified) of the declare reduction construct.
Definition: DeclOpenMP.h:154
Represents the results of name lookup.
Definition: Lookup.h:32
PtrTy get() const
Definition: Ownership.h:162
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2616
TagKind getTagKind() const
Definition: Decl.h:3156
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:424
A convenient class for passing around template argument information.
Definition: TemplateBase.h:546
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
Look up all declarations in a scope with the given name, including resolved using declarations...
Definition: Sema.h:3018
bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target, const LookupResult &PreviousDecls, UsingShadowDecl *&PrevShadow)
Determines whether to create a using shadow decl for a particular decl, given the set of decls existi...
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3226
void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDecl, ArrayRef< Decl *> Elements, Scope *S, AttributeList *Attr)
Definition: SemaDecl.cpp:15727
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Definition: DeclTemplate.h:878
ArrayRef< NamedDecl * > chain() const
Definition: Decl.h:2733
bool InitFunctionInstantiation(FunctionDecl *New, FunctionDecl *Tmpl)
Initializes the common fields of an instantiation function declaration (New) from the corresponding f...
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:2377
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack)
void PerformPendingInstantiations(bool LocalOnly=false)
Performs template instantiation for all implicit template instantiations we have seen until this poin...
SourceLocation RAngleLoc
The source location of the right angle bracket (&#39;>&#39;).
Definition: TemplateBase.h:609
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:745
SourceLocation getDefaultArgumentLoc() const
Retrieves the location of the default argument declaration.
void setInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *PartialSpec)
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1366
const TemplateArgumentLoc * getArgumentArray() const
Definition: TemplateBase.h:570
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
void setSpecializationKind(TemplateSpecializationKind TSK)
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:705
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1153
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type...
Definition: Decl.h:3183
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
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:820
bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New)
Definition: SemaDecl.cpp:2071
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1869
const LangOptions & getLangOpts() const
Definition: Sema.h:1193
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Definition: DeclCXX.cpp:2362
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:1661
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:748
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
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:3204
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:429
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1716
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3375
A binding in a decomposition declaration.
Definition: DeclCXX.h:3718
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization, retrieves the member specialization information.
Definition: Decl.cpp:3211
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
Ordinary names.
Definition: DeclBase.h:144
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, bool isConstexprSpecified=false)
Definition: Decl.h:1881
RAII object used to change the argument pack substitution index within a Sema object.
Definition: Sema.h:7230
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Whether this is an anonymous struct or union.
Definition: Decl.h:3556
void AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E, unsigned SpellingListIndex, bool IsPackExpansion)
AddAlignedAttr - Adds an aligned attribute to a particular declaration.
UsingShadowDecl * BuildUsingShadowDecl(Scope *S, UsingDecl *UD, NamedDecl *Target, UsingShadowDecl *PrevDecl)
Builds a shadow declaration corresponding to a &#39;using&#39; declaration.
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given function from its template.
A helper class for building up ExtParameterInfos.
Definition: Sema.h:7594
VarDecl * ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D)
Initialize declare reduction construct initializer.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1536
SourceLocation getRParenLoc() const
Definition: DeclCXX.h:3700
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1197
NodeId Parent
Definition: ASTDiff.cpp:192
void BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar, const MultiLevelTemplateArgumentList &TemplateArgs, LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner, LocalInstantiationScope *StartingScope, bool InstantiatingVarTemplate=false)
BuildVariableInstantiation - Used after a new variable has been created.
bool hasAttr() const
Definition: DeclBase.h:535
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:274
TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x alias-declaration.
Definition: Decl.h:2918
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1590
void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3268
bool isUsableInConstantExpressions(ASTContext &C) const
Determine whether this variable&#39;s value can be used in a constant expression, according to the releva...
Definition: Decl.cpp:2165
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2787
SourceLocation getTypenameLoc() const
Returns the source location of the &#39;typename&#39; keyword.
Definition: DeclCXX.h:3622
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1386
bool inferObjCARCLifetime(ValueDecl *decl)
Definition: SemaDecl.cpp:5839
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:680
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:540
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...
static QualType adjustFunctionTypeForInstantiation(ASTContext &Context, FunctionDecl *D, TypeSourceInfo *TInfo)
Adjust the given function type for an instantiation of the given declaration, to cope with modificati...
unsigned getNumSubstitutedLevels() const
Determine the number of substituted levels in this template argument list.
Definition: Template.h:72
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
FunctionDecl * getClassScopeSpecializationPattern() const
Retrieve the class scope template pattern that this function template specialization is instantiated ...
Definition: Decl.cpp:3336
bool isInlineSpecified() const
Definition: Decl.h:1351
Expr * getCombiner()
Get combiner expression of the declare reduction construct.
Definition: DeclOpenMP.h:147
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.
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:2847
void AddAlignValueAttr(SourceRange AttrRange, Decl *D, Expr *E, unsigned SpellingListIndex)
AddAlignValueAttr - Adds an align_value attribute to a particular declaration.
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, bool isImplicitlyDeclared)
Definition: DeclCXX.cpp:2196
const ArgList & getInnermost() const
Retrieve the innermost template argument list.
Definition: Template.h:132
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.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2241
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3163
Expr - This represents one expression.
Definition: Expr.h:106
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3315
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
unsigned getChainingSize() const
Definition: Decl.h:2739
SourceLocation getAliasLoc() const
Returns the location of the alias name, i.e.
Definition: DeclCXX.h:3033
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)
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2012
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3420
void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Pattern, Decl *Inst, LateInstantiatedAttrVec *LateAttrs=nullptr, LocalInstantiationScope *OuterMostScope=nullptr)
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner)
Finish current declare reduction construct initializer.
const FunctionProtoType * T
StateNode * Previous
Declaration of a template type parameter.
OMPThreadPrivateDecl * CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef< Expr *> VarList)
Builds a new OpenMPThreadPrivateDecl and checks its correctness.
ClassTemplatePartialSpecializationDecl * InstantiateClassTemplatePartialSpecialization(ClassTemplateDecl *ClassTemplate, ClassTemplatePartialSpecializationDecl *PartialSpec)
Instantiate the declaration of a class template partial specialization.
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3322
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
Definition: TemplateBase.h:612
void setHideTags(bool Hide)
Sets whether tag declarations should be hidden by non-tag declarations during resolution.
Definition: Lookup.h:300
void PerformDependentDiagnostics(const DeclContext *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
OMPDeclareReductionDecl * getPrevDeclInScope()
Get reference to previous declare reduction construct in the same scope with the same name...
Definition: DeclOpenMP.cpp:76
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6368
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
Definition: Sema.h:7363
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:86
static DeclT * getPreviousDeclForInstantiation(DeclT *D)
Get the previous declaration of a declaration for the purposes of template instantiation.
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2620
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:1973
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:551
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
bool isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD, bool AllowParamOrMoveConstructible)
Definition: SemaStmt.cpp:2888
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:1052
bool isFileContext() const
Definition: DeclBase.h:1401
TemplateParameterList * getTemplateParameterList(unsigned index) const
Definition: Decl.h:756
ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, Optional< unsigned > NumExpansions, bool ExpectParameterPack)
DeclContext * getDeclContext()
Definition: DeclBase.h:425
void CheckAlignasUnderalignment(Decl *D)
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:731
UsingShadowDecl * getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst)
SourceLocation getEllipsisLoc() const
Definition: TypeLoc.h:2238
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2237
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:264
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
Represents the type decltype(expr) (C++11).
Definition: Type.h:3852
bool CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous)
Perform semantic analysis for the given function template specialization.
EnumDecl * getDefinition() const
Definition: Decl.h:3309
static void InstantiateDefaultCtorDefaultArgs(Sema &S, CXXConstructorDecl *Ctor)
In the MS ABI, we need to instantiate default arguments of dllexported default constructors along wit...
Defines the clang::TypeLoc interface and its subclasses.
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
Definition: Decl.cpp:3399
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:13788
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.h:1956
void setConstexpr(bool IC)
Definition: Decl.h:1369
FieldDecl * CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitfieldWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D=nullptr)
Build a new FieldDecl and check its well-formedness.
Definition: SemaDecl.cpp:14382
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
bool isFunctionOrMethod() const
Definition: DeclBase.h:1384
StorageClass
Storage classes.
Definition: Specifiers.h:203
IdentifierInfo * getSetterId() const
Definition: DeclCXX.h:3858
Declaration of an alias template.
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > & getPartialSpecializations()
Retrieve the set of partial specializations of this class template.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1335
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:42
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc)
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
QualType getRecordType(const RecordDecl *Decl) const
bool isInvalid() const
Definition: Ownership.h:158
SourceLocation getEnd() const
unsigned getNumExpansionTemplateParameters() const
Retrieves the number of expansion template parameters in an expanded parameter pack.
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:1333
void setLocation(SourceLocation L)
Definition: DeclBase.h:417
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1041
NamedDecl * getInstantiatedFromUsingDecl(NamedDecl *Inst)
If the given using decl Inst is an instantiation of a (possibly unresolved) using decl from a templat...
Represents a C++ deduction guide declaration.
Definition: DeclCXX.h:1911
void setDescribedClassTemplate(ClassTemplateDecl *Template)
Definition: DeclCXX.cpp:1382
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2682
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:1347
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:149
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
InitializationStyle getInitStyle() const
The style of initialization for this declaration.
Definition: Decl.h:1271
static StringRef getIdentifier(const Token &Tok)
static void instantiateOMPDeclareSimdDeclAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const OMPDeclareSimdDeclAttr &Attr, Decl *New)
Instantiation of &#39;declare simd&#39; attribute and its arguments.
static void instantiateDependentModeAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const ModeAttr &Attr, Decl *New)
DeclContext * FindInstantiatedContext(SourceLocation Loc, DeclContext *DC, const MultiLevelTemplateArgumentList &TemplateArgs)
Finds the instantiation of the given declaration context within the current instantiation.
TypeSourceInfo * SubstFunctionType(FunctionDecl *D, SmallVectorImpl< ParmVarDecl *> &Params)
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:1977
NamedDecl * FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, bool FindingInstantiatedContext=false)
Find the instantiation of the given declaration within the current instantiation. ...
bool isDirectInit() const
Whether the initializer is a direct-initializer (list or call).
Definition: Decl.h:1276
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1102
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:220
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:122
AttrVec & getAttrs()
Definition: DeclBase.h:477
Attr * instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
bool hasAttrs() const
Definition: DeclBase.h:471
ClassTemplateDecl * getInstantiatedFromMemberTemplate() const
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
Definition: Decl.cpp:3894
RecordDecl * getDecl() const
Definition: Type.h:3986
TypeSourceInfo * getExpansionTypeSourceInfo(unsigned I) const
Retrieve a particular expansion type source info within an expanded parameter pack.
void addAttr(Attr *A)
Definition: DeclBase.h:484
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:408
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: Decl.cpp:3941
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1708
TypeLoc getPatternLoc() const
Definition: TypeLoc.h:2254
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:144
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3365
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1196
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:208
A stack object to be created when performing template instantiation.
Definition: Sema.h:7267
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3500
Attr * instantiateTemplateAttributeForDecl(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, ArrayRef< TemplateArgument > Args, ClassTemplateSpecializationDecl *PrevDecl)
bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, TemplateArgumentListInfo &Result, const MultiLevelTemplateArgumentList &TemplateArgs)
ClassTemplatePartialSpecializationDecl * findPartialSpecInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *D)
Find a class template partial specialization which was instantiated from the given member partial spe...
ASTContext & getASTContext() const
Definition: Sema.h:1200
static FriendDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, FriendUnion Friend_, SourceLocation FriendL, ArrayRef< TemplateParameterList *> FriendTypeTPLists=None)
Definition: DeclFriend.cpp:35
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, AttributeList *AttrList, bool IsInstantiation)
Builds a using declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:299
bool isParameterPack() const
Returns whether this is a parameter pack.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Encodes a location in the source.
QualType getReturnType() const
Definition: Type.h:3201
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:1996
bool duplicatesAllowed() const
By default, attributes cannot be duplicated when being merged; however, an attribute can override thi...
Definition: Attr.h:116
bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange)
Mark the given method pure.
This represents &#39;#pragma omp declare reduction ...&#39; directive.
Definition: DeclOpenMP.h:102
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1335
Pseudo declaration for capturing expressions.
Definition: DeclOpenMP.h:187
static bool isInstantiationOfUnresolvedUsingDecl(T *Pattern, Decl *Other, ASTContext &Ctx)
Decl * BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, StringLiteral *AssertMessageExpr, SourceLocation RParenLoc, bool Failed)
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1874
Attr * clone(ASTContext &C) const
SourceLocation getNamespaceKeyLocation() const
Returns the location of the namespace keyword.
Definition: DeclCXX.h:2918
unsigned getManglingNumber(const NamedDecl *ND) const
void setExternLoc(SourceLocation Loc)
Sets the location of the extern keyword.
DeclarationName getName() const
getName - Returns the embedded declaration name.
bool wasDeclaredWithTypename() const
Whether this template type parameter was declared with the &#39;typename&#39; keyword.
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2944
SourceLocation getUsingLoc() const
Return the source location of the &#39;using&#39; keyword.
Definition: DeclCXX.h:3308
const TemplateArgumentListInfo & templateArgs() const
TemplateParameterList * SubstTemplateParams(TemplateParameterList *List)
Instantiates a nested template parameter list in the current instantiation context.
void setReferenced(bool R=true)
Definition: DeclBase.h:581
LabelDecl - Represents the declaration of a label.
Definition: Decl.h:459
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3494
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1964
TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)
SourceLocation getFriendLoc() const
Retrieves the location of the &#39;friend&#39; keyword.
Definition: DeclFriend.h:144
static bool isInstantiationOf(ClassTemplateDecl *Pattern, ClassTemplateDecl *Instance)
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3529
EnumDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.h:3287
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
SourceLocation getIdentLocation() const
Returns the location of this using declaration&#39;s identifier.
Definition: DeclCXX.h:2921
bool isMemberSpecialization()
Determines whether this variable template partial specialization was a specialization of a member par...
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2190
static void instantiateDependentAlignValueAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const AlignValueAttr *Aligned, Decl *New)
SourceLocation getLocation() const
Definition: Attr.h:91
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Definition: DeclCXX.h:2888
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template...
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3415
void setDeclName(DeclarationName N)
Set the name of this declaration.
Definition: Decl.h:294
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:149
const TemplateArgumentListInfo & getTemplateArgsInfo() const
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
FunctionTemplateDecl * getPreviousDecl()
Retrieve the previous declaration of this function template, or nullptr if no such declaration exists...
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:694
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:691
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:399
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:161
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:146
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Previous)
Checks that the given using declaration is not an invalid redeclaration.
static bool DeclContainsAttr(const Decl *D, const Attr *NewAttr)
SourceLocation getRAngleLoc() const
Definition: TypeLoc.h:1641
TypeSourceInfo * getTypeAsWritten() const
Gets the type of this specialization as it was written by the user, if it was so written.
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:2017
DeclarationNameInfo getNameInfo() const
Definition: Decl.h:1907
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3669
void setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec)
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
Optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
Definition: Type.h:5025
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:565
SourceLocation getAccessSpecifierLoc() const
The location of the access specifier.
Definition: DeclCXX.h:147
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:586
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:80
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:1864
bool isTemplateTypeParmType() const
Definition: Type.h:6132
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3524
void setVirtualAsWritten(bool V)
Definition: Decl.h:1992
Represents a pack expansion of types.
Definition: Type.h:4994
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4379
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:3204
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments.
Definition: TemplateBase.h:615
ddiag_range ddiags() const
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:2415
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2802
Represents a template argument.
Definition: TemplateBase.h:51
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument. ...
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
static bool isInvalid(LocType Loc, bool *Invalid)
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
Definition: DeclCXX.cpp:2288
bool isNull() const
Determine whether this template name is NULL.
static bool addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function, const FunctionDecl *PatternDecl, LocalInstantiationScope &Scope, const MultiLevelTemplateArgumentList &TemplateArgs)
Introduce the instantiated function parameters into the local instantiation scope, and set the parameter names to those used in the template.
Dataflow Directional Tag Classes.
void setImplicitlyInline()
Flag that this function is implicitly inline.
Definition: Decl.h:2250
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
Definition: Sema.h:7224
ExtInfo getExtInfo() const
Definition: Type.h:3212
Decl * VisitFunctionDecl(FunctionDecl *D, TemplateParameterList *TemplateParams)
Normal class members are of more specific types and therefore don&#39;t make it here. ...
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
Definition: SemaDecl.cpp:11662
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:493
not evaluated yet, for special member function
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
Definition: Decl.h:2000
LocalInstantiationScope * cloneScopes(LocalInstantiationScope *Outermost)
Clone this scope, and all outer scopes, down to the given outermost scope.
Definition: Template.h:298
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1256
void InstantiateVariableInitializer(VarDecl *Var, VarDecl *OldVar, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the initializer of a variable.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3430
bool isRecord() const
Definition: DeclBase.h:1409
attr_range attrs() const
Definition: DeclBase.h:494
bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy, bool EnumUnderlyingIsImplicit, const EnumDecl *Prev)
Check whether this is a valid redeclaration of a previous enumeration.
Definition: SemaDecl.cpp:12824
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2711
QualType getUnderlyingType() const
Definition: Decl.h:2853
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Definition: DeclCXX.h:3011
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1006
DeclContext * getCommonAncestor()
Returns the common ancestor context of this using-directive and its nominated namespace.
Definition: DeclCXX.h:2910
const Expr * getInit() const
Definition: Decl.h:1212
AccessSpecifier getAccess() const
Definition: DeclBase.h:460
static NamedDecl * findInstantiationOf(ASTContext &Ctx, NamedDecl *D, ForwardIterator first, ForwardIterator last)
A decomposition declaration.
Definition: DeclCXX.h:3766
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:157
unsigned getIndex() const
Retrieve the index of the template parameter.
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3590
FunctionDecl * getTemplateInstantiationPattern() const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:3286
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:2267
DeclarationName - The name of a declaration.
void setInstantiationIsPending(bool IC)
Definition: Decl.h:2052
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2085
Kind getKind() const
Definition: DeclBase.h:419
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:1357
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:731
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:752
EnumDecl - Represents an enum.
Definition: Decl.h:3239
SourceLocation LAngleLoc
The source location of the left angle bracket (&#39;<&#39;).
Definition: TemplateBase.h:606
void setInlineSpecified()
Definition: Decl.h:1355
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:143
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid)
Called at the end of &#39;#pragma omp declare reduction&#39;.
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1375
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
void setPreviousDeclInSameBlockScope(bool Same)
Definition: Decl.h:1390
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
Definition: Decl.cpp:3808
VarTemplateSpecializationDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
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:6238
static LabelDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II)
Definition: Decl.cpp:4174
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:1063
void setInitCapture(bool IC)
Definition: Decl.h:1378
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it&#39;s a function-local extern declaration...
Definition: DeclBase.h:1034
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:150
void setImplicitlyInline()
Definition: Decl.h:1360
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
Definition: Type.h:3379
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3976
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
Definition: DeclBase.h:566
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:3771
void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD)
Definition: DeclTemplate.h:929
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:153
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant...
Definition: Expr.cpp:2753
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
Definition: DeclBase.h:1111
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)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:1722
T * getAttr() const
Definition: DeclBase.h:531
EnumConstantDecl * CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *val)
Definition: SemaDecl.cpp:15258
bool isFunctionType() const
Definition: Type.h:5938
void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer, VarDecl *OmpPrivParm)
Finish current declare reduction construct initializer.
void setInstantiationOfStaticDataMember(VarDecl *VD, TemplateSpecializationKind TSK)
Specify that this variable is an instantiation of the static data member VD.
Definition: Decl.cpp:2444
static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl, const MultiLevelTemplateArgumentList &TemplateArgs)
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:707
DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc, TypeResult ParsedType)
Check if the specified type is allowed to be used in &#39;omp declare reduction&#39; construct.
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInline, bool isConstexpr, SourceLocation EndLocation)
Definition: DeclCXX.cpp:1696
void setCXXForRangeDecl(bool FRD)
Definition: Decl.h:1330
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1425
void setInstantiationOfMemberClass(CXXRecordDecl *RD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member class RD.
Definition: DeclCXX.cpp:1369
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
The template argument is actually a parameter pack.
Definition: TemplateBase.h:91
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
Definition: Type.cpp:3041
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
bool hasTypename() const
Return true if the using declaration has &#39;typename&#39;.
Definition: DeclCXX.h:3330
void setInnerLocStart(SourceLocation L)
Definition: Decl.h:723
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
Definition: DeclCXX.cpp:2575
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2257
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
RedeclarationKind forRedeclarationInCurContext()
Definition: Sema.h:3052
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:2174
bool isAlreadyInstantiating() const
Determine whether we are already instantiating this specialization in some surrounding active instant...
Definition: Sema.h:7367
A template argument list.
Definition: DeclTemplate.h:210
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:239
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
shadow_range shadows() const
Definition: DeclCXX.h:3375
QualType getParamType(unsigned i) const
Definition: Type.h:3491
Call-style initialization (C++98)
Definition: Decl.h:814
Represents a field declaration created by an @defs(...).
Definition: DeclObjC.h:2031
QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI, SourceLocation Loc)
Check that the type of a non-type template parameter is well-formed.
void CheckOverrideControl(NamedDecl *D)
CheckOverrideControl - Check C++11 override control semantics.
void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in.
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3187
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization)
Perform semantic checking of a new function declaration.
Definition: SemaDecl.cpp:9134
bool isMutable() const
isMutable - Determines whether this field is mutable (C++ only).
Definition: Decl.h:2542
bool isThisDeclarationADefinition() const
isThisDeclarationADefinition() - Return true if this declaration is a completion definition of the ty...
Definition: Decl.h:3091
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
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:2370
void setTSCSpec(ThreadStorageClassSpecifier TSC)
Definition: Decl.h:1014
bool isNRVOVariable() const
Determine whether this local variable can be used with the named return value optimization (NRVO)...
Definition: Decl.h:1317
void setDescribedVarTemplate(VarTemplateDecl *Template)
Definition: Decl.cpp:2402
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:2140
VarTemplateSpecializationDecl * CompleteVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiates a variable template specialization by completing it with appropriate type information an...
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
Definition: DeclBase.cpp:1399
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4327
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:607
ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:328
void AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads, Expr *MinBlocks, unsigned SpellingListIndex)
AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular declaration. ...
void setUnsupportedFriend(bool Unsupported)
Definition: DeclFriend.h:178
bool isFailed() const
Definition: DeclCXX.h:3698
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
Definition: DeclCXX.cpp:2466
static VarTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, VarDecl *Decl)
Create a variable template node.
Declaration of a class template.
SourceManager & getSourceManager() const
Definition: Sema.h:1198
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
static bool isInstantiationOfStaticDataMember(VarDecl *Pattern, VarDecl *Instance)
void AddAllocAlignAttr(SourceRange AttrRange, Decl *D, Expr *ParamExpr, unsigned SpellingListIndex)
AddAllocAlignAttr - Adds an alloc_align attribute to a particular declaration.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
VarTemplateDecl * getInstantiatedFromMemberTemplate() const
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3509
QualType getIntegerType() const
getIntegerType - Return the integer type this enum decl corresponds to.
Definition: Decl.h:3364
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
Definition: Decl.cpp:3230
Decl * SubstDecl(Decl *D, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs)
SourceLocation getLAngleLoc() const
Definition: TemplateBase.h:562
FriendDecl * CheckFriendTypeDecl(SourceLocation LocStart, SourceLocation FriendLoc, TypeSourceInfo *TSInfo)
Perform semantic analysis of the given friend type declaration.
CanQualType IntTy
Definition: ASTContext.h:1004
static OpaquePtr make(QualType P)
Definition: Ownership.h:54
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:230
TranslationUnitDecl - The top declaration context.
Definition: Decl.h:107
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1858
Optional< unsigned > getNumArgumentsInExpansion(QualType T, const MultiLevelTemplateArgumentList &TemplateArgs)
Determine the number of arguments in the given pack expansion type.
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2077
SourceLocation getTemplateNameLoc() const
Definition: TemplateBase.h:532
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
Definition: Decl.cpp:1980
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.
varlist_range varlists()
Definition: DeclOpenMP.h:77
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1126
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:3835
SourceLocation getNamespaceLoc() const
Returns the location of the namespace keyword.
Definition: DeclCXX.h:3036
static bool isPotentialConstantExprUnevaluated(Expr *E, const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExprUnevaluted - Return true if this expression might be usable in a constant expr...
QualType getType() const
Definition: Decl.h:638
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:342
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:301
ASTContext & Context
Definition: Sema.h:316
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2845
NamedDecl - This represents a decl with a name.
Definition: Decl.h:245
FunctionDecl * getExceptionSpecTemplate() const
If this function type has an uninstantiated exception specification, this is the function whose excep...
Definition: Type.h:3597
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:75
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:455
Represents a C++ namespace alias.
Definition: DeclCXX.h:2947
bool isInline() const
Whether this variable is (C++1z) inline.
Definition: Decl.h:1348
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:281
Declaration of a friend template.
VarTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member variable template partial specialization from which this particular variable temp...
ArrayRef< NamedDecl * > expansions() const
Get the set of using declarations that this pack expanded into.
Definition: DeclCXX.h:3461
Represents C++ using-directive.
Definition: DeclCXX.h:2843
Represents a #pragma detect_mismatch line.
Definition: Decl.h:173
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user.
SourceLocation getRAngleLoc() const
Definition: TemplateBase.h:563
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
attr::Kind getKind() const
Definition: Attr.h:84
bool SubstParmTypes(SourceLocation Loc, ArrayRef< ParmVarDecl *> Params, const FunctionProtoType::ExtParameterInfo *ExtParamInfos, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< QualType > &ParamTypes, SmallVectorImpl< ParmVarDecl *> *OutParams, ExtParameterInfoBuilder &ParamInfos)
Substitute the given template arguments into the given set of parameters, producing the set of parame...
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:2910
void setType(QualType newType)
Definition: Decl.h:639
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isExplicit, bool isInline, bool isImplicitlyDeclared, bool isConstexpr, InheritedConstructor Inherited=InheritedConstructor())
Definition: DeclCXX.cpp:2057
bool hasInit() const
Definition: Decl.cpp:2115
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:176
SourceLocation getInnerLocStart() const
getInnerLocStart - Return SourceLocation representing start of source range ignoring outer template d...
Definition: Decl.h:722
bool InitMethodInstantiation(CXXMethodDecl *New, CXXMethodDecl *Tmpl)
Initializes common fields of an instantiated method declaration (New) from the corresponding fields o...
bool isParameterPack() const
Determine whether this parameter is actually a function parameter pack.
Definition: Decl.cpp:2549
void setDeletedAsWritten(bool D=true)
Definition: Decl.h:2079
Decl * VisitCXXMethodDecl(CXXMethodDecl *D, TemplateParameterList *TemplateParams, bool IsClassScopeSpecialization=false)
This represents &#39;#pragma omp threadprivate ...&#39; directive.
Definition: DeclOpenMP.h:39
bool isUnsupportedFriend() const
Determines if this friend kind is unsupported.
Definition: DeclFriend.h:175
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3393
Declaration of a template function.
Definition: DeclTemplate.h:967
void clear()
Clears out any current state.
Definition: Lookup.h:557
bool hasLinkage() const
Determine whether this declaration has linkage.
Definition: Decl.cpp:1671
Attr - This represents one attribute.
Definition: Attr.h:43
bool isDeletedAsWritten() const
Definition: Decl.h:2078
SourceLocation getLocation() const
Definition: DeclBase.h:416
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3066
Represents a pack of using declarations that a single using-declarator pack-expanded into...
Definition: DeclCXX.h:3425
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > & getPartialSpecializations()
Retrieve the set of partial specializations of this class template.
decl_iterator decls_end() const
Definition: DeclBase.h:1582
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1689
A RAII object to temporarily push a declaration context.
Definition: Sema.h:705
void DiagnoseUnusedNestedTypedefs(const RecordDecl *D)
Definition: SemaDecl.cpp:1752