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