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