clang  3.7.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"
22 #include "clang/Sema/Lookup.h"
24 #include "clang/Sema/Template.h"
25 
26 using namespace clang;
27 
28 static bool isDeclWithinFunction(const Decl *D) {
29  const DeclContext *DC = D->getDeclContext();
30  if (DC->isFunctionOrMethod())
31  return true;
32 
33  if (DC->isRecord())
34  return cast<CXXRecordDecl>(DC)->isLocalClass();
35 
36  return false;
37 }
38 
39 template<typename DeclT>
40 static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl,
41  const MultiLevelTemplateArgumentList &TemplateArgs) {
42  if (!OldDecl->getQualifierLoc())
43  return false;
44 
45  assert((NewDecl->getFriendObjectKind() ||
46  !OldDecl->getLexicalDeclContext()->isDependentContext()) &&
47  "non-friend with qualified name defined in dependent context");
48  Sema::ContextRAII SavedContext(
49  SemaRef,
50  const_cast<DeclContext *>(NewDecl->getFriendObjectKind()
51  ? NewDecl->getLexicalDeclContext()
52  : OldDecl->getLexicalDeclContext()));
53 
54  NestedNameSpecifierLoc NewQualifierLoc
55  = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
56  TemplateArgs);
57 
58  if (!NewQualifierLoc)
59  return true;
60 
61  NewDecl->setQualifierInfo(NewQualifierLoc);
62  return false;
63 }
64 
66  DeclaratorDecl *NewDecl) {
67  return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
68 }
69 
71  TagDecl *NewDecl) {
72  return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
73 }
74 
75 // Include attribute instantiation code.
76 #include "clang/Sema/AttrTemplateInstantiate.inc"
77 
79  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
80  const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion) {
81  if (Aligned->isAlignmentExpr()) {
82  // The alignment expression is a constant expression.
84  ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs);
85  if (!Result.isInvalid())
86  S.AddAlignedAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
87  Aligned->getSpellingListIndex(), IsPackExpansion);
88  } else {
89  TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(),
90  TemplateArgs, Aligned->getLocation(),
91  DeclarationName());
92  if (Result)
93  S.AddAlignedAttr(Aligned->getLocation(), New, Result,
94  Aligned->getSpellingListIndex(), IsPackExpansion);
95  }
96 }
97 
99  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
100  const AlignedAttr *Aligned, Decl *New) {
101  if (!Aligned->isPackExpansion()) {
102  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
103  return;
104  }
105 
107  if (Aligned->isAlignmentExpr())
108  S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(),
109  Unexpanded);
110  else
111  S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(),
112  Unexpanded);
113  assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
114 
115  // Determine whether we can expand this attribute pack yet.
116  bool Expand = true, RetainExpansion = false;
117  Optional<unsigned> NumExpansions;
118  // FIXME: Use the actual location of the ellipsis.
119  SourceLocation EllipsisLoc = Aligned->getLocation();
120  if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(),
121  Unexpanded, TemplateArgs, Expand,
122  RetainExpansion, NumExpansions))
123  return;
124 
125  if (!Expand) {
126  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1);
127  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true);
128  } else {
129  for (unsigned I = 0; I != *NumExpansions; ++I) {
131  instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
132  }
133  }
134 }
135 
137  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
138  const AssumeAlignedAttr *Aligned, Decl *New) {
139  // The alignment expression is a constant expression.
141 
142  Expr *E, *OE = nullptr;
143  ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
144  if (Result.isInvalid())
145  return;
146  E = Result.getAs<Expr>();
147 
148  if (Aligned->getOffset()) {
149  Result = S.SubstExpr(Aligned->getOffset(), TemplateArgs);
150  if (Result.isInvalid())
151  return;
152  OE = Result.getAs<Expr>();
153  }
154 
155  S.AddAssumeAlignedAttr(Aligned->getLocation(), New, E, OE,
156  Aligned->getSpellingListIndex());
157 }
158 
160  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
161  const AlignValueAttr *Aligned, Decl *New) {
162  // The alignment expression is a constant expression.
164  ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
165  if (!Result.isInvalid())
166  S.AddAlignValueAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
167  Aligned->getSpellingListIndex());
168 }
169 
171  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
172  const EnableIfAttr *A, const Decl *Tmpl, Decl *New) {
173  Expr *Cond = nullptr;
174  {
176  ExprResult Result = S.SubstExpr(A->getCond(), TemplateArgs);
177  if (Result.isInvalid())
178  return;
179  Cond = Result.getAs<Expr>();
180  }
181  if (A->getCond()->isTypeDependent() && !Cond->isTypeDependent()) {
182  ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
183  if (Converted.isInvalid())
184  return;
185  Cond = Converted.get();
186  }
187 
189  if (A->getCond()->isValueDependent() && !Cond->isValueDependent() &&
190  !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(Tmpl),
191  Diags)) {
192  S.Diag(A->getLocation(), diag::err_enable_if_never_constant_expr);
193  for (int I = 0, N = Diags.size(); I != N; ++I)
194  S.Diag(Diags[I].first, Diags[I].second);
195  return;
196  }
197 
198  EnableIfAttr *EIA = new (S.getASTContext())
199  EnableIfAttr(A->getLocation(), S.getASTContext(), Cond,
200  A->getMessage(),
201  A->getSpellingListIndex());
202  New->addAttr(EIA);
203 }
204 
205 // Constructs and adds to New a new instance of CUDALaunchBoundsAttr using
206 // template A as the base and arguments from TemplateArgs.
208  Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
209  const CUDALaunchBoundsAttr &Attr, Decl *New) {
210  // The alignment expression is a constant expression.
212 
213  ExprResult Result = S.SubstExpr(Attr.getMaxThreads(), TemplateArgs);
214  if (Result.isInvalid())
215  return;
216  Expr *MaxThreads = Result.getAs<Expr>();
217 
218  Expr *MinBlocks = nullptr;
219  if (Attr.getMinBlocks()) {
220  Result = S.SubstExpr(Attr.getMinBlocks(), TemplateArgs);
221  if (Result.isInvalid())
222  return;
223  MinBlocks = Result.getAs<Expr>();
224  }
225 
226  S.AddLaunchBoundsAttr(Attr.getLocation(), New, MaxThreads, MinBlocks,
227  Attr.getSpellingListIndex());
228 }
229 
231  const Decl *Tmpl, Decl *New,
232  LateInstantiatedAttrVec *LateAttrs,
233  LocalInstantiationScope *OuterMostScope) {
234  for (const auto *TmplAttr : Tmpl->attrs()) {
235  // FIXME: This should be generalized to more than just the AlignedAttr.
236  const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
237  if (Aligned && Aligned->isAlignmentDependent()) {
238  instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New);
239  continue;
240  }
241 
242  const AssumeAlignedAttr *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr);
243  if (AssumeAligned) {
244  instantiateDependentAssumeAlignedAttr(*this, TemplateArgs, AssumeAligned, New);
245  continue;
246  }
247 
248  const AlignValueAttr *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr);
249  if (AlignValue) {
250  instantiateDependentAlignValueAttr(*this, TemplateArgs, AlignValue, New);
251  continue;
252  }
253 
254  const EnableIfAttr *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr);
255  if (EnableIf && EnableIf->getCond()->isValueDependent()) {
256  instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl,
257  New);
258  continue;
259  }
260 
261  if (const CUDALaunchBoundsAttr *CUDALaunchBounds =
262  dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
263  instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs,
264  *CUDALaunchBounds, New);
265  continue;
266  }
267 
268  // Existing DLL attribute on the instantiation takes precedence.
269  if (TmplAttr->getKind() == attr::DLLExport ||
270  TmplAttr->getKind() == attr::DLLImport) {
271  if (New->hasAttr<DLLExportAttr>() || New->hasAttr<DLLImportAttr>()) {
272  continue;
273  }
274  }
275 
276  assert(!TmplAttr->isPackExpansion());
277  if (TmplAttr->isLateParsed() && LateAttrs) {
278  // Late parsed attributes must be instantiated and attached after the
279  // enclosing class has been instantiated. See Sema::InstantiateClass.
280  LocalInstantiationScope *Saved = nullptr;
282  Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope);
283  LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New));
284  } else {
285  // Allow 'this' within late-parsed attributes.
286  NamedDecl *ND = dyn_cast<NamedDecl>(New);
287  CXXRecordDecl *ThisContext =
288  dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
289  CXXThisScopeRAII ThisScope(*this, ThisContext, /*TypeQuals*/0,
290  ND && ND->isCXXInstanceMember());
291 
292  Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
293  *this, TemplateArgs);
294  if (NewAttr)
295  New->addAttr(NewAttr);
296  }
297  }
298 }
299 
300 /// Get the previous declaration of a declaration for the purposes of template
301 /// instantiation. If this finds a previous declaration, then the previous
302 /// declaration of the instantiation of D should be an instantiation of the
303 /// result of this function.
304 template<typename DeclT>
305 static DeclT *getPreviousDeclForInstantiation(DeclT *D) {
306  DeclT *Result = D->getPreviousDecl();
307 
308  // If the declaration is within a class, and the previous declaration was
309  // merged from a different definition of that class, then we don't have a
310  // previous declaration for the purpose of template instantiation.
311  if (Result && isa<CXXRecordDecl>(D->getDeclContext()) &&
312  D->getLexicalDeclContext() != Result->getLexicalDeclContext())
313  return nullptr;
314 
315  return Result;
316 }
317 
318 Decl *
319 TemplateDeclInstantiator::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
320  llvm_unreachable("Translation units cannot be instantiated");
321 }
322 
323 Decl *
324 TemplateDeclInstantiator::VisitExternCContextDecl(ExternCContextDecl *D) {
325  llvm_unreachable("extern \"C\" context cannot be instantiated");
326 }
327 
328 Decl *
329 TemplateDeclInstantiator::VisitLabelDecl(LabelDecl *D) {
330  LabelDecl *Inst = LabelDecl::Create(SemaRef.Context, Owner, D->getLocation(),
331  D->getIdentifier());
332  Owner->addDecl(Inst);
333  return Inst;
334 }
335 
336 Decl *
337 TemplateDeclInstantiator::VisitNamespaceDecl(NamespaceDecl *D) {
338  llvm_unreachable("Namespaces cannot be instantiated");
339 }
340 
341 Decl *
342 TemplateDeclInstantiator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
343  NamespaceAliasDecl *Inst
344  = NamespaceAliasDecl::Create(SemaRef.Context, Owner,
345  D->getNamespaceLoc(),
346  D->getAliasLoc(),
347  D->getIdentifier(),
348  D->getQualifierLoc(),
349  D->getTargetNameLoc(),
350  D->getNamespace());
351  Owner->addDecl(Inst);
352  return Inst;
353 }
354 
356  bool IsTypeAlias) {
357  bool Invalid = false;
359  if (DI->getType()->isInstantiationDependentType() ||
360  DI->getType()->isVariablyModifiedType()) {
361  DI = SemaRef.SubstType(DI, TemplateArgs,
362  D->getLocation(), D->getDeclName());
363  if (!DI) {
364  Invalid = true;
365  DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
366  }
367  } else {
369  }
370 
371  // HACK: g++ has a bug where it gets the value kind of ?: wrong.
372  // libstdc++ relies upon this bug in its implementation of common_type.
373  // If we happen to be processing that implementation, fake up the g++ ?:
374  // semantics. See LWG issue 2141 for more information on the bug.
375  const DecltypeType *DT = DI->getType()->getAs<DecltypeType>();
376  CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
377  if (DT && RD && isa<ConditionalOperator>(DT->getUnderlyingExpr()) &&
378  DT->isReferenceType() &&
379  RD->getEnclosingNamespaceContext() == SemaRef.getStdNamespace() &&
380  RD->getIdentifier() && RD->getIdentifier()->isStr("common_type") &&
381  D->getIdentifier() && D->getIdentifier()->isStr("type") &&
383  // Fold it to the (non-reference) type which g++ would have produced.
384  DI = SemaRef.Context.getTrivialTypeSourceInfo(
385  DI->getType().getNonReferenceType());
386 
387  // Create the new typedef
388  TypedefNameDecl *Typedef;
389  if (IsTypeAlias)
390  Typedef = TypeAliasDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
391  D->getLocation(), D->getIdentifier(), DI);
392  else
393  Typedef = TypedefDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
394  D->getLocation(), D->getIdentifier(), DI);
395  if (Invalid)
396  Typedef->setInvalidDecl();
397 
398  // If the old typedef was the name for linkage purposes of an anonymous
399  // tag decl, re-establish that relationship for the new typedef.
400  if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
401  TagDecl *oldTag = oldTagType->getDecl();
402  if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) {
403  TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
404  assert(!newTag->hasNameForLinkage());
405  newTag->setTypedefNameForAnonDecl(Typedef);
406  }
407  }
408 
410  NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
411  TemplateArgs);
412  if (!InstPrev)
413  return nullptr;
414 
415  TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev);
416 
417  // If the typedef types are not identical, reject them.
418  SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef);
419 
420  Typedef->setPreviousDecl(InstPrevTypedef);
421  }
422 
423  SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);
424 
425  Typedef->setAccess(D->getAccess());
426 
427  return Typedef;
428 }
429 
430 Decl *TemplateDeclInstantiator::VisitTypedefDecl(TypedefDecl *D) {
431  Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/false);
432  if (Typedef)
433  Owner->addDecl(Typedef);
434  return Typedef;
435 }
436 
437 Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
438  Decl *Typedef = InstantiateTypedefNameDecl(D, /*IsTypeAlias=*/true);
439  if (Typedef)
440  Owner->addDecl(Typedef);
441  return Typedef;
442 }
443 
444 Decl *
445 TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
446  // Create a local instantiation scope for this type alias template, which
447  // will contain the instantiations of the template parameters.
449 
450  TemplateParameterList *TempParams = D->getTemplateParameters();
451  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
452  if (!InstParams)
453  return nullptr;
454 
455  TypeAliasDecl *Pattern = D->getTemplatedDecl();
456 
457  TypeAliasTemplateDecl *PrevAliasTemplate = nullptr;
458  if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
459  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
460  if (!Found.empty()) {
461  PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front());
462  }
463  }
464 
465  TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
466  InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
467  if (!AliasInst)
468  return nullptr;
469 
471  = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
472  D->getDeclName(), InstParams, AliasInst);
473  AliasInst->setDescribedAliasTemplate(Inst);
474  if (PrevAliasTemplate)
475  Inst->setPreviousDecl(PrevAliasTemplate);
476 
477  Inst->setAccess(D->getAccess());
478 
479  if (!PrevAliasTemplate)
481 
482  Owner->addDecl(Inst);
483 
484  return Inst;
485 }
486 
488  return VisitVarDecl(D, /*InstantiatingVarTemplate=*/false);
489 }
490 
492  bool InstantiatingVarTemplate) {
493 
494  // If this is the variable for an anonymous struct or union,
495  // instantiate the anonymous struct/union type first.
496  if (const RecordType *RecordTy = D->getType()->getAs<RecordType>())
497  if (RecordTy->getDecl()->isAnonymousStructOrUnion())
498  if (!VisitCXXRecordDecl(cast<CXXRecordDecl>(RecordTy->getDecl())))
499  return nullptr;
500 
501  // Do substitution on the type of the declaration
502  TypeSourceInfo *DI = SemaRef.SubstType(D->getTypeSourceInfo(),
503  TemplateArgs,
504  D->getTypeSpecStartLoc(),
505  D->getDeclName());
506  if (!DI)
507  return nullptr;
508 
509  if (DI->getType()->isFunctionType()) {
510  SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
511  << D->isStaticDataMember() << DI->getType();
512  return nullptr;
513  }
514 
515  DeclContext *DC = Owner;
516  if (D->isLocalExternDecl())
518 
519  // Build the instantiated declaration.
520  VarDecl *Var = VarDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
521  D->getLocation(), D->getIdentifier(),
522  DI->getType(), DI, D->getStorageClass());
523 
524  // In ARC, infer 'retaining' for variables of retainable type.
525  if (SemaRef.getLangOpts().ObjCAutoRefCount &&
526  SemaRef.inferObjCARCLifetime(Var))
527  Var->setInvalidDecl();
528 
529  // Substitute the nested name specifier, if any.
530  if (SubstQualifier(D, Var))
531  return nullptr;
532 
533  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
534  StartingScope, InstantiatingVarTemplate);
535 
536  if (D->isNRVOVariable()) {
537  QualType ReturnType = cast<FunctionDecl>(DC)->getReturnType();
538  if (SemaRef.isCopyElisionCandidate(ReturnType, Var, false))
539  Var->setNRVOVariable(true);
540  }
541 
542  Var->setImplicit(D->isImplicit());
543 
544  return Var;
545 }
546 
547 Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
548  AccessSpecDecl* AD
549  = AccessSpecDecl::Create(SemaRef.Context, D->getAccess(), Owner,
551  Owner->addHiddenDecl(AD);
552  return AD;
553 }
554 
555 Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
556  bool Invalid = false;
558  if (DI->getType()->isInstantiationDependentType() ||
559  DI->getType()->isVariablyModifiedType()) {
560  DI = SemaRef.SubstType(DI, TemplateArgs,
561  D->getLocation(), D->getDeclName());
562  if (!DI) {
563  DI = D->getTypeSourceInfo();
564  Invalid = true;
565  } else if (DI->getType()->isFunctionType()) {
566  // C++ [temp.arg.type]p3:
567  // If a declaration acquires a function type through a type
568  // dependent on a template-parameter and this causes a
569  // declaration that does not use the syntactic form of a
570  // function declarator to have function type, the program is
571  // ill-formed.
572  SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
573  << DI->getType();
574  Invalid = true;
575  }
576  } else {
578  }
579 
580  Expr *BitWidth = D->getBitWidth();
581  if (Invalid)
582  BitWidth = nullptr;
583  else if (BitWidth) {
584  // The bit-width expression is a constant expression.
585  EnterExpressionEvaluationContext Unevaluated(SemaRef,
587 
588  ExprResult InstantiatedBitWidth
589  = SemaRef.SubstExpr(BitWidth, TemplateArgs);
590  if (InstantiatedBitWidth.isInvalid()) {
591  Invalid = true;
592  BitWidth = nullptr;
593  } else
594  BitWidth = InstantiatedBitWidth.getAs<Expr>();
595  }
596 
597  FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
598  DI->getType(), DI,
599  cast<RecordDecl>(Owner),
600  D->getLocation(),
601  D->isMutable(),
602  BitWidth,
603  D->getInClassInitStyle(),
604  D->getInnerLocStart(),
605  D->getAccess(),
606  nullptr);
607  if (!Field) {
608  cast<Decl>(Owner)->setInvalidDecl();
609  return nullptr;
610  }
611 
612  SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);
613 
614  if (Field->hasAttrs())
615  SemaRef.CheckAlignasUnderalignment(Field);
616 
617  if (Invalid)
618  Field->setInvalidDecl();
619 
620  if (!Field->getDeclName()) {
621  // Keep track of where this decl came from.
623  }
624  if (CXXRecordDecl *Parent= dyn_cast<CXXRecordDecl>(Field->getDeclContext())) {
625  if (Parent->isAnonymousStructOrUnion() &&
626  Parent->getRedeclContext()->isFunctionOrMethod())
627  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Field);
628  }
629 
630  Field->setImplicit(D->isImplicit());
631  Field->setAccess(D->getAccess());
632  Owner->addDecl(Field);
633 
634  return Field;
635 }
636 
637 Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) {
638  bool Invalid = false;
640 
641  if (DI->getType()->isVariablyModifiedType()) {
642  SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified)
643  << D;
644  Invalid = true;
645  } else if (DI->getType()->isInstantiationDependentType()) {
646  DI = SemaRef.SubstType(DI, TemplateArgs,
647  D->getLocation(), D->getDeclName());
648  if (!DI) {
649  DI = D->getTypeSourceInfo();
650  Invalid = true;
651  } else if (DI->getType()->isFunctionType()) {
652  // C++ [temp.arg.type]p3:
653  // If a declaration acquires a function type through a type
654  // dependent on a template-parameter and this causes a
655  // declaration that does not use the syntactic form of a
656  // function declarator to have function type, the program is
657  // ill-formed.
658  SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
659  << DI->getType();
660  Invalid = true;
661  }
662  } else {
664  }
665 
667  SemaRef.Context, Owner, D->getLocation(), D->getDeclName(), DI->getType(),
668  DI, D->getLocStart(), D->getGetterId(), D->getSetterId());
669 
670  SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs,
671  StartingScope);
672 
673  if (Invalid)
674  Property->setInvalidDecl();
675 
676  Property->setAccess(D->getAccess());
677  Owner->addDecl(Property);
678 
679  return Property;
680 }
681 
682 Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
683  NamedDecl **NamedChain =
684  new (SemaRef.Context)NamedDecl*[D->getChainingSize()];
685 
686  int i = 0;
687  for (auto *PI : D->chain()) {
688  NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), PI,
689  TemplateArgs);
690  if (!Next)
691  return nullptr;
692 
693  NamedChain[i++] = Next;
694  }
695 
696  QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
698  SemaRef.Context, Owner, D->getLocation(), D->getIdentifier(), T,
699  NamedChain, D->getChainingSize());
700 
701  for (const auto *Attr : D->attrs())
702  IndirectField->addAttr(Attr->clone(SemaRef.Context));
703 
704  IndirectField->setImplicit(D->isImplicit());
705  IndirectField->setAccess(D->getAccess());
706  Owner->addDecl(IndirectField);
707  return IndirectField;
708 }
709 
710 Decl *TemplateDeclInstantiator::VisitFriendDecl(FriendDecl *D) {
711  // Handle friend type expressions by simply substituting template
712  // parameters into the pattern type and checking the result.
713  if (TypeSourceInfo *Ty = D->getFriendType()) {
714  TypeSourceInfo *InstTy;
715  // If this is an unsupported friend, don't bother substituting template
716  // arguments into it. The actual type referred to won't be used by any
717  // parts of Clang, and may not be valid for instantiating. Just use the
718  // same info for the instantiated friend.
719  if (D->isUnsupportedFriend()) {
720  InstTy = Ty;
721  } else {
722  InstTy = SemaRef.SubstType(Ty, TemplateArgs,
723  D->getLocation(), DeclarationName());
724  }
725  if (!InstTy)
726  return nullptr;
727 
728  FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getLocStart(),
729  D->getFriendLoc(), InstTy);
730  if (!FD)
731  return nullptr;
732 
733  FD->setAccess(AS_public);
735  Owner->addDecl(FD);
736  return FD;
737  }
738 
739  NamedDecl *ND = D->getFriendDecl();
740  assert(ND && "friend decl must be a decl or a type!");
741 
742  // All of the Visit implementations for the various potential friend
743  // declarations have to be carefully written to work for friend
744  // objects, with the most important detail being that the target
745  // decl should almost certainly not be placed in Owner.
746  Decl *NewND = Visit(ND);
747  if (!NewND) return nullptr;
748 
749  FriendDecl *FD =
750  FriendDecl::Create(SemaRef.Context, Owner, D->getLocation(),
751  cast<NamedDecl>(NewND), D->getFriendLoc());
752  FD->setAccess(AS_public);
754  Owner->addDecl(FD);
755  return FD;
756 }
757 
758 Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
759  Expr *AssertExpr = D->getAssertExpr();
760 
761  // The expression in a static assertion is a constant expression.
762  EnterExpressionEvaluationContext Unevaluated(SemaRef,
764 
765  ExprResult InstantiatedAssertExpr
766  = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
767  if (InstantiatedAssertExpr.isInvalid())
768  return nullptr;
769 
770  return SemaRef.BuildStaticAssertDeclaration(D->getLocation(),
771  InstantiatedAssertExpr.get(),
772  D->getMessage(),
773  D->getRParenLoc(),
774  D->isFailed());
775 }
776 
777 Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
778  EnumDecl *PrevDecl = nullptr;
779  if (EnumDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
780  NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
781  PatternPrev,
782  TemplateArgs);
783  if (!Prev) return nullptr;
784  PrevDecl = cast<EnumDecl>(Prev);
785  }
786 
787  EnumDecl *Enum = EnumDecl::Create(SemaRef.Context, Owner, D->getLocStart(),
788  D->getLocation(), D->getIdentifier(),
789  PrevDecl, D->isScoped(),
790  D->isScopedUsingClassTag(), D->isFixed());
791  if (D->isFixed()) {
792  if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) {
793  // If we have type source information for the underlying type, it means it
794  // has been explicitly set by the user. Perform substitution on it before
795  // moving on.
796  SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
797  TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc,
798  DeclarationName());
799  if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI))
800  Enum->setIntegerType(SemaRef.Context.IntTy);
801  else
802  Enum->setIntegerTypeSourceInfo(NewTI);
803  } else {
804  assert(!D->getIntegerType()->isDependentType()
805  && "Dependent type without type source info");
806  Enum->setIntegerType(D->getIntegerType());
807  }
808  }
809 
810  SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);
811 
812  Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation);
813  Enum->setAccess(D->getAccess());
814  // Forward the mangling number from the template to the instantiated decl.
815  SemaRef.Context.setManglingNumber(Enum, SemaRef.Context.getManglingNumber(D));
816  if (SubstQualifier(D, Enum)) return nullptr;
817  Owner->addDecl(Enum);
818 
819  EnumDecl *Def = D->getDefinition();
820  if (Def && Def != D) {
821  // If this is an out-of-line definition of an enum member template, check
822  // that the underlying types match in the instantiation of both
823  // declarations.
824  if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) {
825  SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
826  QualType DefnUnderlying =
827  SemaRef.SubstType(TI->getType(), TemplateArgs,
828  UnderlyingLoc, DeclarationName());
829  SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(),
830  DefnUnderlying, Enum);
831  }
832  }
833 
834  // C++11 [temp.inst]p1: The implicit instantiation of a class template
835  // specialization causes the implicit instantiation of the declarations, but
836  // not the definitions of scoped member enumerations.
837  //
838  // DR1484 clarifies that enumeration definitions inside of a template
839  // declaration aren't considered entities that can be separately instantiated
840  // from the rest of the entity they are declared inside of.
841  if (isDeclWithinFunction(D) ? D == Def : Def && !Enum->isScoped()) {
843  InstantiateEnumDefinition(Enum, Def);
844  }
845 
846  return Enum;
847 }
848 
850  EnumDecl *Enum, EnumDecl *Pattern) {
851  Enum->startDefinition();
852 
853  // Update the location to refer to the definition.
854  Enum->setLocation(Pattern->getLocation());
855 
856  SmallVector<Decl*, 4> Enumerators;
857 
858  EnumConstantDecl *LastEnumConst = nullptr;
859  for (auto *EC : Pattern->enumerators()) {
860  // The specified value for the enumerator.
861  ExprResult Value((Expr *)nullptr);
862  if (Expr *UninstValue = EC->getInitExpr()) {
863  // The enumerator's value expression is a constant expression.
864  EnterExpressionEvaluationContext Unevaluated(SemaRef,
866 
867  Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
868  }
869 
870  // Drop the initial value and continue.
871  bool isInvalid = false;
872  if (Value.isInvalid()) {
873  Value = nullptr;
874  isInvalid = true;
875  }
876 
877  EnumConstantDecl *EnumConst
878  = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
879  EC->getLocation(), EC->getIdentifier(),
880  Value.get());
881 
882  if (isInvalid) {
883  if (EnumConst)
884  EnumConst->setInvalidDecl();
885  Enum->setInvalidDecl();
886  }
887 
888  if (EnumConst) {
889  SemaRef.InstantiateAttrs(TemplateArgs, EC, EnumConst);
890 
891  EnumConst->setAccess(Enum->getAccess());
892  Enum->addDecl(EnumConst);
893  Enumerators.push_back(EnumConst);
894  LastEnumConst = EnumConst;
895 
896  if (Pattern->getDeclContext()->isFunctionOrMethod() &&
897  !Enum->isScoped()) {
898  // If the enumeration is within a function or method, record the enum
899  // constant as a local.
900  SemaRef.CurrentInstantiationScope->InstantiatedLocal(EC, EnumConst);
901  }
902  }
903  }
904 
905  // FIXME: Fixup LBraceLoc
906  SemaRef.ActOnEnumBody(Enum->getLocation(), SourceLocation(),
907  Enum->getRBraceLoc(), Enum,
908  Enumerators,
909  nullptr, nullptr);
910 }
911 
912 Decl *TemplateDeclInstantiator::VisitEnumConstantDecl(EnumConstantDecl *D) {
913  llvm_unreachable("EnumConstantDecls can only occur within EnumDecls.");
914 }
915 
916 Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
917  bool isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
918 
919  // Create a local instantiation scope for this class template, which
920  // will contain the instantiations of the template parameters.
922  TemplateParameterList *TempParams = D->getTemplateParameters();
923  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
924  if (!InstParams)
925  return nullptr;
926 
927  CXXRecordDecl *Pattern = D->getTemplatedDecl();
928 
929  // Instantiate the qualifier. We have to do this first in case
930  // we're a friend declaration, because if we are then we need to put
931  // the new declaration in the appropriate context.
932  NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
933  if (QualifierLoc) {
934  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
935  TemplateArgs);
936  if (!QualifierLoc)
937  return nullptr;
938  }
939 
940  CXXRecordDecl *PrevDecl = nullptr;
941  ClassTemplateDecl *PrevClassTemplate = nullptr;
942 
943  if (!isFriend && getPreviousDeclForInstantiation(Pattern)) {
944  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
945  if (!Found.empty()) {
946  PrevClassTemplate = dyn_cast<ClassTemplateDecl>(Found.front());
947  if (PrevClassTemplate)
948  PrevDecl = PrevClassTemplate->getTemplatedDecl();
949  }
950  }
951 
952  // If this isn't a friend, then it's a member template, in which
953  // case we just want to build the instantiation in the
954  // specialization. If it is a friend, we want to build it in
955  // the appropriate context.
956  DeclContext *DC = Owner;
957  if (isFriend) {
958  if (QualifierLoc) {
959  CXXScopeSpec SS;
960  SS.Adopt(QualifierLoc);
961  DC = SemaRef.computeDeclContext(SS);
962  if (!DC) return nullptr;
963  } else {
964  DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
965  Pattern->getDeclContext(),
966  TemplateArgs);
967  }
968 
969  // Look for a previous declaration of the template in the owning
970  // context.
971  LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
973  SemaRef.LookupQualifiedName(R, DC);
974 
975  if (R.isSingleResult()) {
976  PrevClassTemplate = R.getAsSingle<ClassTemplateDecl>();
977  if (PrevClassTemplate)
978  PrevDecl = PrevClassTemplate->getTemplatedDecl();
979  }
980 
981  if (!PrevClassTemplate && QualifierLoc) {
982  SemaRef.Diag(Pattern->getLocation(), diag::err_not_tag_in_scope)
983  << D->getTemplatedDecl()->getTagKind() << Pattern->getDeclName() << DC
984  << QualifierLoc.getSourceRange();
985  return nullptr;
986  }
987 
988  bool AdoptedPreviousTemplateParams = false;
989  if (PrevClassTemplate) {
990  bool Complain = true;
991 
992  // HACK: libstdc++ 4.2.1 contains an ill-formed friend class
993  // template for struct std::tr1::__detail::_Map_base, where the
994  // template parameters of the friend declaration don't match the
995  // template parameters of the original declaration. In this one
996  // case, we don't complain about the ill-formed friend
997  // declaration.
998  if (isFriend && Pattern->getIdentifier() &&
999  Pattern->getIdentifier()->isStr("_Map_base") &&
1000  DC->isNamespace() &&
1001  cast<NamespaceDecl>(DC)->getIdentifier() &&
1002  cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__detail")) {
1003  DeclContext *DCParent = DC->getParent();
1004  if (DCParent->isNamespace() &&
1005  cast<NamespaceDecl>(DCParent)->getIdentifier() &&
1006  cast<NamespaceDecl>(DCParent)->getIdentifier()->isStr("tr1")) {
1007  if (cast<Decl>(DCParent)->isInStdNamespace())
1008  Complain = false;
1009  }
1010  }
1011 
1012  TemplateParameterList *PrevParams
1013  = PrevClassTemplate->getTemplateParameters();
1014 
1015  // Make sure the parameter lists match.
1016  if (!SemaRef.TemplateParameterListsAreEqual(InstParams, PrevParams,
1017  Complain,
1019  if (Complain)
1020  return nullptr;
1021 
1022  AdoptedPreviousTemplateParams = true;
1023  InstParams = PrevParams;
1024  }
1025 
1026  // Do some additional validation, then merge default arguments
1027  // from the existing declarations.
1028  if (!AdoptedPreviousTemplateParams &&
1029  SemaRef.CheckTemplateParameterList(InstParams, PrevParams,
1031  return nullptr;
1032  }
1033  }
1034 
1035  CXXRecordDecl *RecordInst
1036  = CXXRecordDecl::Create(SemaRef.Context, Pattern->getTagKind(), DC,
1037  Pattern->getLocStart(), Pattern->getLocation(),
1038  Pattern->getIdentifier(), PrevDecl,
1039  /*DelayTypeCreation=*/true);
1040 
1041  if (QualifierLoc)
1042  RecordInst->setQualifierInfo(QualifierLoc);
1043 
1044  ClassTemplateDecl *Inst
1045  = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
1046  D->getIdentifier(), InstParams, RecordInst,
1047  PrevClassTemplate);
1048  RecordInst->setDescribedClassTemplate(Inst);
1049 
1050  if (isFriend) {
1051  if (PrevClassTemplate)
1052  Inst->setAccess(PrevClassTemplate->getAccess());
1053  else
1054  Inst->setAccess(D->getAccess());
1055 
1056  Inst->setObjectOfFriendDecl();
1057  // TODO: do we want to track the instantiation progeny of this
1058  // friend target decl?
1059  } else {
1060  Inst->setAccess(D->getAccess());
1061  if (!PrevClassTemplate)
1063  }
1064 
1065  // Trigger creation of the type for the instantiation.
1066  SemaRef.Context.getInjectedClassNameType(RecordInst,
1068 
1069  // Finish handling of friends.
1070  if (isFriend) {
1071  DC->makeDeclVisibleInContext(Inst);
1072  Inst->setLexicalDeclContext(Owner);
1073  RecordInst->setLexicalDeclContext(Owner);
1074  return Inst;
1075  }
1076 
1077  if (D->isOutOfLine()) {
1079  RecordInst->setLexicalDeclContext(D->getLexicalDeclContext());
1080  }
1081 
1082  Owner->addDecl(Inst);
1083 
1084  if (!PrevClassTemplate) {
1085  // Queue up any out-of-line partial specializations of this member
1086  // class template; the client will force their instantiation once
1087  // the enclosing class has been instantiated.
1089  D->getPartialSpecializations(PartialSpecs);
1090  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1091  if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1092  OutOfLinePartialSpecs.push_back(std::make_pair(Inst, PartialSpecs[I]));
1093  }
1094 
1095  return Inst;
1096 }
1097 
1098 Decl *
1099 TemplateDeclInstantiator::VisitClassTemplatePartialSpecializationDecl(
1101  ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
1102 
1103  // Lookup the already-instantiated declaration in the instantiation
1104  // of the class template and return that.
1106  = Owner->lookup(ClassTemplate->getDeclName());
1107  if (Found.empty())
1108  return nullptr;
1109 
1110  ClassTemplateDecl *InstClassTemplate
1111  = dyn_cast<ClassTemplateDecl>(Found.front());
1112  if (!InstClassTemplate)
1113  return nullptr;
1114 
1116  = InstClassTemplate->findPartialSpecInstantiatedFromMember(D))
1117  return Result;
1118 
1119  return InstantiateClassTemplatePartialSpecialization(InstClassTemplate, D);
1120 }
1121 
1122 Decl *TemplateDeclInstantiator::VisitVarTemplateDecl(VarTemplateDecl *D) {
1123  assert(D->getTemplatedDecl()->isStaticDataMember() &&
1124  "Only static data member templates are allowed.");
1125 
1126  // Create a local instantiation scope for this variable template, which
1127  // will contain the instantiations of the template parameters.
1128  LocalInstantiationScope Scope(SemaRef);
1129  TemplateParameterList *TempParams = D->getTemplateParameters();
1130  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1131  if (!InstParams)
1132  return nullptr;
1133 
1134  VarDecl *Pattern = D->getTemplatedDecl();
1135  VarTemplateDecl *PrevVarTemplate = nullptr;
1136 
1137  if (getPreviousDeclForInstantiation(Pattern)) {
1138  DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
1139  if (!Found.empty())
1140  PrevVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1141  }
1142 
1143  VarDecl *VarInst =
1144  cast_or_null<VarDecl>(VisitVarDecl(Pattern,
1145  /*InstantiatingVarTemplate=*/true));
1146 
1147  DeclContext *DC = Owner;
1148 
1150  SemaRef.Context, DC, D->getLocation(), D->getIdentifier(), InstParams,
1151  VarInst);
1152  VarInst->setDescribedVarTemplate(Inst);
1153  Inst->setPreviousDecl(PrevVarTemplate);
1154 
1155  Inst->setAccess(D->getAccess());
1156  if (!PrevVarTemplate)
1158 
1159  if (D->isOutOfLine()) {
1162  }
1163 
1164  Owner->addDecl(Inst);
1165 
1166  if (!PrevVarTemplate) {
1167  // Queue up any out-of-line partial specializations of this member
1168  // variable template; the client will force their instantiation once
1169  // the enclosing class has been instantiated.
1171  D->getPartialSpecializations(PartialSpecs);
1172  for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I)
1173  if (PartialSpecs[I]->getFirstDecl()->isOutOfLine())
1174  OutOfLineVarPartialSpecs.push_back(
1175  std::make_pair(Inst, PartialSpecs[I]));
1176  }
1177 
1178  return Inst;
1179 }
1180 
1181 Decl *TemplateDeclInstantiator::VisitVarTemplatePartialSpecializationDecl(
1183  assert(D->isStaticDataMember() &&
1184  "Only static data member templates are allowed.");
1185 
1186  VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
1187 
1188  // Lookup the already-instantiated declaration and return that.
1189  DeclContext::lookup_result Found = Owner->lookup(VarTemplate->getDeclName());
1190  assert(!Found.empty() && "Instantiation found nothing?");
1191 
1192  VarTemplateDecl *InstVarTemplate = dyn_cast<VarTemplateDecl>(Found.front());
1193  assert(InstVarTemplate && "Instantiation did not find a variable template?");
1194 
1196  InstVarTemplate->findPartialSpecInstantiatedFromMember(D))
1197  return Result;
1198 
1199  return InstantiateVarTemplatePartialSpecialization(InstVarTemplate, D);
1200 }
1201 
1202 Decl *
1203 TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1204  // Create a local instantiation scope for this function template, which
1205  // will contain the instantiations of the template parameters and then get
1206  // merged with the local instantiation scope for the function template
1207  // itself.
1208  LocalInstantiationScope Scope(SemaRef);
1209 
1210  TemplateParameterList *TempParams = D->getTemplateParameters();
1211  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1212  if (!InstParams)
1213  return nullptr;
1214 
1215  FunctionDecl *Instantiated = nullptr;
1216  if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(D->getTemplatedDecl()))
1217  Instantiated = cast_or_null<FunctionDecl>(VisitCXXMethodDecl(DMethod,
1218  InstParams));
1219  else
1220  Instantiated = cast_or_null<FunctionDecl>(VisitFunctionDecl(
1221  D->getTemplatedDecl(),
1222  InstParams));
1223 
1224  if (!Instantiated)
1225  return nullptr;
1226 
1227  // Link the instantiated function template declaration to the function
1228  // template from which it was instantiated.
1229  FunctionTemplateDecl *InstTemplate
1230  = Instantiated->getDescribedFunctionTemplate();
1231  InstTemplate->setAccess(D->getAccess());
1232  assert(InstTemplate &&
1233  "VisitFunctionDecl/CXXMethodDecl didn't create a template!");
1234 
1235  bool isFriend = (InstTemplate->getFriendObjectKind() != Decl::FOK_None);
1236 
1237  // Link the instantiation back to the pattern *unless* this is a
1238  // non-definition friend declaration.
1239  if (!InstTemplate->getInstantiatedFromMemberTemplate() &&
1240  !(isFriend && !D->getTemplatedDecl()->isThisDeclarationADefinition()))
1241  InstTemplate->setInstantiatedFromMemberTemplate(D);
1242 
1243  // Make declarations visible in the appropriate context.
1244  if (!isFriend) {
1245  Owner->addDecl(InstTemplate);
1246  } else if (InstTemplate->getDeclContext()->isRecord() &&
1248  SemaRef.CheckFriendAccess(InstTemplate);
1249  }
1250 
1251  return InstTemplate;
1252 }
1253 
1254 Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
1255  CXXRecordDecl *PrevDecl = nullptr;
1256  if (D->isInjectedClassName())
1257  PrevDecl = cast<CXXRecordDecl>(Owner);
1258  else if (CXXRecordDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
1259  NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
1260  PatternPrev,
1261  TemplateArgs);
1262  if (!Prev) return nullptr;
1263  PrevDecl = cast<CXXRecordDecl>(Prev);
1264  }
1265 
1266  CXXRecordDecl *Record
1267  = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
1268  D->getLocStart(), D->getLocation(),
1269  D->getIdentifier(), PrevDecl);
1270 
1271  // Substitute the nested name specifier, if any.
1272  if (SubstQualifier(D, Record))
1273  return nullptr;
1274 
1275  Record->setImplicit(D->isImplicit());
1276  // FIXME: Check against AS_none is an ugly hack to work around the issue that
1277  // the tag decls introduced by friend class declarations don't have an access
1278  // specifier. Remove once this area of the code gets sorted out.
1279  if (D->getAccess() != AS_none)
1280  Record->setAccess(D->getAccess());
1281  if (!D->isInjectedClassName())
1283 
1284  // If the original function was part of a friend declaration,
1285  // inherit its namespace state.
1286  if (D->getFriendObjectKind())
1287  Record->setObjectOfFriendDecl();
1288 
1289  // Make sure that anonymous structs and unions are recorded.
1290  if (D->isAnonymousStructOrUnion())
1291  Record->setAnonymousStructOrUnion(true);
1292 
1293  if (D->isLocalClass())
1294  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Record);
1295 
1296  // Forward the mangling number from the template to the instantiated decl.
1297  SemaRef.Context.setManglingNumber(Record,
1298  SemaRef.Context.getManglingNumber(D));
1299 
1300  Owner->addDecl(Record);
1301 
1302  // DR1484 clarifies that the members of a local class are instantiated as part
1303  // of the instantiation of their enclosing entity.
1304  if (D->isCompleteDefinition() && D->isLocalClass()) {
1306  SavedPendingLocalImplicitInstantiations(SemaRef);
1307 
1308  SemaRef.InstantiateClass(D->getLocation(), Record, D, TemplateArgs,
1310  /*Complain=*/true);
1311 
1312  SemaRef.InstantiateClassMembers(D->getLocation(), Record, TemplateArgs,
1314 
1315  // This class may have local implicit instantiations that need to be
1316  // performed within this scope.
1317  SemaRef.PerformPendingInstantiations(/*LocalOnly=*/true);
1318  }
1319 
1320  SemaRef.DiagnoseUnusedNestedTypedefs(Record);
1321 
1322  return Record;
1323 }
1324 
1325 /// \brief Adjust the given function type for an instantiation of the
1326 /// given declaration, to cope with modifications to the function's type that
1327 /// aren't reflected in the type-source information.
1328 ///
1329 /// \param D The declaration we're instantiating.
1330 /// \param TInfo The already-instantiated type.
1332  FunctionDecl *D,
1333  TypeSourceInfo *TInfo) {
1334  const FunctionProtoType *OrigFunc
1335  = D->getType()->castAs<FunctionProtoType>();
1336  const FunctionProtoType *NewFunc
1337  = TInfo->getType()->castAs<FunctionProtoType>();
1338  if (OrigFunc->getExtInfo() == NewFunc->getExtInfo())
1339  return TInfo->getType();
1340 
1341  FunctionProtoType::ExtProtoInfo NewEPI = NewFunc->getExtProtoInfo();
1342  NewEPI.ExtInfo = OrigFunc->getExtInfo();
1343  return Context.getFunctionType(NewFunc->getReturnType(),
1344  NewFunc->getParamTypes(), NewEPI);
1345 }
1346 
1347 /// Normal class members are of more specific types and therefore
1348 /// don't make it here. This function serves two purposes:
1349 /// 1) instantiating function templates
1350 /// 2) substituting friend declarations
1352  TemplateParameterList *TemplateParams) {
1353  // Check whether there is already a function template specialization for
1354  // this declaration.
1355  FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1356  if (FunctionTemplate && !TemplateParams) {
1357  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1358 
1359  void *InsertPos = nullptr;
1360  FunctionDecl *SpecFunc
1361  = FunctionTemplate->findSpecialization(Innermost, InsertPos);
1362 
1363  // If we already have a function template specialization, return it.
1364  if (SpecFunc)
1365  return SpecFunc;
1366  }
1367 
1368  bool isFriend;
1369  if (FunctionTemplate)
1370  isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1371  else
1372  isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1373 
1374  bool MergeWithParentScope = (TemplateParams != nullptr) ||
1375  Owner->isFunctionOrMethod() ||
1376  !(isa<Decl>(Owner) &&
1377  cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1378  LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1379 
1381  TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1382  if (!TInfo)
1383  return nullptr;
1384  QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
1385 
1386  NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1387  if (QualifierLoc) {
1388  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1389  TemplateArgs);
1390  if (!QualifierLoc)
1391  return nullptr;
1392  }
1393 
1394  // If we're instantiating a local function declaration, put the result
1395  // in the enclosing namespace; otherwise we need to find the instantiated
1396  // context.
1397  DeclContext *DC;
1398  if (D->isLocalExternDecl()) {
1399  DC = Owner;
1400  SemaRef.adjustContextForLocalExternDecl(DC);
1401  } else if (isFriend && QualifierLoc) {
1402  CXXScopeSpec SS;
1403  SS.Adopt(QualifierLoc);
1404  DC = SemaRef.computeDeclContext(SS);
1405  if (!DC) return nullptr;
1406  } else {
1407  DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
1408  TemplateArgs);
1409  }
1410 
1411  FunctionDecl *Function =
1412  FunctionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
1413  D->getNameInfo(), T, TInfo,
1416  D->isConstexpr());
1417  Function->setRangeEnd(D->getSourceRange().getEnd());
1418 
1419  if (D->isInlined())
1420  Function->setImplicitlyInline();
1421 
1422  if (QualifierLoc)
1423  Function->setQualifierInfo(QualifierLoc);
1424 
1425  if (D->isLocalExternDecl())
1426  Function->setLocalExternDecl();
1427 
1428  DeclContext *LexicalDC = Owner;
1429  if (!isFriend && D->isOutOfLine() && !D->isLocalExternDecl()) {
1430  assert(D->getDeclContext()->isFileContext());
1431  LexicalDC = D->getDeclContext();
1432  }
1433 
1434  Function->setLexicalDeclContext(LexicalDC);
1435 
1436  // Attach the parameters
1437  for (unsigned P = 0; P < Params.size(); ++P)
1438  if (Params[P])
1439  Params[P]->setOwningFunction(Function);
1440  Function->setParams(Params);
1441 
1442  SourceLocation InstantiateAtPOI;
1443  if (TemplateParams) {
1444  // Our resulting instantiation is actually a function template, since we
1445  // are substituting only the outer template parameters. For example, given
1446  //
1447  // template<typename T>
1448  // struct X {
1449  // template<typename U> friend void f(T, U);
1450  // };
1451  //
1452  // X<int> x;
1453  //
1454  // We are instantiating the friend function template "f" within X<int>,
1455  // which means substituting int for T, but leaving "f" as a friend function
1456  // template.
1457  // Build the function template itself.
1458  FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, DC,
1459  Function->getLocation(),
1460  Function->getDeclName(),
1461  TemplateParams, Function);
1462  Function->setDescribedFunctionTemplate(FunctionTemplate);
1463 
1464  FunctionTemplate->setLexicalDeclContext(LexicalDC);
1465 
1466  if (isFriend && D->isThisDeclarationADefinition()) {
1467  // TODO: should we remember this connection regardless of whether
1468  // the friend declaration provided a body?
1469  FunctionTemplate->setInstantiatedFromMemberTemplate(
1471  }
1472  } else if (FunctionTemplate) {
1473  // Record this function template specialization.
1474  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1475  Function->setFunctionTemplateSpecialization(FunctionTemplate,
1477  Innermost.begin(),
1478  Innermost.size()),
1479  /*InsertPos=*/nullptr);
1480  } else if (isFriend) {
1481  // Note, we need this connection even if the friend doesn't have a body.
1482  // Its body may exist but not have been attached yet due to deferred
1483  // parsing.
1484  // FIXME: It might be cleaner to set this when attaching the body to the
1485  // friend function declaration, however that would require finding all the
1486  // instantiations and modifying them.
1487  Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1488  }
1489 
1490  if (InitFunctionInstantiation(Function, D))
1491  Function->setInvalidDecl();
1492 
1493  bool isExplicitSpecialization = false;
1494 
1496  SemaRef, Function->getDeclName(), SourceLocation(),
1500 
1503  assert(isFriend && "non-friend has dependent specialization info?");
1504 
1505  // This needs to be set now for future sanity.
1506  Function->setObjectOfFriendDecl();
1507 
1508  // Instantiate the explicit template arguments.
1509  TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
1510  Info->getRAngleLoc());
1511  if (SemaRef.Subst(Info->getTemplateArgs(), Info->getNumTemplateArgs(),
1512  ExplicitArgs, TemplateArgs))
1513  return nullptr;
1514 
1515  // Map the candidate templates to their instantiations.
1516  for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
1517  Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
1518  Info->getTemplate(I),
1519  TemplateArgs);
1520  if (!Temp) return nullptr;
1521 
1522  Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
1523  }
1524 
1525  if (SemaRef.CheckFunctionTemplateSpecialization(Function,
1526  &ExplicitArgs,
1527  Previous))
1528  Function->setInvalidDecl();
1529 
1530  isExplicitSpecialization = true;
1531 
1532  } else if (TemplateParams || !FunctionTemplate) {
1533  // Look only into the namespace where the friend would be declared to
1534  // find a previous declaration. This is the innermost enclosing namespace,
1535  // as described in ActOnFriendFunctionDecl.
1536  SemaRef.LookupQualifiedName(Previous, DC);
1537 
1538  // In C++, the previous declaration we find might be a tag type
1539  // (class or enum). In this case, the new declaration will hide the
1540  // tag type. Note that this does does not apply if we're declaring a
1541  // typedef (C++ [dcl.typedef]p4).
1542  if (Previous.isSingleTagDecl())
1543  Previous.clear();
1544  }
1545 
1546  SemaRef.CheckFunctionDeclaration(/*Scope*/ nullptr, Function, Previous,
1547  isExplicitSpecialization);
1548 
1549  NamedDecl *PrincipalDecl = (TemplateParams
1550  ? cast<NamedDecl>(FunctionTemplate)
1551  : Function);
1552 
1553  // If the original function was part of a friend declaration,
1554  // inherit its namespace state and add it to the owner.
1555  if (isFriend) {
1556  PrincipalDecl->setObjectOfFriendDecl();
1557  DC->makeDeclVisibleInContext(PrincipalDecl);
1558 
1559  bool QueuedInstantiation = false;
1560 
1561  // C++11 [temp.friend]p4 (DR329):
1562  // When a function is defined in a friend function declaration in a class
1563  // template, the function is instantiated when the function is odr-used.
1564  // The same restrictions on multiple declarations and definitions that
1565  // apply to non-template function declarations and definitions also apply
1566  // to these implicit definitions.
1567  if (D->isThisDeclarationADefinition()) {
1568  // Check for a function body.
1569  const FunctionDecl *Definition = nullptr;
1570  if (Function->isDefined(Definition) &&
1571  Definition->getTemplateSpecializationKind() == TSK_Undeclared) {
1572  SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
1573  << Function->getDeclName();
1574  SemaRef.Diag(Definition->getLocation(), diag::note_previous_definition);
1575  }
1576  // Check for redefinitions due to other instantiations of this or
1577  // a similar friend function.
1578  else for (auto R : Function->redecls()) {
1579  if (R == Function)
1580  continue;
1581 
1582  // If some prior declaration of this function has been used, we need
1583  // to instantiate its definition.
1584  if (!QueuedInstantiation && R->isUsed(false)) {
1585  if (MemberSpecializationInfo *MSInfo =
1586  Function->getMemberSpecializationInfo()) {
1587  if (MSInfo->getPointOfInstantiation().isInvalid()) {
1588  SourceLocation Loc = R->getLocation(); // FIXME
1589  MSInfo->setPointOfInstantiation(Loc);
1590  SemaRef.PendingLocalImplicitInstantiations.push_back(
1591  std::make_pair(Function, Loc));
1592  QueuedInstantiation = true;
1593  }
1594  }
1595  }
1596 
1597  // If some prior declaration of this function was a friend with an
1598  // uninstantiated definition, reject it.
1599  if (R->getFriendObjectKind()) {
1600  if (const FunctionDecl *RPattern =
1602  if (RPattern->isDefined(RPattern)) {
1603  SemaRef.Diag(Function->getLocation(), diag::err_redefinition)
1604  << Function->getDeclName();
1605  SemaRef.Diag(R->getLocation(), diag::note_previous_definition);
1606  break;
1607  }
1608  }
1609  }
1610  }
1611  }
1612  }
1613 
1614  if (Function->isLocalExternDecl() && !Function->getPreviousDecl())
1615  DC->makeDeclVisibleInContext(PrincipalDecl);
1616 
1617  if (Function->isOverloadedOperator() && !DC->isRecord() &&
1619  PrincipalDecl->setNonMemberOperator();
1620 
1621  assert(!D->isDefaulted() && "only methods should be defaulted");
1622  return Function;
1623 }
1624 
1625 Decl *
1627  TemplateParameterList *TemplateParams,
1628  bool IsClassScopeSpecialization) {
1629  FunctionTemplateDecl *FunctionTemplate = D->getDescribedFunctionTemplate();
1630  if (FunctionTemplate && !TemplateParams) {
1631  // We are creating a function template specialization from a function
1632  // template. Check whether there is already a function template
1633  // specialization for this particular set of template arguments.
1634  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1635 
1636  void *InsertPos = nullptr;
1637  FunctionDecl *SpecFunc
1638  = FunctionTemplate->findSpecialization(Innermost, InsertPos);
1639 
1640  // If we already have a function template specialization, return it.
1641  if (SpecFunc)
1642  return SpecFunc;
1643  }
1644 
1645  bool isFriend;
1646  if (FunctionTemplate)
1647  isFriend = (FunctionTemplate->getFriendObjectKind() != Decl::FOK_None);
1648  else
1649  isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
1650 
1651  bool MergeWithParentScope = (TemplateParams != nullptr) ||
1652  !(isa<Decl>(Owner) &&
1653  cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
1654  LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
1655 
1656  // Instantiate enclosing template arguments for friends.
1658  unsigned NumTempParamLists = 0;
1659  if (isFriend && (NumTempParamLists = D->getNumTemplateParameterLists())) {
1660  TempParamLists.set_size(NumTempParamLists);
1661  for (unsigned I = 0; I != NumTempParamLists; ++I) {
1662  TemplateParameterList *TempParams = D->getTemplateParameterList(I);
1663  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
1664  if (!InstParams)
1665  return nullptr;
1666  TempParamLists[I] = InstParams;
1667  }
1668  }
1669 
1671  TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
1672  if (!TInfo)
1673  return nullptr;
1674  QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
1675 
1676  NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
1677  if (QualifierLoc) {
1678  QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
1679  TemplateArgs);
1680  if (!QualifierLoc)
1681  return nullptr;
1682  }
1683 
1684  DeclContext *DC = Owner;
1685  if (isFriend) {
1686  if (QualifierLoc) {
1687  CXXScopeSpec SS;
1688  SS.Adopt(QualifierLoc);
1689  DC = SemaRef.computeDeclContext(SS);
1690 
1691  if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
1692  return nullptr;
1693  } else {
1694  DC = SemaRef.FindInstantiatedContext(D->getLocation(),
1695  D->getDeclContext(),
1696  TemplateArgs);
1697  }
1698  if (!DC) return nullptr;
1699  }
1700 
1701  // Build the instantiated method declaration.
1702  CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
1703  CXXMethodDecl *Method = nullptr;
1704 
1705  SourceLocation StartLoc = D->getInnerLocStart();
1706  DeclarationNameInfo NameInfo
1707  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
1708  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
1709  Method = CXXConstructorDecl::Create(SemaRef.Context, Record,
1710  StartLoc, NameInfo, T, TInfo,
1711  Constructor->isExplicit(),
1712  Constructor->isInlineSpecified(),
1713  false, Constructor->isConstexpr());
1714 
1715  // Claim that the instantiation of a constructor or constructor template
1716  // inherits the same constructor that the template does.
1717  if (CXXConstructorDecl *Inh = const_cast<CXXConstructorDecl *>(
1718  Constructor->getInheritedConstructor())) {
1719  // If we're instantiating a specialization of a function template, our
1720  // "inherited constructor" will actually itself be a function template.
1721  // Instantiate a declaration of it, too.
1722  if (FunctionTemplate) {
1723  assert(!TemplateParams && Inh->getDescribedFunctionTemplate() &&
1724  !Inh->getParent()->isDependentContext() &&
1725  "inheriting constructor template in dependent context?");
1726  Sema::InstantiatingTemplate Inst(SemaRef, Constructor->getLocation(),
1727  Inh);
1728  if (Inst.isInvalid())
1729  return nullptr;
1730  Sema::ContextRAII SavedContext(SemaRef, Inh->getDeclContext());
1731  LocalInstantiationScope LocalScope(SemaRef);
1732 
1733  // Use the same template arguments that we deduced for the inheriting
1734  // constructor. There's no way they could be deduced differently.
1735  MultiLevelTemplateArgumentList InheritedArgs;
1736  InheritedArgs.addOuterTemplateArguments(TemplateArgs.getInnermost());
1737  Inh = cast_or_null<CXXConstructorDecl>(
1738  SemaRef.SubstDecl(Inh, Inh->getDeclContext(), InheritedArgs));
1739  if (!Inh)
1740  return nullptr;
1741  }
1742  cast<CXXConstructorDecl>(Method)->setInheritedConstructor(Inh);
1743  }
1744  } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
1745  Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
1746  StartLoc, NameInfo, T, TInfo,
1747  Destructor->isInlineSpecified(),
1748  false);
1749  } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
1750  Method = CXXConversionDecl::Create(SemaRef.Context, Record,
1751  StartLoc, NameInfo, T, TInfo,
1752  Conversion->isInlineSpecified(),
1753  Conversion->isExplicit(),
1754  Conversion->isConstexpr(),
1755  Conversion->getLocEnd());
1756  } else {
1757  StorageClass SC = D->isStatic() ? SC_Static : SC_None;
1758  Method = CXXMethodDecl::Create(SemaRef.Context, Record,
1759  StartLoc, NameInfo, T, TInfo,
1760  SC, D->isInlineSpecified(),
1761  D->isConstexpr(), D->getLocEnd());
1762  }
1763 
1764  if (D->isInlined())
1765  Method->setImplicitlyInline();
1766 
1767  if (QualifierLoc)
1768  Method->setQualifierInfo(QualifierLoc);
1769 
1770  if (TemplateParams) {
1771  // Our resulting instantiation is actually a function template, since we
1772  // are substituting only the outer template parameters. For example, given
1773  //
1774  // template<typename T>
1775  // struct X {
1776  // template<typename U> void f(T, U);
1777  // };
1778  //
1779  // X<int> x;
1780  //
1781  // We are instantiating the member template "f" within X<int>, which means
1782  // substituting int for T, but leaving "f" as a member function template.
1783  // Build the function template itself.
1784  FunctionTemplate = FunctionTemplateDecl::Create(SemaRef.Context, Record,
1785  Method->getLocation(),
1786  Method->getDeclName(),
1787  TemplateParams, Method);
1788  if (isFriend) {
1789  FunctionTemplate->setLexicalDeclContext(Owner);
1790  FunctionTemplate->setObjectOfFriendDecl();
1791  } else if (D->isOutOfLine())
1792  FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
1793  Method->setDescribedFunctionTemplate(FunctionTemplate);
1794  } else if (FunctionTemplate) {
1795  // Record this function template specialization.
1796  ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1797  Method->setFunctionTemplateSpecialization(FunctionTemplate,
1799  Innermost.begin(),
1800  Innermost.size()),
1801  /*InsertPos=*/nullptr);
1802  } else if (!isFriend) {
1803  // Record that this is an instantiation of a member function.
1804  Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation);
1805  }
1806 
1807  // If we are instantiating a member function defined
1808  // out-of-line, the instantiation will have the same lexical
1809  // context (which will be a namespace scope) as the template.
1810  if (isFriend) {
1811  if (NumTempParamLists)
1812  Method->setTemplateParameterListsInfo(SemaRef.Context,
1813  NumTempParamLists,
1814  TempParamLists.data());
1815 
1816  Method->setLexicalDeclContext(Owner);
1817  Method->setObjectOfFriendDecl();
1818  } else if (D->isOutOfLine())
1819  Method->setLexicalDeclContext(D->getLexicalDeclContext());
1820 
1821  // Attach the parameters
1822  for (unsigned P = 0; P < Params.size(); ++P)
1823  Params[P]->setOwningFunction(Method);
1824  Method->setParams(Params);
1825 
1826  if (InitMethodInstantiation(Method, D))
1827  Method->setInvalidDecl();
1828 
1829  LookupResult Previous(SemaRef, NameInfo, Sema::LookupOrdinaryName,
1831 
1832  if (!FunctionTemplate || TemplateParams || isFriend) {
1833  SemaRef.LookupQualifiedName(Previous, Record);
1834 
1835  // In C++, the previous declaration we find might be a tag type
1836  // (class or enum). In this case, the new declaration will hide the
1837  // tag type. Note that this does does not apply if we're declaring a
1838  // typedef (C++ [dcl.typedef]p4).
1839  if (Previous.isSingleTagDecl())
1840  Previous.clear();
1841  }
1842 
1843  if (!IsClassScopeSpecialization)
1844  SemaRef.CheckFunctionDeclaration(nullptr, Method, Previous, false);
1845 
1846  if (D->isPure())
1847  SemaRef.CheckPureMethod(Method, SourceRange());
1848 
1849  // Propagate access. For a non-friend declaration, the access is
1850  // whatever we're propagating from. For a friend, it should be the
1851  // previous declaration we just found.
1852  if (isFriend && Method->getPreviousDecl())
1853  Method->setAccess(Method->getPreviousDecl()->getAccess());
1854  else
1855  Method->setAccess(D->getAccess());
1856  if (FunctionTemplate)
1857  FunctionTemplate->setAccess(Method->getAccess());
1858 
1859  SemaRef.CheckOverrideControl(Method);
1860 
1861  // If a function is defined as defaulted or deleted, mark it as such now.
1862  if (D->isExplicitlyDefaulted())
1863  SemaRef.SetDeclDefaulted(Method, Method->getLocation());
1864  if (D->isDeletedAsWritten())
1865  SemaRef.SetDeclDeleted(Method, Method->getLocation());
1866 
1867  // If there's a function template, let our caller handle it.
1868  if (FunctionTemplate) {
1869  // do nothing
1870 
1871  // Don't hide a (potentially) valid declaration with an invalid one.
1872  } else if (Method->isInvalidDecl() && !Previous.empty()) {
1873  // do nothing
1874 
1875  // Otherwise, check access to friends and make them visible.
1876  } else if (isFriend) {
1877  // We only need to re-check access for methods which we didn't
1878  // manage to match during parsing.
1879  if (!D->getPreviousDecl())
1880  SemaRef.CheckFriendAccess(Method);
1881 
1882  Record->makeDeclVisibleInContext(Method);
1883 
1884  // Otherwise, add the declaration. We don't need to do this for
1885  // class-scope specializations because we'll have matched them with
1886  // the appropriate template.
1887  } else if (!IsClassScopeSpecialization) {
1888  Owner->addDecl(Method);
1889  }
1890 
1891  return Method;
1892 }
1893 
1894 Decl *TemplateDeclInstantiator::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1895  return VisitCXXMethodDecl(D);
1896 }
1897 
1898 Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1899  return VisitCXXMethodDecl(D);
1900 }
1901 
1902 Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
1903  return VisitCXXMethodDecl(D);
1904 }
1905 
1906 Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
1907  return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None,
1908  /*ExpectParameterPack=*/ false);
1909 }
1910 
1911 Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
1912  TemplateTypeParmDecl *D) {
1913  // TODO: don't always clone when decls are refcounted.
1914  assert(D->getTypeForDecl()->isTemplateTypeParmType());
1915 
1916  TemplateTypeParmDecl *Inst =
1917  TemplateTypeParmDecl::Create(SemaRef.Context, Owner,
1918  D->getLocStart(), D->getLocation(),
1919  D->getDepth() - TemplateArgs.getNumLevels(),
1920  D->getIndex(), D->getIdentifier(),
1922  D->isParameterPack());
1923  Inst->setAccess(AS_public);
1924 
1925  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
1926  TypeSourceInfo *InstantiatedDefaultArg =
1927  SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
1928  D->getDefaultArgumentLoc(), D->getDeclName());
1929  if (InstantiatedDefaultArg)
1930  Inst->setDefaultArgument(InstantiatedDefaultArg);
1931  }
1932 
1933  // Introduce this template parameter's instantiation into the instantiation
1934  // scope.
1935  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1936 
1937  return Inst;
1938 }
1939 
1940 Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
1942  // Substitute into the type of the non-type template parameter.
1943  TypeLoc TL = D->getTypeSourceInfo()->getTypeLoc();
1944  SmallVector<TypeSourceInfo *, 4> ExpandedParameterPackTypesAsWritten;
1945  SmallVector<QualType, 4> ExpandedParameterPackTypes;
1946  bool IsExpandedParameterPack = false;
1947  TypeSourceInfo *DI;
1948  QualType T;
1949  bool Invalid = false;
1950 
1951  if (D->isExpandedParameterPack()) {
1952  // The non-type template parameter pack is an already-expanded pack
1953  // expansion of types. Substitute into each of the expanded types.
1954  ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
1955  ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
1956  for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1957  TypeSourceInfo *NewDI =SemaRef.SubstType(D->getExpansionTypeSourceInfo(I),
1958  TemplateArgs,
1959  D->getLocation(),
1960  D->getDeclName());
1961  if (!NewDI)
1962  return nullptr;
1963 
1964  ExpandedParameterPackTypesAsWritten.push_back(NewDI);
1965  QualType NewT =SemaRef.CheckNonTypeTemplateParameterType(NewDI->getType(),
1966  D->getLocation());
1967  if (NewT.isNull())
1968  return nullptr;
1969  ExpandedParameterPackTypes.push_back(NewT);
1970  }
1971 
1972  IsExpandedParameterPack = true;
1973  DI = D->getTypeSourceInfo();
1974  T = DI->getType();
1975  } else if (D->isPackExpansion()) {
1976  // The non-type template parameter pack's type is a pack expansion of types.
1977  // Determine whether we need to expand this parameter pack into separate
1978  // types.
1980  TypeLoc Pattern = Expansion.getPatternLoc();
1982  SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
1983 
1984  // Determine whether the set of unexpanded parameter packs can and should
1985  // be expanded.
1986  bool Expand = true;
1987  bool RetainExpansion = false;
1988  Optional<unsigned> OrigNumExpansions
1989  = Expansion.getTypePtr()->getNumExpansions();
1990  Optional<unsigned> NumExpansions = OrigNumExpansions;
1991  if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
1992  Pattern.getSourceRange(),
1993  Unexpanded,
1994  TemplateArgs,
1995  Expand, RetainExpansion,
1996  NumExpansions))
1997  return nullptr;
1998 
1999  if (Expand) {
2000  for (unsigned I = 0; I != *NumExpansions; ++I) {
2001  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2002  TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
2003  D->getLocation(),
2004  D->getDeclName());
2005  if (!NewDI)
2006  return nullptr;
2007 
2008  ExpandedParameterPackTypesAsWritten.push_back(NewDI);
2010  NewDI->getType(),
2011  D->getLocation());
2012  if (NewT.isNull())
2013  return nullptr;
2014  ExpandedParameterPackTypes.push_back(NewT);
2015  }
2016 
2017  // Note that we have an expanded parameter pack. The "type" of this
2018  // expanded parameter pack is the original expansion type, but callers
2019  // will end up using the expanded parameter pack types for type-checking.
2020  IsExpandedParameterPack = true;
2021  DI = D->getTypeSourceInfo();
2022  T = DI->getType();
2023  } else {
2024  // We cannot fully expand the pack expansion now, so substitute into the
2025  // pattern and create a new pack expansion type.
2026  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2027  TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
2028  D->getLocation(),
2029  D->getDeclName());
2030  if (!NewPattern)
2031  return nullptr;
2032 
2033  DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
2034  NumExpansions);
2035  if (!DI)
2036  return nullptr;
2037 
2038  T = DI->getType();
2039  }
2040  } else {
2041  // Simple case: substitution into a parameter that is not a parameter pack.
2042  DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
2043  D->getLocation(), D->getDeclName());
2044  if (!DI)
2045  return nullptr;
2046 
2047  // Check that this type is acceptable for a non-type template parameter.
2048  T = SemaRef.CheckNonTypeTemplateParameterType(DI->getType(),
2049  D->getLocation());
2050  if (T.isNull()) {
2051  T = SemaRef.Context.IntTy;
2052  Invalid = true;
2053  }
2054  }
2055 
2056  NonTypeTemplateParmDecl *Param;
2057  if (IsExpandedParameterPack)
2058  Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner,
2059  D->getInnerLocStart(),
2060  D->getLocation(),
2061  D->getDepth() - TemplateArgs.getNumLevels(),
2062  D->getPosition(),
2063  D->getIdentifier(), T,
2064  DI,
2065  ExpandedParameterPackTypes.data(),
2066  ExpandedParameterPackTypes.size(),
2067  ExpandedParameterPackTypesAsWritten.data());
2068  else
2069  Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner,
2070  D->getInnerLocStart(),
2071  D->getLocation(),
2072  D->getDepth() - TemplateArgs.getNumLevels(),
2073  D->getPosition(),
2074  D->getIdentifier(), T,
2075  D->isParameterPack(), DI);
2076 
2077  Param->setAccess(AS_public);
2078  if (Invalid)
2079  Param->setInvalidDecl();
2080 
2081  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2082  ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
2083  if (!Value.isInvalid())
2084  Param->setDefaultArgument(Value.get());
2085  }
2086 
2087  // Introduce this template parameter's instantiation into the instantiation
2088  // scope.
2089  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2090  return Param;
2091 }
2092 
2094  Sema &S,
2095  TemplateParameterList *Params,
2097  for (const auto &P : *Params) {
2098  if (P->isTemplateParameterPack())
2099  continue;
2100  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
2101  S.collectUnexpandedParameterPacks(NTTP->getTypeSourceInfo()->getTypeLoc(),
2102  Unexpanded);
2103  if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
2104  collectUnexpandedParameterPacks(S, TTP->getTemplateParameters(),
2105  Unexpanded);
2106  }
2107 }
2108 
2109 Decl *
2110 TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
2112  // Instantiate the template parameter list of the template template parameter.
2113  TemplateParameterList *TempParams = D->getTemplateParameters();
2114  TemplateParameterList *InstParams;
2116 
2117  bool IsExpandedParameterPack = false;
2118 
2119  if (D->isExpandedParameterPack()) {
2120  // The template template parameter pack is an already-expanded pack
2121  // expansion of template parameters. Substitute into each of the expanded
2122  // parameters.
2123  ExpandedParams.reserve(D->getNumExpansionTemplateParameters());
2124  for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2125  I != N; ++I) {
2126  LocalInstantiationScope Scope(SemaRef);
2127  TemplateParameterList *Expansion =
2129  if (!Expansion)
2130  return nullptr;
2131  ExpandedParams.push_back(Expansion);
2132  }
2133 
2134  IsExpandedParameterPack = true;
2135  InstParams = TempParams;
2136  } else if (D->isPackExpansion()) {
2137  // The template template parameter pack expands to a pack of template
2138  // template parameters. Determine whether we need to expand this parameter
2139  // pack into separate parameters.
2142  Unexpanded);
2143 
2144  // Determine whether the set of unexpanded parameter packs can and should
2145  // be expanded.
2146  bool Expand = true;
2147  bool RetainExpansion = false;
2148  Optional<unsigned> NumExpansions;
2150  TempParams->getSourceRange(),
2151  Unexpanded,
2152  TemplateArgs,
2153  Expand, RetainExpansion,
2154  NumExpansions))
2155  return nullptr;
2156 
2157  if (Expand) {
2158  for (unsigned I = 0; I != *NumExpansions; ++I) {
2159  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
2160  LocalInstantiationScope Scope(SemaRef);
2161  TemplateParameterList *Expansion = SubstTemplateParams(TempParams);
2162  if (!Expansion)
2163  return nullptr;
2164  ExpandedParams.push_back(Expansion);
2165  }
2166 
2167  // Note that we have an expanded parameter pack. The "type" of this
2168  // expanded parameter pack is the original expansion type, but callers
2169  // will end up using the expanded parameter pack types for type-checking.
2170  IsExpandedParameterPack = true;
2171  InstParams = TempParams;
2172  } else {
2173  // We cannot fully expand the pack expansion now, so just substitute
2174  // into the pattern.
2175  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
2176 
2177  LocalInstantiationScope Scope(SemaRef);
2178  InstParams = SubstTemplateParams(TempParams);
2179  if (!InstParams)
2180  return nullptr;
2181  }
2182  } else {
2183  // Perform the actual substitution of template parameters within a new,
2184  // local instantiation scope.
2185  LocalInstantiationScope Scope(SemaRef);
2186  InstParams = SubstTemplateParams(TempParams);
2187  if (!InstParams)
2188  return nullptr;
2189  }
2190 
2191  // Build the template template parameter.
2192  TemplateTemplateParmDecl *Param;
2193  if (IsExpandedParameterPack)
2194  Param = TemplateTemplateParmDecl::Create(SemaRef.Context, Owner,
2195  D->getLocation(),
2196  D->getDepth() - TemplateArgs.getNumLevels(),
2197  D->getPosition(),
2198  D->getIdentifier(), InstParams,
2199  ExpandedParams);
2200  else
2201  Param = TemplateTemplateParmDecl::Create(SemaRef.Context, Owner,
2202  D->getLocation(),
2203  D->getDepth() - TemplateArgs.getNumLevels(),
2204  D->getPosition(),
2205  D->isParameterPack(),
2206  D->getIdentifier(), InstParams);
2207  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
2208  NestedNameSpecifierLoc QualifierLoc =
2210  QualifierLoc =
2211  SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
2212  TemplateName TName = SemaRef.SubstTemplateName(
2213  QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
2214  D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
2215  if (!TName.isNull())
2216  Param->setDefaultArgument(
2217  SemaRef.Context,
2221  }
2222  Param->setAccess(AS_public);
2223 
2224  // Introduce this template parameter's instantiation into the instantiation
2225  // scope.
2226  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
2227 
2228  return Param;
2229 }
2230 
2231 Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
2232  // Using directives are never dependent (and never contain any types or
2233  // expressions), so they require no explicit instantiation work.
2234 
2235  UsingDirectiveDecl *Inst
2236  = UsingDirectiveDecl::Create(SemaRef.Context, Owner, D->getLocation(),
2238  D->getQualifierLoc(),
2239  D->getIdentLocation(),
2240  D->getNominatedNamespace(),
2241  D->getCommonAncestor());
2242 
2243  // Add the using directive to its declaration context
2244  // only if this is not a function or method.
2245  if (!Owner->isFunctionOrMethod())
2246  Owner->addDecl(Inst);
2247 
2248  return Inst;
2249 }
2250 
2251 Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
2252 
2253  // The nested name specifier may be dependent, for example
2254  // template <typename T> struct t {
2255  // struct s1 { T f1(); };
2256  // struct s2 : s1 { using s1::f1; };
2257  // };
2258  // template struct t<int>;
2259  // Here, in using s1::f1, s1 refers to t<T>::s1;
2260  // we need to substitute for t<int>::s1.
2261  NestedNameSpecifierLoc QualifierLoc
2263  TemplateArgs);
2264  if (!QualifierLoc)
2265  return nullptr;
2266 
2267  // The name info is non-dependent, so no transformation
2268  // is required.
2269  DeclarationNameInfo NameInfo = D->getNameInfo();
2270 
2271  // We only need to do redeclaration lookups if we're in a class
2272  // scope (in fact, it's not really even possible in non-class
2273  // scopes).
2274  bool CheckRedeclaration = Owner->isRecord();
2275 
2276  LookupResult Prev(SemaRef, NameInfo, Sema::LookupUsingDeclName,
2278 
2279  UsingDecl *NewUD = UsingDecl::Create(SemaRef.Context, Owner,
2280  D->getUsingLoc(),
2281  QualifierLoc,
2282  NameInfo,
2283  D->hasTypename());
2284 
2285  CXXScopeSpec SS;
2286  SS.Adopt(QualifierLoc);
2287  if (CheckRedeclaration) {
2288  Prev.setHideTags(false);
2289  SemaRef.LookupQualifiedName(Prev, Owner);
2290 
2291  // Check for invalid redeclarations.
2292  if (SemaRef.CheckUsingDeclRedeclaration(D->getUsingLoc(),
2293  D->hasTypename(), SS,
2294  D->getLocation(), Prev))
2295  NewUD->setInvalidDecl();
2296 
2297  }
2298 
2299  if (!NewUD->isInvalidDecl() &&
2300  SemaRef.CheckUsingDeclQualifier(D->getUsingLoc(), SS, NameInfo,
2301  D->getLocation()))
2302  NewUD->setInvalidDecl();
2303 
2304  SemaRef.Context.setInstantiatedFromUsingDecl(NewUD, D);
2305  NewUD->setAccess(D->getAccess());
2306  Owner->addDecl(NewUD);
2307 
2308  // Don't process the shadow decls for an invalid decl.
2309  if (NewUD->isInvalidDecl())
2310  return NewUD;
2311 
2312  if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName) {
2313  SemaRef.CheckInheritingConstructorUsingDecl(NewUD);
2314  return NewUD;
2315  }
2316 
2317  bool isFunctionScope = Owner->isFunctionOrMethod();
2318 
2319  // Process the shadow decls.
2320  for (auto *Shadow : D->shadows()) {
2321  NamedDecl *InstTarget =
2322  cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
2323  Shadow->getLocation(), Shadow->getTargetDecl(), TemplateArgs));
2324  if (!InstTarget)
2325  return nullptr;
2326 
2327  UsingShadowDecl *PrevDecl = nullptr;
2328  if (CheckRedeclaration) {
2329  if (SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev, PrevDecl))
2330  continue;
2331  } else if (UsingShadowDecl *OldPrev =
2333  PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
2334  Shadow->getLocation(), OldPrev, TemplateArgs));
2335  }
2336 
2337  UsingShadowDecl *InstShadow =
2338  SemaRef.BuildUsingShadowDecl(/*Scope*/nullptr, NewUD, InstTarget,
2339  PrevDecl);
2340  SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
2341 
2342  if (isFunctionScope)
2343  SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
2344  }
2345 
2346  return NewUD;
2347 }
2348 
2349 Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
2350  // Ignore these; we handle them in bulk when processing the UsingDecl.
2351  return nullptr;
2352 }
2353 
2354 Decl * TemplateDeclInstantiator
2355  ::VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) {
2356  NestedNameSpecifierLoc QualifierLoc
2358  TemplateArgs);
2359  if (!QualifierLoc)
2360  return nullptr;
2361 
2362  CXXScopeSpec SS;
2363  SS.Adopt(QualifierLoc);
2364 
2365  // Since NameInfo refers to a typename, it cannot be a C++ special name.
2366  // Hence, no transformation is required for it.
2367  DeclarationNameInfo NameInfo(D->getDeclName(), D->getLocation());
2368  NamedDecl *UD =
2369  SemaRef.BuildUsingDeclaration(/*Scope*/ nullptr, D->getAccess(),
2370  D->getUsingLoc(), SS, NameInfo, nullptr,
2371  /*instantiation*/ true,
2372  /*typename*/ true, D->getTypenameLoc());
2373  if (UD)
2374  SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D);
2375 
2376  return UD;
2377 }
2378 
2379 Decl * TemplateDeclInstantiator
2380  ::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
2381  NestedNameSpecifierLoc QualifierLoc
2382  = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(), TemplateArgs);
2383  if (!QualifierLoc)
2384  return nullptr;
2385 
2386  CXXScopeSpec SS;
2387  SS.Adopt(QualifierLoc);
2388 
2389  DeclarationNameInfo NameInfo
2390  = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
2391 
2392  NamedDecl *UD =
2393  SemaRef.BuildUsingDeclaration(/*Scope*/ nullptr, D->getAccess(),
2394  D->getUsingLoc(), SS, NameInfo, nullptr,
2395  /*instantiation*/ true,
2396  /*typename*/ false, SourceLocation());
2397  if (UD)
2398  SemaRef.Context.setInstantiatedFromUsingDecl(cast<UsingDecl>(UD), D);
2399 
2400  return UD;
2401 }
2402 
2403 
2404 Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
2406  CXXMethodDecl *OldFD = Decl->getSpecialization();
2407  CXXMethodDecl *NewFD =
2408  cast_or_null<CXXMethodDecl>(VisitCXXMethodDecl(OldFD, nullptr, true));
2409  if (!NewFD)
2410  return nullptr;
2411 
2414 
2415  TemplateArgumentListInfo TemplateArgs;
2416  TemplateArgumentListInfo *TemplateArgsPtr = nullptr;
2417  if (Decl->hasExplicitTemplateArgs()) {
2418  TemplateArgs = Decl->templateArgs();
2419  TemplateArgsPtr = &TemplateArgs;
2420  }
2421 
2422  SemaRef.LookupQualifiedName(Previous, SemaRef.CurContext);
2423  if (SemaRef.CheckFunctionTemplateSpecialization(NewFD, TemplateArgsPtr,
2424  Previous)) {
2425  NewFD->setInvalidDecl();
2426  return NewFD;
2427  }
2428 
2429  // Associate the specialization with the pattern.
2430  FunctionDecl *Specialization = cast<FunctionDecl>(Previous.getFoundDecl());
2431  assert(Specialization && "Class scope Specialization is null");
2432  SemaRef.Context.setClassScopeSpecializationPattern(Specialization, OldFD);
2433 
2434  return NewFD;
2435 }
2436 
2437 Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
2438  OMPThreadPrivateDecl *D) {
2440  for (auto *I : D->varlists()) {
2441  Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
2442  assert(isa<DeclRefExpr>(Var) && "threadprivate arg is not a DeclRefExpr");
2443  Vars.push_back(Var);
2444  }
2445 
2446  OMPThreadPrivateDecl *TD =
2447  SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);
2448 
2449  TD->setAccess(AS_public);
2450  Owner->addDecl(TD);
2451 
2452  return TD;
2453 }
2454 
2456  return VisitFunctionDecl(D, nullptr);
2457 }
2458 
2460  return VisitCXXMethodDecl(D, nullptr);
2461 }
2462 
2463 Decl *TemplateDeclInstantiator::VisitRecordDecl(RecordDecl *D) {
2464  llvm_unreachable("There are only CXXRecordDecls in C++");
2465 }
2466 
2467 Decl *
2468 TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
2470  // As a MS extension, we permit class-scope explicit specialization
2471  // of member class templates.
2472  ClassTemplateDecl *ClassTemplate = D->getSpecializedTemplate();
2473  assert(ClassTemplate->getDeclContext()->isRecord() &&
2475  "can only instantiate an explicit specialization "
2476  "for a member class template");
2477 
2478  // Lookup the already-instantiated declaration in the instantiation
2479  // of the class template. FIXME: Diagnose or assert if this fails?
2481  = Owner->lookup(ClassTemplate->getDeclName());
2482  if (Found.empty())
2483  return nullptr;
2484  ClassTemplateDecl *InstClassTemplate
2485  = dyn_cast<ClassTemplateDecl>(Found.front());
2486  if (!InstClassTemplate)
2487  return nullptr;
2488 
2489  // Substitute into the template arguments of the class template explicit
2490  // specialization.
2492  castAs<TemplateSpecializationTypeLoc>();
2493  TemplateArgumentListInfo InstTemplateArgs(Loc.getLAngleLoc(),
2494  Loc.getRAngleLoc());
2496  for (unsigned I = 0; I != Loc.getNumArgs(); ++I)
2497  ArgLocs.push_back(Loc.getArgLoc(I));
2498  if (SemaRef.Subst(ArgLocs.data(), ArgLocs.size(),
2499  InstTemplateArgs, TemplateArgs))
2500  return nullptr;
2501 
2502  // Check that the template argument list is well-formed for this
2503  // class template.
2505  if (SemaRef.CheckTemplateArgumentList(InstClassTemplate,
2506  D->getLocation(),
2507  InstTemplateArgs,
2508  false,
2509  Converted))
2510  return nullptr;
2511 
2512  // Figure out where to insert this class template explicit specialization
2513  // in the member template's set of class template explicit specializations.
2514  void *InsertPos = nullptr;
2516  InstClassTemplate->findSpecialization(Converted, InsertPos);
2517 
2518  // Check whether we've already seen a conflicting instantiation of this
2519  // declaration (for instance, if there was a prior implicit instantiation).
2520  bool Ignored;
2521  if (PrevDecl &&
2523  D->getSpecializationKind(),
2524  PrevDecl,
2525  PrevDecl->getSpecializationKind(),
2526  PrevDecl->getPointOfInstantiation(),
2527  Ignored))
2528  return nullptr;
2529 
2530  // If PrevDecl was a definition and D is also a definition, diagnose.
2531  // This happens in cases like:
2532  //
2533  // template<typename T, typename U>
2534  // struct Outer {
2535  // template<typename X> struct Inner;
2536  // template<> struct Inner<T> {};
2537  // template<> struct Inner<U> {};
2538  // };
2539  //
2540  // Outer<int, int> outer; // error: the explicit specializations of Inner
2541  // // have the same signature.
2542  if (PrevDecl && PrevDecl->getDefinition() &&
2544  SemaRef.Diag(D->getLocation(), diag::err_redefinition) << PrevDecl;
2545  SemaRef.Diag(PrevDecl->getDefinition()->getLocation(),
2546  diag::note_previous_definition);
2547  return nullptr;
2548  }
2549 
2550  // Create the class template partial specialization declaration.
2553  D->getTagKind(),
2554  Owner,
2555  D->getLocStart(),
2556  D->getLocation(),
2557  InstClassTemplate,
2558  Converted.data(),
2559  Converted.size(),
2560  PrevDecl);
2561 
2562  // Add this partial specialization to the set of class template partial
2563  // specializations.
2564  if (!PrevDecl)
2565  InstClassTemplate->AddSpecialization(InstD, InsertPos);
2566 
2567  // Substitute the nested name specifier, if any.
2568  if (SubstQualifier(D, InstD))
2569  return nullptr;
2570 
2571  // Build the canonical type that describes the converted template
2572  // arguments of the class template explicit specialization.
2573  QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
2574  TemplateName(InstClassTemplate), Converted.data(), Converted.size(),
2575  SemaRef.Context.getRecordType(InstD));
2576 
2577  // Build the fully-sugared type for this class template
2578  // specialization as the user wrote in the specialization
2579  // itself. This means that we'll pretty-print the type retrieved
2580  // from the specialization's declaration the way that the user
2581  // actually wrote the specialization, rather than formatting the
2582  // name based on the "canonical" representation used to store the
2583  // template arguments in the specialization.
2585  TemplateName(InstClassTemplate), D->getLocation(), InstTemplateArgs,
2586  CanonType);
2587 
2588  InstD->setAccess(D->getAccess());
2589  InstD->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
2591  InstD->setTypeAsWritten(WrittenTy);
2592  InstD->setExternLoc(D->getExternLoc());
2594 
2595  Owner->addDecl(InstD);
2596 
2597  // Instantiate the members of the class-scope explicit specialization eagerly.
2598  // We don't have support for lazy instantiation of an explicit specialization
2599  // yet, and MSVC eagerly instantiates in this case.
2600  if (D->isThisDeclarationADefinition() &&
2601  SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
2603  /*Complain=*/true))
2604  return nullptr;
2605 
2606  return InstD;
2607 }
2608 
2611 
2612  TemplateArgumentListInfo VarTemplateArgsInfo;
2613  VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
2614  assert(VarTemplate &&
2615  "A template specialization without specialized template?");
2616 
2617  // Substitute the current template arguments.
2618  const TemplateArgumentListInfo &TemplateArgsInfo = D->getTemplateArgsInfo();
2619  VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
2620  VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());
2621 
2622  if (SemaRef.Subst(TemplateArgsInfo.getArgumentArray(),
2623  TemplateArgsInfo.size(), VarTemplateArgsInfo, TemplateArgs))
2624  return nullptr;
2625 
2626  // Check that the template argument list is well-formed for this template.
2628  if (SemaRef.CheckTemplateArgumentList(
2629  VarTemplate, VarTemplate->getLocStart(),
2630  const_cast<TemplateArgumentListInfo &>(VarTemplateArgsInfo), false,
2631  Converted))
2632  return nullptr;
2633 
2634  // Find the variable template specialization declaration that
2635  // corresponds to these arguments.
2636  void *InsertPos = nullptr;
2637  if (VarTemplateSpecializationDecl *VarSpec = VarTemplate->findSpecialization(
2638  Converted, InsertPos))
2639  // If we already have a variable template specialization, return it.
2640  return VarSpec;
2641 
2642  return VisitVarTemplateSpecializationDecl(VarTemplate, D, InsertPos,
2643  VarTemplateArgsInfo, Converted);
2644 }
2645 
2647  VarTemplateDecl *VarTemplate, VarDecl *D, void *InsertPos,
2648  const TemplateArgumentListInfo &TemplateArgsInfo,
2649  ArrayRef<TemplateArgument> Converted) {
2650 
2651  // If this is the variable for an anonymous struct or union,
2652  // instantiate the anonymous struct/union type first.
2653  if (const RecordType *RecordTy = D->getType()->getAs<RecordType>())
2654  if (RecordTy->getDecl()->isAnonymousStructOrUnion())
2655  if (!VisitCXXRecordDecl(cast<CXXRecordDecl>(RecordTy->getDecl())))
2656  return nullptr;
2657 
2658  // Do substitution on the type of the declaration
2659  TypeSourceInfo *DI =
2660  SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
2661  D->getTypeSpecStartLoc(), D->getDeclName());
2662  if (!DI)
2663  return nullptr;
2664 
2665  if (DI->getType()->isFunctionType()) {
2666  SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
2667  << D->isStaticDataMember() << DI->getType();
2668  return nullptr;
2669  }
2670 
2671  // Build the instantiated declaration
2673  SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
2674  VarTemplate, DI->getType(), DI, D->getStorageClass(), Converted.data(),
2675  Converted.size());
2676  Var->setTemplateArgsInfo(TemplateArgsInfo);
2677  if (InsertPos)
2678  VarTemplate->AddSpecialization(Var, InsertPos);
2679 
2680  // Substitute the nested name specifier, if any.
2681  if (SubstQualifier(D, Var))
2682  return nullptr;
2683 
2684  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs,
2685  Owner, StartingScope);
2686 
2687  return Var;
2688 }
2689 
2690 Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
2691  llvm_unreachable("@defs is not supported in Objective-C++");
2692 }
2693 
2694 Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
2695  // FIXME: We need to be able to instantiate FriendTemplateDecls.
2696  unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID(
2698  "cannot instantiate %0 yet");
2699  SemaRef.Diag(D->getLocation(), DiagID)
2700  << D->getDeclKindName();
2701 
2702  return nullptr;
2703 }
2704 
2706  llvm_unreachable("Unexpected decl");
2707 }
2708 
2709 Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
2710  const MultiLevelTemplateArgumentList &TemplateArgs) {
2711  TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
2712  if (D->isInvalidDecl())
2713  return nullptr;
2714 
2715  return Instantiator.Visit(D);
2716 }
2717 
2718 /// \brief Instantiates a nested template parameter list in the current
2719 /// instantiation context.
2720 ///
2721 /// \param L The parameter list to instantiate
2722 ///
2723 /// \returns NULL if there was an error
2726  // Get errors for all the parameters before bailing out.
2727  bool Invalid = false;
2728 
2729  unsigned N = L->size();
2730  typedef SmallVector<NamedDecl *, 8> ParamVector;
2731  ParamVector Params;
2732  Params.reserve(N);
2733  for (auto &P : *L) {
2734  NamedDecl *D = cast_or_null<NamedDecl>(Visit(P));
2735  Params.push_back(D);
2736  Invalid = Invalid || !D || D->isInvalidDecl();
2737  }
2738 
2739  // Clean up if we had an error.
2740  if (Invalid)
2741  return nullptr;
2742 
2743  TemplateParameterList *InstL
2744  = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
2745  L->getLAngleLoc(), &Params.front(), N,
2746  L->getRAngleLoc());
2747  return InstL;
2748 }
2749 
2750 /// \brief Instantiate the declaration of a class template partial
2751 /// specialization.
2752 ///
2753 /// \param ClassTemplate the (instantiated) class template that is partially
2754 // specialized by the instantiation of \p PartialSpec.
2755 ///
2756 /// \param PartialSpec the (uninstantiated) class template partial
2757 /// specialization that we are instantiating.
2758 ///
2759 /// \returns The instantiated partial specialization, if successful; otherwise,
2760 /// NULL to indicate an error.
2763  ClassTemplateDecl *ClassTemplate,
2765  // Create a local instantiation scope for this class template partial
2766  // specialization, which will contain the instantiations of the template
2767  // parameters.
2768  LocalInstantiationScope Scope(SemaRef);
2769 
2770  // Substitute into the template parameters of the class template partial
2771  // specialization.
2772  TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
2773  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
2774  if (!InstParams)
2775  return nullptr;
2776 
2777  // Substitute into the template arguments of the class template partial
2778  // specialization.
2779  const ASTTemplateArgumentListInfo *TemplArgInfo
2780  = PartialSpec->getTemplateArgsAsWritten();
2781  TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
2782  TemplArgInfo->RAngleLoc);
2783  if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
2784  TemplArgInfo->NumTemplateArgs,
2785  InstTemplateArgs, TemplateArgs))
2786  return nullptr;
2787 
2788  // Check that the template argument list is well-formed for this
2789  // class template.
2791  if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
2792  PartialSpec->getLocation(),
2793  InstTemplateArgs,
2794  false,
2795  Converted))
2796  return nullptr;
2797 
2798  // Figure out where to insert this class template partial specialization
2799  // in the member template's set of class template partial specializations.
2800  void *InsertPos = nullptr;
2802  = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
2803 
2804  // Build the canonical type that describes the converted template
2805  // arguments of the class template partial specialization.
2806  QualType CanonType
2807  = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
2808  Converted.data(),
2809  Converted.size());
2810 
2811  // Build the fully-sugared type for this class template
2812  // specialization as the user wrote in the specialization
2813  // itself. This means that we'll pretty-print the type retrieved
2814  // from the specialization's declaration the way that the user
2815  // actually wrote the specialization, rather than formatting the
2816  // name based on the "canonical" representation used to store the
2817  // template arguments in the specialization.
2818  TypeSourceInfo *WrittenTy
2820  TemplateName(ClassTemplate),
2821  PartialSpec->getLocation(),
2822  InstTemplateArgs,
2823  CanonType);
2824 
2825  if (PrevDecl) {
2826  // We've already seen a partial specialization with the same template
2827  // parameters and template arguments. This can happen, for example, when
2828  // substituting the outer template arguments ends up causing two
2829  // class template partial specializations of a member class template
2830  // to have identical forms, e.g.,
2831  //
2832  // template<typename T, typename U>
2833  // struct Outer {
2834  // template<typename X, typename Y> struct Inner;
2835  // template<typename Y> struct Inner<T, Y>;
2836  // template<typename Y> struct Inner<U, Y>;
2837  // };
2838  //
2839  // Outer<int, int> outer; // error: the partial specializations of Inner
2840  // // have the same signature.
2841  SemaRef.Diag(PartialSpec->getLocation(), diag::err_partial_spec_redeclared)
2842  << WrittenTy->getType();
2843  SemaRef.Diag(PrevDecl->getLocation(), diag::note_prev_partial_spec_here)
2844  << SemaRef.Context.getTypeDeclType(PrevDecl);
2845  return nullptr;
2846  }
2847 
2848 
2849  // Create the class template partial specialization declaration.
2852  PartialSpec->getTagKind(),
2853  Owner,
2854  PartialSpec->getLocStart(),
2855  PartialSpec->getLocation(),
2856  InstParams,
2857  ClassTemplate,
2858  Converted.data(),
2859  Converted.size(),
2860  InstTemplateArgs,
2861  CanonType,
2862  nullptr);
2863  // Substitute the nested name specifier, if any.
2864  if (SubstQualifier(PartialSpec, InstPartialSpec))
2865  return nullptr;
2866 
2867  InstPartialSpec->setInstantiatedFromMember(PartialSpec);
2868  InstPartialSpec->setTypeAsWritten(WrittenTy);
2869 
2870  // Add this partial specialization to the set of class template partial
2871  // specializations.
2872  ClassTemplate->AddPartialSpecialization(InstPartialSpec,
2873  /*InsertPos=*/nullptr);
2874  return InstPartialSpec;
2875 }
2876 
2877 /// \brief Instantiate the declaration of a variable template partial
2878 /// specialization.
2879 ///
2880 /// \param VarTemplate the (instantiated) variable template that is partially
2881 /// specialized by the instantiation of \p PartialSpec.
2882 ///
2883 /// \param PartialSpec the (uninstantiated) variable template partial
2884 /// specialization that we are instantiating.
2885 ///
2886 /// \returns The instantiated partial specialization, if successful; otherwise,
2887 /// NULL to indicate an error.
2890  VarTemplateDecl *VarTemplate,
2891  VarTemplatePartialSpecializationDecl *PartialSpec) {
2892  // Create a local instantiation scope for this variable template partial
2893  // specialization, which will contain the instantiations of the template
2894  // parameters.
2895  LocalInstantiationScope Scope(SemaRef);
2896 
2897  // Substitute into the template parameters of the variable template partial
2898  // specialization.
2899  TemplateParameterList *TempParams = PartialSpec->getTemplateParameters();
2900  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
2901  if (!InstParams)
2902  return nullptr;
2903 
2904  // Substitute into the template arguments of the variable template partial
2905  // specialization.
2906  const ASTTemplateArgumentListInfo *TemplArgInfo
2907  = PartialSpec->getTemplateArgsAsWritten();
2908  TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
2909  TemplArgInfo->RAngleLoc);
2910  if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
2911  TemplArgInfo->NumTemplateArgs,
2912  InstTemplateArgs, TemplateArgs))
2913  return nullptr;
2914 
2915  // Check that the template argument list is well-formed for this
2916  // class template.
2918  if (SemaRef.CheckTemplateArgumentList(VarTemplate, PartialSpec->getLocation(),
2919  InstTemplateArgs, false, Converted))
2920  return nullptr;
2921 
2922  // Figure out where to insert this variable template partial specialization
2923  // in the member template's set of variable template partial specializations.
2924  void *InsertPos = nullptr;
2925  VarTemplateSpecializationDecl *PrevDecl =
2926  VarTemplate->findPartialSpecialization(Converted, InsertPos);
2927 
2928  // Build the canonical type that describes the converted template
2929  // arguments of the variable template partial specialization.
2930  QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
2931  TemplateName(VarTemplate), Converted.data(), Converted.size());
2932 
2933  // Build the fully-sugared type for this variable template
2934  // specialization as the user wrote in the specialization
2935  // itself. This means that we'll pretty-print the type retrieved
2936  // from the specialization's declaration the way that the user
2937  // actually wrote the specialization, rather than formatting the
2938  // name based on the "canonical" representation used to store the
2939  // template arguments in the specialization.
2941  TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
2942  CanonType);
2943 
2944  if (PrevDecl) {
2945  // We've already seen a partial specialization with the same template
2946  // parameters and template arguments. This can happen, for example, when
2947  // substituting the outer template arguments ends up causing two
2948  // variable template partial specializations of a member variable template
2949  // to have identical forms, e.g.,
2950  //
2951  // template<typename T, typename U>
2952  // struct Outer {
2953  // template<typename X, typename Y> pair<X,Y> p;
2954  // template<typename Y> pair<T, Y> p;
2955  // template<typename Y> pair<U, Y> p;
2956  // };
2957  //
2958  // Outer<int, int> outer; // error: the partial specializations of Inner
2959  // // have the same signature.
2960  SemaRef.Diag(PartialSpec->getLocation(),
2961  diag::err_var_partial_spec_redeclared)
2962  << WrittenTy->getType();
2963  SemaRef.Diag(PrevDecl->getLocation(),
2964  diag::note_var_prev_partial_spec_here);
2965  return nullptr;
2966  }
2967 
2968  // Do substitution on the type of the declaration
2969  TypeSourceInfo *DI = SemaRef.SubstType(
2970  PartialSpec->getTypeSourceInfo(), TemplateArgs,
2971  PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName());
2972  if (!DI)
2973  return nullptr;
2974 
2975  if (DI->getType()->isFunctionType()) {
2976  SemaRef.Diag(PartialSpec->getLocation(),
2977  diag::err_variable_instantiates_to_function)
2978  << PartialSpec->isStaticDataMember() << DI->getType();
2979  return nullptr;
2980  }
2981 
2982  // Create the variable template partial specialization declaration.
2983  VarTemplatePartialSpecializationDecl *InstPartialSpec =
2985  SemaRef.Context, Owner, PartialSpec->getInnerLocStart(),
2986  PartialSpec->getLocation(), InstParams, VarTemplate, DI->getType(),
2987  DI, PartialSpec->getStorageClass(), Converted.data(),
2988  Converted.size(), InstTemplateArgs);
2989 
2990  // Substitute the nested name specifier, if any.
2991  if (SubstQualifier(PartialSpec, InstPartialSpec))
2992  return nullptr;
2993 
2994  InstPartialSpec->setInstantiatedFromMember(PartialSpec);
2995  InstPartialSpec->setTypeAsWritten(WrittenTy);
2996 
2997  // Add this partial specialization to the set of variable template partial
2998  // specializations. The instantiation of the initializer is not necessary.
2999  VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/nullptr);
3000 
3001  SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs,
3002  LateAttrs, Owner, StartingScope);
3003 
3004  return InstPartialSpec;
3005 }
3006 
3010  TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
3011  assert(OldTInfo && "substituting function without type source info");
3012  assert(Params.empty() && "parameter vector is non-empty at start");
3013 
3014  CXXRecordDecl *ThisContext = nullptr;
3015  unsigned ThisTypeQuals = 0;
3016  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
3017  ThisContext = cast<CXXRecordDecl>(Owner);
3018  ThisTypeQuals = Method->getTypeQualifiers();
3019  }
3020 
3021  TypeSourceInfo *NewTInfo
3022  = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
3023  D->getTypeSpecStartLoc(),
3024  D->getDeclName(),
3025  ThisContext, ThisTypeQuals);
3026  if (!NewTInfo)
3027  return nullptr;
3028 
3029  TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
3030  if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
3031  if (NewTInfo != OldTInfo) {
3032  // Get parameters from the new type info.
3033  TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
3034  FunctionProtoTypeLoc NewProtoLoc = NewTL.castAs<FunctionProtoTypeLoc>();
3035  unsigned NewIdx = 0;
3036  for (unsigned OldIdx = 0, NumOldParams = OldProtoLoc.getNumParams();
3037  OldIdx != NumOldParams; ++OldIdx) {
3038  ParmVarDecl *OldParam = OldProtoLoc.getParam(OldIdx);
3040 
3041  Optional<unsigned> NumArgumentsInExpansion;
3042  if (OldParam->isParameterPack())
3043  NumArgumentsInExpansion =
3044  SemaRef.getNumArgumentsInExpansion(OldParam->getType(),
3045  TemplateArgs);
3046  if (!NumArgumentsInExpansion) {
3047  // Simple case: normal parameter, or a parameter pack that's
3048  // instantiated to a (still-dependent) parameter pack.
3049  ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
3050  Params.push_back(NewParam);
3051  Scope->InstantiatedLocal(OldParam, NewParam);
3052  } else {
3053  // Parameter pack expansion: make the instantiation an argument pack.
3054  Scope->MakeInstantiatedLocalArgPack(OldParam);
3055  for (unsigned I = 0; I != *NumArgumentsInExpansion; ++I) {
3056  ParmVarDecl *NewParam = NewProtoLoc.getParam(NewIdx++);
3057  Params.push_back(NewParam);
3058  Scope->InstantiatedLocalPackArg(OldParam, NewParam);
3059  }
3060  }
3061  }
3062  } else {
3063  // The function type itself was not dependent and therefore no
3064  // substitution occurred. However, we still need to instantiate
3065  // the function parameters themselves.
3066  const FunctionProtoType *OldProto =
3067  cast<FunctionProtoType>(OldProtoLoc.getType());
3068  for (unsigned i = 0, i_end = OldProtoLoc.getNumParams(); i != i_end;
3069  ++i) {
3070  ParmVarDecl *OldParam = OldProtoLoc.getParam(i);
3071  if (!OldParam) {
3072  Params.push_back(SemaRef.BuildParmVarDeclForTypedef(
3073  D, D->getLocation(), OldProto->getParamType(i)));
3074  continue;
3075  }
3076 
3077  ParmVarDecl *Parm =
3078  cast_or_null<ParmVarDecl>(VisitParmVarDecl(OldParam));
3079  if (!Parm)
3080  return nullptr;
3081  Params.push_back(Parm);
3082  }
3083  }
3084  } else {
3085  // If the type of this function, after ignoring parentheses, is not
3086  // *directly* a function type, then we're instantiating a function that
3087  // was declared via a typedef or with attributes, e.g.,
3088  //
3089  // typedef int functype(int, int);
3090  // functype func;
3091  // int __cdecl meth(int, int);
3092  //
3093  // In this case, we'll just go instantiate the ParmVarDecls that we
3094  // synthesized in the method declaration.
3095  SmallVector<QualType, 4> ParamTypes;
3096  if (SemaRef.SubstParmTypes(D->getLocation(), D->param_begin(),
3097  D->getNumParams(), TemplateArgs, ParamTypes,
3098  &Params))
3099  return nullptr;
3100  }
3101 
3102  return NewTInfo;
3103 }
3104 
3105 /// Introduce the instantiated function parameters into the local
3106 /// instantiation scope, and set the parameter names to those used
3107 /// in the template.
3109  const FunctionDecl *PatternDecl,
3111  const MultiLevelTemplateArgumentList &TemplateArgs) {
3112  unsigned FParamIdx = 0;
3113  for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
3114  const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
3115  if (!PatternParam->isParameterPack()) {
3116  // Simple case: not a parameter pack.
3117  assert(FParamIdx < Function->getNumParams());
3118  ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
3119  FunctionParam->setDeclName(PatternParam->getDeclName());
3120  // If the parameter's type is not dependent, update it to match the type
3121  // in the pattern. They can differ in top-level cv-qualifiers, and we want
3122  // the pattern's type here. If the type is dependent, they can't differ,
3123  // per core issue 1668. Substitute into the type from the pattern, in case
3124  // it's instantiation-dependent.
3125  // FIXME: Updating the type to work around this is at best fragile.
3126  if (!PatternDecl->getType()->isDependentType()) {
3127  QualType T = S.SubstType(PatternParam->getType(), TemplateArgs,
3128  FunctionParam->getLocation(),
3129  FunctionParam->getDeclName());
3130  if (T.isNull())
3131  return true;
3132  FunctionParam->setType(T);
3133  }
3134 
3135  Scope.InstantiatedLocal(PatternParam, FunctionParam);
3136  ++FParamIdx;
3137  continue;
3138  }
3139 
3140  // Expand the parameter pack.
3141  Scope.MakeInstantiatedLocalArgPack(PatternParam);
3142  Optional<unsigned> NumArgumentsInExpansion
3143  = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
3144  assert(NumArgumentsInExpansion &&
3145  "should only be called when all template arguments are known");
3146  QualType PatternType =
3147  PatternParam->getType()->castAs<PackExpansionType>()->getPattern();
3148  for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
3149  ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
3150  FunctionParam->setDeclName(PatternParam->getDeclName());
3151  if (!PatternDecl->getType()->isDependentType()) {
3152  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, Arg);
3153  QualType T = S.SubstType(PatternType, TemplateArgs,
3154  FunctionParam->getLocation(),
3155  FunctionParam->getDeclName());
3156  if (T.isNull())
3157  return true;
3158  FunctionParam->setType(T);
3159  }
3160 
3161  Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
3162  ++FParamIdx;
3163  }
3164  }
3165 
3166  return false;
3167 }
3168 
3170  FunctionDecl *Decl) {
3171  const FunctionProtoType *Proto = Decl->getType()->castAs<FunctionProtoType>();
3172  if (Proto->getExceptionSpecType() != EST_Uninstantiated)
3173  return;
3174 
3175  InstantiatingTemplate Inst(*this, PointOfInstantiation, Decl,
3177  if (Inst.isInvalid()) {
3178  // We hit the instantiation depth limit. Clear the exception specification
3179  // so that our callers don't have to cope with EST_Uninstantiated.
3181  return;
3182  }
3183 
3184  // Enter the scope of this instantiation. We don't use
3185  // PushDeclContext because we don't have a scope.
3186  Sema::ContextRAII savedContext(*this, Decl);
3188 
3189  MultiLevelTemplateArgumentList TemplateArgs =
3190  getTemplateInstantiationArgs(Decl, nullptr, /*RelativeToPrimary*/true);
3191 
3192  FunctionDecl *Template = Proto->getExceptionSpecTemplate();
3193  if (addInstantiatedParametersToScope(*this, Decl, Template, Scope,
3194  TemplateArgs)) {
3196  return;
3197  }
3198 
3199  SubstExceptionSpec(Decl, Template->getType()->castAs<FunctionProtoType>(),
3200  TemplateArgs);
3201 }
3202 
3203 /// \brief Initializes the common fields of an instantiation function
3204 /// declaration (New) from the corresponding fields of its template (Tmpl).
3205 ///
3206 /// \returns true if there was an error
3207 bool
3209  FunctionDecl *Tmpl) {
3210  if (Tmpl->isDeleted())
3211  New->setDeletedAsWritten();
3212 
3213  // Forward the mangling number from the template to the instantiated decl.
3214  SemaRef.Context.setManglingNumber(New,
3215  SemaRef.Context.getManglingNumber(Tmpl));
3216 
3217  // If we are performing substituting explicitly-specified template arguments
3218  // or deduced template arguments into a function template and we reach this
3219  // point, we are now past the point where SFINAE applies and have committed
3220  // to keeping the new function template specialization. We therefore
3221  // convert the active template instantiation for the function template
3222  // into a template instantiation for this specific function template
3223  // specialization, which is not a SFINAE context, so that we diagnose any
3224  // further errors in the declaration itself.
3225  typedef Sema::ActiveTemplateInstantiation ActiveInstType;
3226  ActiveInstType &ActiveInst = SemaRef.ActiveTemplateInstantiations.back();
3227  if (ActiveInst.Kind == ActiveInstType::ExplicitTemplateArgumentSubstitution ||
3228  ActiveInst.Kind == ActiveInstType::DeducedTemplateArgumentSubstitution) {
3229  if (FunctionTemplateDecl *FunTmpl
3230  = dyn_cast<FunctionTemplateDecl>(ActiveInst.Entity)) {
3231  assert(FunTmpl->getTemplatedDecl() == Tmpl &&
3232  "Deduction from the wrong function template?");
3233  (void) FunTmpl;
3234  ActiveInst.Kind = ActiveInstType::TemplateInstantiation;
3235  ActiveInst.Entity = New;
3236  }
3237  }
3238 
3239  const FunctionProtoType *Proto = Tmpl->getType()->getAs<FunctionProtoType>();
3240  assert(Proto && "Function template without prototype?");
3241 
3242  if (Proto->hasExceptionSpec() || Proto->getNoReturnAttr()) {
3244 
3245  // DR1330: In C++11, defer instantiation of a non-trivial
3246  // exception specification.
3247  // DR1484: Local classes and their members are instantiated along with the
3248  // containing function.
3249  bool RequireInstantiation = false;
3250  if (CXXRecordDecl *Cls = dyn_cast<CXXRecordDecl>(Tmpl->getDeclContext())) {
3251  if (Cls->isLocalClass())
3252  RequireInstantiation = true;
3253  }
3254  if (SemaRef.getLangOpts().CPlusPlus11 &&
3255  EPI.ExceptionSpec.Type != EST_None &&
3258  !RequireInstantiation) {
3259  FunctionDecl *ExceptionSpecTemplate = Tmpl;
3261  ExceptionSpecTemplate = EPI.ExceptionSpec.SourceTemplate;
3263  if (EPI.ExceptionSpec.Type == EST_Unevaluated)
3264  NewEST = EST_Unevaluated;
3265 
3266  // Mark the function has having an uninstantiated exception specification.
3267  const FunctionProtoType *NewProto
3268  = New->getType()->getAs<FunctionProtoType>();
3269  assert(NewProto && "Template instantiation without function prototype?");
3270  EPI = NewProto->getExtProtoInfo();
3271  EPI.ExceptionSpec.Type = NewEST;
3272  EPI.ExceptionSpec.SourceDecl = New;
3273  EPI.ExceptionSpec.SourceTemplate = ExceptionSpecTemplate;
3274  New->setType(SemaRef.Context.getFunctionType(
3275  NewProto->getReturnType(), NewProto->getParamTypes(), EPI));
3276  } else {
3277  SemaRef.SubstExceptionSpec(New, Proto, TemplateArgs);
3278  }
3279  }
3280 
3281  // Get the definition. Leaves the variable unchanged if undefined.
3282  const FunctionDecl *Definition = Tmpl;
3283  Tmpl->isDefined(Definition);
3284 
3285  SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
3286  LateAttrs, StartingScope);
3287 
3288  return false;
3289 }
3290 
3291 /// \brief Initializes common fields of an instantiated method
3292 /// declaration (New) from the corresponding fields of its template
3293 /// (Tmpl).
3294 ///
3295 /// \returns true if there was an error
3296 bool
3298  CXXMethodDecl *Tmpl) {
3299  if (InitFunctionInstantiation(New, Tmpl))
3300  return true;
3301 
3302  New->setAccess(Tmpl->getAccess());
3303  if (Tmpl->isVirtualAsWritten())
3304  New->setVirtualAsWritten(true);
3305 
3306  // FIXME: New needs a pointer to Tmpl
3307  return false;
3308 }
3309 
3310 /// \brief Instantiate the definition of the given function from its
3311 /// template.
3312 ///
3313 /// \param PointOfInstantiation the point at which the instantiation was
3314 /// required. Note that this is not precisely a "point of instantiation"
3315 /// for the function, but it's close.
3316 ///
3317 /// \param Function the already-instantiated declaration of a
3318 /// function template specialization or member function of a class template
3319 /// specialization.
3320 ///
3321 /// \param Recursive if true, recursively instantiates any functions that
3322 /// are required by this instantiation.
3323 ///
3324 /// \param DefinitionRequired if true, then we are performing an explicit
3325 /// instantiation where the body of the function is required. Complain if
3326 /// there is no such body.
3328  FunctionDecl *Function,
3329  bool Recursive,
3330  bool DefinitionRequired) {
3331  if (Function->isInvalidDecl() || Function->isDefined())
3332  return;
3333 
3334  // Never instantiate an explicit specialization except if it is a class scope
3335  // explicit specialization.
3338  return;
3339 
3340  // Find the function body that we'll be substituting.
3341  const FunctionDecl *PatternDecl = Function->getTemplateInstantiationPattern();
3342  assert(PatternDecl && "instantiating a non-template");
3343 
3344  Stmt *Pattern = PatternDecl->getBody(PatternDecl);
3345  assert(PatternDecl && "template definition is not a template");
3346  if (!Pattern) {
3347  // Try to find a defaulted definition
3348  PatternDecl->isDefined(PatternDecl);
3349  }
3350  assert(PatternDecl && "template definition is not a template");
3351 
3352  // Postpone late parsed template instantiations.
3353  if (PatternDecl->isLateTemplateParsed() &&
3354  !LateTemplateParser) {
3355  PendingInstantiations.push_back(
3356  std::make_pair(Function, PointOfInstantiation));
3357  return;
3358  }
3359 
3360  // If we're performing recursive template instantiation, create our own
3361  // queue of pending implicit instantiations that we will instantiate later,
3362  // while we're still within our own instantiation context.
3363  // This has to happen before LateTemplateParser below is called, so that
3364  // it marks vtables used in late parsed templates as used.
3366  SavedPendingLocalImplicitInstantiations(*this);
3368  SavePendingInstantiationsAndVTableUses(*this, /*Enabled=*/Recursive);
3369 
3370  // Call the LateTemplateParser callback if there is a need to late parse
3371  // a templated function definition.
3372  if (!Pattern && PatternDecl->isLateTemplateParsed() &&
3374  // FIXME: Optimize to allow individual templates to be deserialized.
3375  if (PatternDecl->isFromASTFile())
3377 
3378  LateParsedTemplate *LPT = LateParsedTemplateMap.lookup(PatternDecl);
3379  assert(LPT && "missing LateParsedTemplate");
3381  Pattern = PatternDecl->getBody(PatternDecl);
3382  }
3383 
3384  if (!Pattern && !PatternDecl->isDefaulted()) {
3385  if (DefinitionRequired) {
3386  if (Function->getPrimaryTemplate())
3387  Diag(PointOfInstantiation,
3388  diag::err_explicit_instantiation_undefined_func_template)
3389  << Function->getPrimaryTemplate();
3390  else
3391  Diag(PointOfInstantiation,
3392  diag::err_explicit_instantiation_undefined_member)
3393  << 1 << Function->getDeclName() << Function->getDeclContext();
3394 
3395  if (PatternDecl)
3396  Diag(PatternDecl->getLocation(),
3397  diag::note_explicit_instantiation_here);
3398  Function->setInvalidDecl();
3399  } else if (Function->getTemplateSpecializationKind()
3401  assert(!Recursive);
3402  PendingInstantiations.push_back(
3403  std::make_pair(Function, PointOfInstantiation));
3404  }
3405 
3406  return;
3407  }
3408 
3409  // C++1y [temp.explicit]p10:
3410  // Except for inline functions, declarations with types deduced from their
3411  // initializer or return value, and class template specializations, other
3412  // explicit instantiation declarations have the effect of suppressing the
3413  // implicit instantiation of the entity to which they refer.
3414  if (Function->getTemplateSpecializationKind() ==
3416  !PatternDecl->isInlined() &&
3417  !PatternDecl->getReturnType()->getContainedAutoType())
3418  return;
3419 
3420  if (PatternDecl->isInlined()) {
3421  // Function, and all later redeclarations of it (from imported modules,
3422  // for instance), are now implicitly inline.
3423  for (auto *D = Function->getMostRecentDecl(); /**/;
3424  D = D->getPreviousDecl()) {
3425  D->setImplicitlyInline();
3426  if (D == Function)
3427  break;
3428  }
3429  }
3430 
3431  InstantiatingTemplate Inst(*this, PointOfInstantiation, Function);
3432  if (Inst.isInvalid())
3433  return;
3434 
3435  // Copy the inner loc start from the pattern.
3436  Function->setInnerLocStart(PatternDecl->getInnerLocStart());
3437 
3438  EnterExpressionEvaluationContext EvalContext(*this,
3440 
3441  // Introduce a new scope where local variable instantiations will be
3442  // recorded, unless we're actually a member function within a local
3443  // class, in which case we need to merge our results with the parent
3444  // scope (of the enclosing function).
3445  bool MergeWithParentScope = false;
3446  if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Function->getDeclContext()))
3447  MergeWithParentScope = Rec->isLocalClass();
3448 
3449  LocalInstantiationScope Scope(*this, MergeWithParentScope);
3450 
3451  if (PatternDecl->isDefaulted())
3452  SetDeclDefaulted(Function, PatternDecl->getLocation());
3453  else {
3454  MultiLevelTemplateArgumentList TemplateArgs =
3455  getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl);
3456 
3457  // Substitute into the qualifier; we can get a substitution failure here
3458  // through evil use of alias templates.
3459  // FIXME: Is CurContext correct for this? Should we go to the (instantiation
3460  // of the) lexical context of the pattern?
3461  SubstQualifier(*this, PatternDecl, Function, TemplateArgs);
3462 
3463  ActOnStartOfFunctionDef(nullptr, Function);
3464 
3465  // Enter the scope of this instantiation. We don't use
3466  // PushDeclContext because we don't have a scope.
3467  Sema::ContextRAII savedContext(*this, Function);
3468 
3469  if (addInstantiatedParametersToScope(*this, Function, PatternDecl, Scope,
3470  TemplateArgs))
3471  return;
3472 
3473  // If this is a constructor, instantiate the member initializers.
3474  if (const CXXConstructorDecl *Ctor =
3475  dyn_cast<CXXConstructorDecl>(PatternDecl)) {
3476  InstantiateMemInitializers(cast<CXXConstructorDecl>(Function), Ctor,
3477  TemplateArgs);
3478  }
3479 
3480  // Instantiate the function body.
3481  StmtResult Body = SubstStmt(Pattern, TemplateArgs);
3482 
3483  if (Body.isInvalid())
3484  Function->setInvalidDecl();
3485 
3486  ActOnFinishFunctionBody(Function, Body.get(),
3487  /*IsInstantiation=*/true);
3488 
3489  PerformDependentDiagnostics(PatternDecl, TemplateArgs);
3490 
3491  if (auto *Listener = getASTMutationListener())
3492  Listener->FunctionDefinitionInstantiated(Function);
3493 
3494  savedContext.pop();
3495  }
3496 
3497  DeclGroupRef DG(Function);
3499 
3500  // This class may have local implicit instantiations that need to be
3501  // instantiation within this scope.
3502  PerformPendingInstantiations(/*LocalOnly=*/true);
3503  Scope.Exit();
3504 
3505  if (Recursive) {
3506  // Define any pending vtables.
3508 
3509  // Instantiate any pending implicit instantiations found during the
3510  // instantiation of this template.
3512 
3513  // PendingInstantiations and VTableUses are restored through
3514  // SavePendingInstantiationsAndVTableUses's destructor.
3515  }
3516 }
3517 
3519  VarTemplateDecl *VarTemplate, VarDecl *FromVar,
3520  const TemplateArgumentList &TemplateArgList,
3521  const TemplateArgumentListInfo &TemplateArgsInfo,
3523  SourceLocation PointOfInstantiation, void *InsertPos,
3524  LateInstantiatedAttrVec *LateAttrs,
3525  LocalInstantiationScope *StartingScope) {
3526  if (FromVar->isInvalidDecl())
3527  return nullptr;
3528 
3529  InstantiatingTemplate Inst(*this, PointOfInstantiation, FromVar);
3530  if (Inst.isInvalid())
3531  return nullptr;
3532 
3533  MultiLevelTemplateArgumentList TemplateArgLists;
3534  TemplateArgLists.addOuterTemplateArguments(&TemplateArgList);
3535 
3536  // Instantiate the first declaration of the variable template: for a partial
3537  // specialization of a static data member template, the first declaration may
3538  // or may not be the declaration in the class; if it's in the class, we want
3539  // to instantiate a member in the class (a declaration), and if it's outside,
3540  // we want to instantiate a definition.
3541  //
3542  // If we're instantiating an explicitly-specialized member template or member
3543  // partial specialization, don't do this. The member specialization completely
3544  // replaces the original declaration in this case.
3545  bool IsMemberSpec = false;
3546  if (VarTemplatePartialSpecializationDecl *PartialSpec =
3547  dyn_cast<VarTemplatePartialSpecializationDecl>(FromVar))
3548  IsMemberSpec = PartialSpec->isMemberSpecialization();
3549  else if (VarTemplateDecl *FromTemplate = FromVar->getDescribedVarTemplate())
3550  IsMemberSpec = FromTemplate->isMemberSpecialization();
3551  if (!IsMemberSpec)
3552  FromVar = FromVar->getFirstDecl();
3553 
3554  MultiLevelTemplateArgumentList MultiLevelList(TemplateArgList);
3555  TemplateDeclInstantiator Instantiator(*this, FromVar->getDeclContext(),
3556  MultiLevelList);
3557 
3558  // TODO: Set LateAttrs and StartingScope ...
3559 
3560  return cast_or_null<VarTemplateSpecializationDecl>(
3561  Instantiator.VisitVarTemplateSpecializationDecl(
3562  VarTemplate, FromVar, InsertPos, TemplateArgsInfo, Converted));
3563 }
3564 
3565 /// \brief Instantiates a variable template specialization by completing it
3566 /// with appropriate type information and initializer.
3568  VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
3569  const MultiLevelTemplateArgumentList &TemplateArgs) {
3570 
3571  // Do substitution on the type of the declaration
3572  TypeSourceInfo *DI =
3573  SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
3574  PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
3575  if (!DI)
3576  return nullptr;
3577 
3578  // Update the type of this variable template specialization.
3579  VarSpec->setType(DI->getType());
3580 
3581  // Instantiate the initializer.
3582  InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs);
3583 
3584  return VarSpec;
3585 }
3586 
3587 /// BuildVariableInstantiation - Used after a new variable has been created.
3588 /// Sets basic variable data and decides whether to postpone the
3589 /// variable instantiation.
3591  VarDecl *NewVar, VarDecl *OldVar,
3592  const MultiLevelTemplateArgumentList &TemplateArgs,
3593  LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner,
3594  LocalInstantiationScope *StartingScope,
3595  bool InstantiatingVarTemplate) {
3596 
3597  // If we are instantiating a local extern declaration, the
3598  // instantiation belongs lexically to the containing function.
3599  // If we are instantiating a static data member defined
3600  // out-of-line, the instantiation will have the same lexical
3601  // context (which will be a namespace scope) as the template.
3602  if (OldVar->isLocalExternDecl()) {
3603  NewVar->setLocalExternDecl();
3604  NewVar->setLexicalDeclContext(Owner);
3605  } else if (OldVar->isOutOfLine())
3606  NewVar->setLexicalDeclContext(OldVar->getLexicalDeclContext());
3607  NewVar->setTSCSpec(OldVar->getTSCSpec());
3608  NewVar->setInitStyle(OldVar->getInitStyle());
3609  NewVar->setCXXForRangeDecl(OldVar->isCXXForRangeDecl());
3610  NewVar->setConstexpr(OldVar->isConstexpr());
3611  NewVar->setInitCapture(OldVar->isInitCapture());
3613  OldVar->isPreviousDeclInSameBlockScope());
3614  NewVar->setAccess(OldVar->getAccess());
3615 
3616  if (!OldVar->isStaticDataMember()) {
3617  if (OldVar->isUsed(false))
3618  NewVar->setIsUsed();
3619  NewVar->setReferenced(OldVar->isReferenced());
3620  }
3621 
3622  // See if the old variable had a type-specifier that defined an anonymous tag.
3623  // If it did, mark the new variable as being the declarator for the new
3624  // anonymous tag.
3625  if (const TagType *OldTagType = OldVar->getType()->getAs<TagType>()) {
3626  TagDecl *OldTag = OldTagType->getDecl();
3627  if (OldTag->getDeclaratorForAnonDecl() == OldVar) {
3628  TagDecl *NewTag = NewVar->getType()->castAs<TagType>()->getDecl();
3629  assert(!NewTag->hasNameForLinkage() &&
3630  !NewTag->hasDeclaratorForAnonDecl());
3631  NewTag->setDeclaratorForAnonDecl(NewVar);
3632  }
3633  }
3634 
3635  InstantiateAttrs(TemplateArgs, OldVar, NewVar, LateAttrs, StartingScope);
3636 
3638  *this, NewVar->getDeclName(), NewVar->getLocation(),
3642 
3643  if (NewVar->isLocalExternDecl() && OldVar->getPreviousDecl() &&
3645  OldVar->getPreviousDecl()->getDeclContext()==OldVar->getDeclContext())) {
3646  // We have a previous declaration. Use that one, so we merge with the
3647  // right type.
3648  if (NamedDecl *NewPrev = FindInstantiatedDecl(
3649  NewVar->getLocation(), OldVar->getPreviousDecl(), TemplateArgs))
3650  Previous.addDecl(NewPrev);
3651  } else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
3652  OldVar->hasLinkage())
3653  LookupQualifiedName(Previous, NewVar->getDeclContext(), false);
3655 
3656  if (!InstantiatingVarTemplate) {
3657  NewVar->getLexicalDeclContext()->addHiddenDecl(NewVar);
3658  if (!NewVar->isLocalExternDecl() || !NewVar->getPreviousDecl())
3659  NewVar->getDeclContext()->makeDeclVisibleInContext(NewVar);
3660  }
3661 
3662  if (!OldVar->isOutOfLine()) {
3663  if (NewVar->getDeclContext()->isFunctionOrMethod())
3665  }
3666 
3667  // Link instantiations of static data members back to the template from
3668  // which they were instantiated.
3669  if (NewVar->isStaticDataMember() && !InstantiatingVarTemplate)
3670  NewVar->setInstantiationOfStaticDataMember(OldVar,
3671  TSK_ImplicitInstantiation);
3672 
3673  // Forward the mangling number from the template to the instantiated decl.
3676 
3677  // Delay instantiation of the initializer for variable templates until a
3678  // definition of the variable is needed. We need it right away if the type
3679  // contains 'auto'.
3680  if ((!isa<VarTemplateSpecializationDecl>(NewVar) &&
3681  !InstantiatingVarTemplate) ||
3682  NewVar->getType()->isUndeducedType())
3683  InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
3684 
3685  // Diagnose unused local variables with dependent types, where the diagnostic
3686  // will have been deferred.
3687  if (!NewVar->isInvalidDecl() &&
3688  NewVar->getDeclContext()->isFunctionOrMethod() &&
3689  OldVar->getType()->isDependentType())
3690  DiagnoseUnusedDecl(NewVar);
3691 }
3692 
3693 /// \brief Instantiate the initializer of a variable.
3695  VarDecl *Var, VarDecl *OldVar,
3696  const MultiLevelTemplateArgumentList &TemplateArgs) {
3697 
3698  if (Var->getAnyInitializer())
3699  // We already have an initializer in the class.
3700  return;
3701 
3702  if (OldVar->getInit()) {
3703  if (Var->isStaticDataMember() && !OldVar->isOutOfLine())
3705  else
3707 
3708  // Instantiate the initializer.
3709  ExprResult Init =
3710  SubstInitializer(OldVar->getInit(), TemplateArgs,
3711  OldVar->getInitStyle() == VarDecl::CallInit);
3712  if (!Init.isInvalid()) {
3713  bool TypeMayContainAuto = true;
3714  Expr *InitExpr = Init.get();
3715 
3716  if (Var->hasAttr<DLLImportAttr>() &&
3717  (!InitExpr ||
3718  !InitExpr->isConstantInitializer(getASTContext(), false))) {
3719  // Do not dynamically initialize dllimport variables.
3720  } else if (InitExpr) {
3721  bool DirectInit = OldVar->isDirectInit();
3722  AddInitializerToDecl(Var, InitExpr, DirectInit, TypeMayContainAuto);
3723  } else
3724  ActOnUninitializedDecl(Var, TypeMayContainAuto);
3725  } else {
3726  // FIXME: Not too happy about invalidating the declaration
3727  // because of a bogus initializer.
3728  Var->setInvalidDecl();
3729  }
3730 
3732  } else if ((!Var->isStaticDataMember() || Var->isOutOfLine()) &&
3733  !Var->isCXXForRangeDecl())
3734  ActOnUninitializedDecl(Var, false);
3735 }
3736 
3737 /// \brief Instantiate the definition of the given variable from its
3738 /// template.
3739 ///
3740 /// \param PointOfInstantiation the point at which the instantiation was
3741 /// required. Note that this is not precisely a "point of instantiation"
3742 /// for the function, but it's close.
3743 ///
3744 /// \param Var the already-instantiated declaration of a static member
3745 /// variable of a class template specialization.
3746 ///
3747 /// \param Recursive if true, recursively instantiates any functions that
3748 /// are required by this instantiation.
3749 ///
3750 /// \param DefinitionRequired if true, then we are performing an explicit
3751 /// instantiation where an out-of-line definition of the member variable
3752 /// is required. Complain if there is no such definition.
3754  SourceLocation PointOfInstantiation,
3755  VarDecl *Var,
3756  bool Recursive,
3757  bool DefinitionRequired) {
3758  InstantiateVariableDefinition(PointOfInstantiation, Var, Recursive,
3759  DefinitionRequired);
3760 }
3761 
3763  VarDecl *Var, bool Recursive,
3764  bool DefinitionRequired) {
3765  if (Var->isInvalidDecl())
3766  return;
3767 
3769  dyn_cast<VarTemplateSpecializationDecl>(Var);
3770  VarDecl *PatternDecl = nullptr, *Def = nullptr;
3771  MultiLevelTemplateArgumentList TemplateArgs =
3773 
3774  if (VarSpec) {
3775  // If this is a variable template specialization, make sure that it is
3776  // non-dependent, then find its instantiation pattern.
3777  bool InstantiationDependent = false;
3779  VarSpec->getTemplateArgsInfo(), InstantiationDependent) &&
3780  "Only instantiate variable template specializations that are "
3781  "not type-dependent");
3782  (void)InstantiationDependent;
3783 
3784  // Find the variable initialization that we'll be substituting. If the
3785  // pattern was instantiated from a member template, look back further to
3786  // find the real pattern.
3787  assert(VarSpec->getSpecializedTemplate() &&
3788  "Specialization without specialized template?");
3789  llvm::PointerUnion<VarTemplateDecl *,
3790  VarTemplatePartialSpecializationDecl *> PatternPtr =
3792  if (PatternPtr.is<VarTemplatePartialSpecializationDecl *>()) {
3794  PatternPtr.get<VarTemplatePartialSpecializationDecl *>();
3796  Tmpl->getInstantiatedFromMember()) {
3797  if (Tmpl->isMemberSpecialization())
3798  break;
3799 
3800  Tmpl = From;
3801  }
3802  PatternDecl = Tmpl;
3803  } else {
3804  VarTemplateDecl *Tmpl = PatternPtr.get<VarTemplateDecl *>();
3805  while (VarTemplateDecl *From =
3807  if (Tmpl->isMemberSpecialization())
3808  break;
3809 
3810  Tmpl = From;
3811  }
3812  PatternDecl = Tmpl->getTemplatedDecl();
3813  }
3814 
3815  // If this is a static data member template, there might be an
3816  // uninstantiated initializer on the declaration. If so, instantiate
3817  // it now.
3818  if (PatternDecl->isStaticDataMember() &&
3819  (PatternDecl = PatternDecl->getFirstDecl())->hasInit() &&
3820  !Var->hasInit()) {
3821  // FIXME: Factor out the duplicated instantiation context setup/tear down
3822  // code here.
3823  InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
3824  if (Inst.isInvalid())
3825  return;
3826 
3827  // If we're performing recursive template instantiation, create our own
3828  // queue of pending implicit instantiations that we will instantiate
3829  // later, while we're still within our own instantiation context.
3831  SavePendingInstantiationsAndVTableUses(*this, /*Enabled=*/Recursive);
3832 
3833  LocalInstantiationScope Local(*this);
3834 
3835  // Enter the scope of this instantiation. We don't use
3836  // PushDeclContext because we don't have a scope.
3837  ContextRAII PreviousContext(*this, Var->getDeclContext());
3838  InstantiateVariableInitializer(Var, PatternDecl, TemplateArgs);
3839  PreviousContext.pop();
3840 
3841  // FIXME: Need to inform the ASTConsumer that we instantiated the
3842  // initializer?
3843 
3844  // This variable may have local implicit instantiations that need to be
3845  // instantiated within this scope.
3846  PerformPendingInstantiations(/*LocalOnly=*/true);
3847 
3848  Local.Exit();
3849 
3850  if (Recursive) {
3851  // Define any newly required vtables.
3853 
3854  // Instantiate any pending implicit instantiations found during the
3855  // instantiation of this template.
3857 
3858  // PendingInstantiations and VTableUses are restored through
3859  // SavePendingInstantiationsAndVTableUses's destructor.
3860  }
3861  }
3862 
3863  // Find actual definition
3864  Def = PatternDecl->getDefinition(getASTContext());
3865  } else {
3866  // If this is a static data member, find its out-of-line definition.
3867  assert(Var->isStaticDataMember() && "not a static data member?");
3868  PatternDecl = Var->getInstantiatedFromStaticDataMember();
3869 
3870  assert(PatternDecl && "data member was not instantiated from a template?");
3871  assert(PatternDecl->isStaticDataMember() && "not a static data member?");
3872  Def = PatternDecl->getOutOfLineDefinition();
3873  }
3874 
3875  // If we don't have a definition of the variable template, we won't perform
3876  // any instantiation. Rather, we rely on the user to instantiate this
3877  // definition (or provide a specialization for it) in another translation
3878  // unit.
3879  if (!Def) {
3880  if (DefinitionRequired) {
3881  if (VarSpec)
3882  Diag(PointOfInstantiation,
3883  diag::err_explicit_instantiation_undefined_var_template) << Var;
3884  else
3885  Diag(PointOfInstantiation,
3886  diag::err_explicit_instantiation_undefined_member)
3887  << 2 << Var->getDeclName() << Var->getDeclContext();
3888  Diag(PatternDecl->getLocation(),
3889  diag::note_explicit_instantiation_here);
3890  if (VarSpec)
3891  Var->setInvalidDecl();
3892  } else if (Var->getTemplateSpecializationKind()
3894  PendingInstantiations.push_back(
3895  std::make_pair(Var, PointOfInstantiation));
3896  }
3897 
3898  return;
3899  }
3900 
3902 
3903  // Never instantiate an explicit specialization.
3904  if (TSK == TSK_ExplicitSpecialization)
3905  return;
3906 
3907  // C++11 [temp.explicit]p10:
3908  // Except for inline functions, [...] explicit instantiation declarations
3909  // have the effect of suppressing the implicit instantiation of the entity
3910  // to which they refer.
3912  return;
3913 
3914  // Make sure to pass the instantiated variable to the consumer at the end.
3915  struct PassToConsumerRAII {
3917  VarDecl *Var;
3918 
3919  PassToConsumerRAII(ASTConsumer &Consumer, VarDecl *Var)
3920  : Consumer(Consumer), Var(Var) { }
3921 
3922  ~PassToConsumerRAII() {
3924  }
3925  } PassToConsumerRAII(Consumer, Var);
3926 
3927  // If we already have a definition, we're done.
3928  if (VarDecl *Def = Var->getDefinition()) {
3929  // We may be explicitly instantiating something we've already implicitly
3930  // instantiated.
3932  PointOfInstantiation);
3933  return;
3934  }
3935 
3936  InstantiatingTemplate Inst(*this, PointOfInstantiation, Var);
3937  if (Inst.isInvalid())
3938  return;
3939 
3940  // If we're performing recursive template instantiation, create our own
3941  // queue of pending implicit instantiations that we will instantiate later,
3942  // while we're still within our own instantiation context.
3944  SavedPendingLocalImplicitInstantiations(*this);
3946  SavePendingInstantiationsAndVTableUses(*this, /*Enabled=*/Recursive);
3947 
3948  // Enter the scope of this instantiation. We don't use
3949  // PushDeclContext because we don't have a scope.
3950  ContextRAII PreviousContext(*this, Var->getDeclContext());
3951  LocalInstantiationScope Local(*this);
3952 
3953  VarDecl *OldVar = Var;
3954  if (!VarSpec)
3955  Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
3956  TemplateArgs));
3957  else if (Var->isStaticDataMember() &&
3958  Var->getLexicalDeclContext()->isRecord()) {
3959  // We need to instantiate the definition of a static data member template,
3960  // and all we have is the in-class declaration of it. Instantiate a separate
3961  // declaration of the definition.
3962  TemplateDeclInstantiator Instantiator(*this, Var->getDeclContext(),
3963  TemplateArgs);
3964  Var = cast_or_null<VarDecl>(Instantiator.VisitVarTemplateSpecializationDecl(
3965  VarSpec->getSpecializedTemplate(), Def, nullptr,
3966  VarSpec->getTemplateArgsInfo(), VarSpec->getTemplateArgs().asArray()));
3967  if (Var) {
3968  llvm::PointerUnion<VarTemplateDecl *,
3969  VarTemplatePartialSpecializationDecl *> PatternPtr =
3972  PatternPtr.dyn_cast<VarTemplatePartialSpecializationDecl *>())
3973  cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
3974  Partial, &VarSpec->getTemplateInstantiationArgs());
3975 
3976  // Merge the definition with the declaration.
3977  LookupResult R(*this, Var->getDeclName(), Var->getLocation(),
3979  R.addDecl(OldVar);
3980  MergeVarDecl(Var, R);
3981 
3982  // Attach the initializer.
3983  InstantiateVariableInitializer(Var, Def, TemplateArgs);
3984  }
3985  } else
3986  // Complete the existing variable's definition with an appropriately
3987  // substituted type and initializer.
3988  Var = CompleteVarTemplateSpecializationDecl(VarSpec, Def, TemplateArgs);
3989 
3990  PreviousContext.pop();
3991 
3992  if (Var) {
3993  PassToConsumerRAII.Var = Var;
3995  OldVar->getPointOfInstantiation());
3996  }
3997 
3998  // This variable may have local implicit instantiations that need to be
3999  // instantiated within this scope.
4000  PerformPendingInstantiations(/*LocalOnly=*/true);
4001 
4002  Local.Exit();
4003 
4004  if (Recursive) {
4005  // Define any newly required vtables.
4007 
4008  // Instantiate any pending implicit instantiations found during the
4009  // instantiation of this template.
4011 
4012  // PendingInstantiations and VTableUses are restored through
4013  // SavePendingInstantiationsAndVTableUses's destructor.
4014  }
4015 }
4016 
4017 void
4019  const CXXConstructorDecl *Tmpl,
4020  const MultiLevelTemplateArgumentList &TemplateArgs) {
4021 
4023  bool AnyErrors = Tmpl->isInvalidDecl();
4024 
4025  // Instantiate all the initializers.
4026  for (const auto *Init : Tmpl->inits()) {
4027  // Only instantiate written initializers, let Sema re-construct implicit
4028  // ones.
4029  if (!Init->isWritten())
4030  continue;
4031 
4032  SourceLocation EllipsisLoc;
4033 
4034  if (Init->isPackExpansion()) {
4035  // This is a pack expansion. We should expand it now.
4036  TypeLoc BaseTL = Init->getTypeSourceInfo()->getTypeLoc();
4038  collectUnexpandedParameterPacks(BaseTL, Unexpanded);
4039  collectUnexpandedParameterPacks(Init->getInit(), Unexpanded);
4040  bool ShouldExpand = false;
4041  bool RetainExpansion = false;
4042  Optional<unsigned> NumExpansions;
4043  if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(),
4044  BaseTL.getSourceRange(),
4045  Unexpanded,
4046  TemplateArgs, ShouldExpand,
4047  RetainExpansion,
4048  NumExpansions)) {
4049  AnyErrors = true;
4050  New->setInvalidDecl();
4051  continue;
4052  }
4053  assert(ShouldExpand && "Partial instantiation of base initializer?");
4054 
4055  // Loop over all of the arguments in the argument pack(s),
4056  for (unsigned I = 0; I != *NumExpansions; ++I) {
4057  Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
4058 
4059  // Instantiate the initializer.
4060  ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4061  /*CXXDirectInit=*/true);
4062  if (TempInit.isInvalid()) {
4063  AnyErrors = true;
4064  break;
4065  }
4066 
4067  // Instantiate the base type.
4068  TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
4069  TemplateArgs,
4070  Init->getSourceLocation(),
4071  New->getDeclName());
4072  if (!BaseTInfo) {
4073  AnyErrors = true;
4074  break;
4075  }
4076 
4077  // Build the initializer.
4078  MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
4079  BaseTInfo, TempInit.get(),
4080  New->getParent(),
4081  SourceLocation());
4082  if (NewInit.isInvalid()) {
4083  AnyErrors = true;
4084  break;
4085  }
4086 
4087  NewInits.push_back(NewInit.get());
4088  }
4089 
4090  continue;
4091  }
4092 
4093  // Instantiate the initializer.
4094  ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
4095  /*CXXDirectInit=*/true);
4096  if (TempInit.isInvalid()) {
4097  AnyErrors = true;
4098  continue;
4099  }
4100 
4101  MemInitResult NewInit;
4102  if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
4103  TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
4104  TemplateArgs,
4105  Init->getSourceLocation(),
4106  New->getDeclName());
4107  if (!TInfo) {
4108  AnyErrors = true;
4109  New->setInvalidDecl();
4110  continue;
4111  }
4112 
4113  if (Init->isBaseInitializer())
4114  NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.get(),
4115  New->getParent(), EllipsisLoc);
4116  else
4117  NewInit = BuildDelegatingInitializer(TInfo, TempInit.get(),
4118  cast<CXXRecordDecl>(CurContext->getParent()));
4119  } else if (Init->isMemberInitializer()) {
4120  FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
4121  Init->getMemberLocation(),
4122  Init->getMember(),
4123  TemplateArgs));
4124  if (!Member) {
4125  AnyErrors = true;
4126  New->setInvalidDecl();
4127  continue;
4128  }
4129 
4130  NewInit = BuildMemberInitializer(Member, TempInit.get(),
4131  Init->getSourceLocation());
4132  } else if (Init->isIndirectMemberInitializer()) {
4133  IndirectFieldDecl *IndirectMember =
4134  cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
4135  Init->getMemberLocation(),
4136  Init->getIndirectMember(), TemplateArgs));
4137 
4138  if (!IndirectMember) {
4139  AnyErrors = true;
4140  New->setInvalidDecl();
4141  continue;
4142  }
4143 
4144  NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(),
4145  Init->getSourceLocation());
4146  }
4147 
4148  if (NewInit.isInvalid()) {
4149  AnyErrors = true;
4150  New->setInvalidDecl();
4151  } else {
4152  NewInits.push_back(NewInit.get());
4153  }
4154  }
4155 
4156  // Assign all the initializers to the new constructor.
4158  /*FIXME: ColonLoc */
4159  SourceLocation(),
4160  NewInits,
4161  AnyErrors);
4162 }
4163 
4164 // TODO: this could be templated if the various decl types used the
4165 // same method name.
4167  ClassTemplateDecl *Instance) {
4168  Pattern = Pattern->getCanonicalDecl();
4169 
4170  do {
4171  Instance = Instance->getCanonicalDecl();
4172  if (Pattern == Instance) return true;
4173  Instance = Instance->getInstantiatedFromMemberTemplate();
4174  } while (Instance);
4175 
4176  return false;
4177 }
4178 
4180  FunctionTemplateDecl *Instance) {
4181  Pattern = Pattern->getCanonicalDecl();
4182 
4183  do {
4184  Instance = Instance->getCanonicalDecl();
4185  if (Pattern == Instance) return true;
4186  Instance = Instance->getInstantiatedFromMemberTemplate();
4187  } while (Instance);
4188 
4189  return false;
4190 }
4191 
4192 static bool
4195  Pattern
4196  = cast<ClassTemplatePartialSpecializationDecl>(Pattern->getCanonicalDecl());
4197  do {
4198  Instance = cast<ClassTemplatePartialSpecializationDecl>(
4199  Instance->getCanonicalDecl());
4200  if (Pattern == Instance)
4201  return true;
4202  Instance = Instance->getInstantiatedFromMember();
4203  } while (Instance);
4204 
4205  return false;
4206 }
4207 
4208 static bool isInstantiationOf(CXXRecordDecl *Pattern,
4209  CXXRecordDecl *Instance) {
4210  Pattern = Pattern->getCanonicalDecl();
4211 
4212  do {
4213  Instance = Instance->getCanonicalDecl();
4214  if (Pattern == Instance) return true;
4215  Instance = Instance->getInstantiatedFromMemberClass();
4216  } while (Instance);
4217 
4218  return false;
4219 }
4220 
4221 static bool isInstantiationOf(FunctionDecl *Pattern,
4222  FunctionDecl *Instance) {
4223  Pattern = Pattern->getCanonicalDecl();
4224 
4225  do {
4226  Instance = Instance->getCanonicalDecl();
4227  if (Pattern == Instance) return true;
4228  Instance = Instance->getInstantiatedFromMemberFunction();
4229  } while (Instance);
4230 
4231  return false;
4232 }
4233 
4234 static bool isInstantiationOf(EnumDecl *Pattern,
4235  EnumDecl *Instance) {
4236  Pattern = Pattern->getCanonicalDecl();
4237 
4238  do {
4239  Instance = Instance->getCanonicalDecl();
4240  if (Pattern == Instance) return true;
4241  Instance = Instance->getInstantiatedFromMemberEnum();
4242  } while (Instance);
4243 
4244  return false;
4245 }
4246 
4247 static bool isInstantiationOf(UsingShadowDecl *Pattern,
4248  UsingShadowDecl *Instance,
4249  ASTContext &C) {
4251  Pattern);
4252 }
4253 
4254 static bool isInstantiationOf(UsingDecl *Pattern,
4255  UsingDecl *Instance,
4256  ASTContext &C) {
4257  return declaresSameEntity(C.getInstantiatedFromUsingDecl(Instance), Pattern);
4258 }
4259 
4261  UsingDecl *Instance,
4262  ASTContext &C) {
4263  return declaresSameEntity(C.getInstantiatedFromUsingDecl(Instance), Pattern);
4264 }
4265 
4267  UsingDecl *Instance,
4268  ASTContext &C) {
4269  return declaresSameEntity(C.getInstantiatedFromUsingDecl(Instance), Pattern);
4270 }
4271 
4273  VarDecl *Instance) {
4274  assert(Instance->isStaticDataMember());
4275 
4276  Pattern = Pattern->getCanonicalDecl();
4277 
4278  do {
4279  Instance = Instance->getCanonicalDecl();
4280  if (Pattern == Instance) return true;
4281  Instance = Instance->getInstantiatedFromStaticDataMember();
4282  } while (Instance);
4283 
4284  return false;
4285 }
4286 
4287 // Other is the prospective instantiation
4288 // D is the prospective pattern
4289 static bool isInstantiationOf(ASTContext &Ctx, NamedDecl *D, Decl *Other) {
4290  if (D->getKind() != Other->getKind()) {
4292  = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
4293  if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) {
4294  return isInstantiationOf(UUD, UD, Ctx);
4295  }
4296  }
4297 
4298  if (UnresolvedUsingValueDecl *UUD
4299  = dyn_cast<UnresolvedUsingValueDecl>(D)) {
4300  if (UsingDecl *UD = dyn_cast<UsingDecl>(Other)) {
4301  return isInstantiationOf(UUD, UD, Ctx);
4302  }
4303  }
4304 
4305  return false;
4306  }
4307 
4308  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Other))
4309  return isInstantiationOf(cast<CXXRecordDecl>(D), Record);
4310 
4311  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Other))
4312  return isInstantiationOf(cast<FunctionDecl>(D), Function);
4313 
4314  if (EnumDecl *Enum = dyn_cast<EnumDecl>(Other))
4315  return isInstantiationOf(cast<EnumDecl>(D), Enum);
4316 
4317  if (VarDecl *Var = dyn_cast<VarDecl>(Other))
4318  if (Var->isStaticDataMember())
4319  return isInstantiationOfStaticDataMember(cast<VarDecl>(D), Var);
4320 
4321  if (ClassTemplateDecl *Temp = dyn_cast<ClassTemplateDecl>(Other))
4322  return isInstantiationOf(cast<ClassTemplateDecl>(D), Temp);
4323 
4324  if (FunctionTemplateDecl *Temp = dyn_cast<FunctionTemplateDecl>(Other))
4325  return isInstantiationOf(cast<FunctionTemplateDecl>(D), Temp);
4326 
4328  = dyn_cast<ClassTemplatePartialSpecializationDecl>(Other))
4329  return isInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(D),
4330  PartialSpec);
4331 
4332  if (FieldDecl *Field = dyn_cast<FieldDecl>(Other)) {
4333  if (!Field->getDeclName()) {
4334  // This is an unnamed field.
4336  cast<FieldDecl>(D));
4337  }
4338  }
4339 
4340  if (UsingDecl *Using = dyn_cast<UsingDecl>(Other))
4341  return isInstantiationOf(cast<UsingDecl>(D), Using, Ctx);
4342 
4343  if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(Other))
4344  return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);
4345 
4346  return D->getDeclName() && isa<NamedDecl>(Other) &&
4347  D->getDeclName() == cast<NamedDecl>(Other)->getDeclName();
4348 }
4349 
4350 template<typename ForwardIterator>
4352  NamedDecl *D,
4353  ForwardIterator first,
4354  ForwardIterator last) {
4355  for (; first != last; ++first)
4356  if (isInstantiationOf(Ctx, D, *first))
4357  return cast<NamedDecl>(*first);
4358 
4359  return nullptr;
4360 }
4361 
4362 /// \brief Finds the instantiation of the given declaration context
4363 /// within the current instantiation.
4364 ///
4365 /// \returns NULL if there was an error
4367  const MultiLevelTemplateArgumentList &TemplateArgs) {
4368  if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
4369  Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs);
4370  return cast_or_null<DeclContext>(ID);
4371  } else return DC;
4372 }
4373 
4374 /// \brief Find the instantiation of the given declaration within the
4375 /// current instantiation.
4376 ///
4377 /// This routine is intended to be used when \p D is a declaration
4378 /// referenced from within a template, that needs to mapped into the
4379 /// corresponding declaration within an instantiation. For example,
4380 /// given:
4381 ///
4382 /// \code
4383 /// template<typename T>
4384 /// struct X {
4385 /// enum Kind {
4386 /// KnownValue = sizeof(T)
4387 /// };
4388 ///
4389 /// bool getKind() const { return KnownValue; }
4390 /// };
4391 ///
4392 /// template struct X<int>;
4393 /// \endcode
4394 ///
4395 /// In the instantiation of <tt>X<int>::getKind()</tt>, we need to map the
4396 /// \p EnumConstantDecl for \p KnownValue (which refers to
4397 /// <tt>X<T>::<Kind>::KnownValue</tt>) to its instantiation
4398 /// (<tt>X<int>::<Kind>::KnownValue</tt>). \p FindInstantiatedDecl performs
4399 /// this mapping from within the instantiation of <tt>X<int></tt>.
4401  const MultiLevelTemplateArgumentList &TemplateArgs) {
4402  DeclContext *ParentDC = D->getDeclContext();
4403  // FIXME: Parmeters of pointer to functions (y below) that are themselves
4404  // parameters (p below) can have their ParentDC set to the translation-unit
4405  // - thus we can not consistently check if the ParentDC of such a parameter
4406  // is Dependent or/and a FunctionOrMethod.
4407  // For e.g. this code, during Template argument deduction tries to
4408  // find an instantiated decl for (T y) when the ParentDC for y is
4409  // the translation unit.
4410  // e.g. template <class T> void Foo(auto (*p)(T y) -> decltype(y())) {}
4411  // float baz(float(*)()) { return 0.0; }
4412  // Foo(baz);
4413  // The better fix here is perhaps to ensure that a ParmVarDecl, by the time
4414  // it gets here, always has a FunctionOrMethod as its ParentDC??
4415  // For now:
4416  // - as long as we have a ParmVarDecl whose parent is non-dependent and
4417  // whose type is not instantiation dependent, do nothing to the decl
4418  // - otherwise find its instantiated decl.
4419  if (isa<ParmVarDecl>(D) && !ParentDC->isDependentContext() &&
4420  !cast<ParmVarDecl>(D)->getType()->isInstantiationDependentType())
4421  return D;
4422  if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
4423  isa<TemplateTypeParmDecl>(D) || isa<TemplateTemplateParmDecl>(D) ||
4424  (ParentDC->isFunctionOrMethod() && ParentDC->isDependentContext()) ||
4425  (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda())) {
4426  // D is a local of some kind. Look into the map of local
4427  // declarations to their instantiations.
4429  if (auto Found = CurrentInstantiationScope->findInstantiationOf(D)) {
4430  if (Decl *FD = Found->dyn_cast<Decl *>())
4431  return cast<NamedDecl>(FD);
4432 
4433  int PackIdx = ArgumentPackSubstitutionIndex;
4434  assert(PackIdx != -1 &&
4435  "found declaration pack but not pack expanding");
4436  typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
4437  return cast<NamedDecl>((*Found->get<DeclArgumentPack *>())[PackIdx]);
4438  }
4439  }
4440 
4441  // If we're performing a partial substitution during template argument
4442  // deduction, we may not have values for template parameters yet. They
4443  // just map to themselves.
4444  if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
4445  isa<TemplateTemplateParmDecl>(D))
4446  return D;
4447 
4448  if (D->isInvalidDecl())
4449  return nullptr;
4450 
4451  // Normally this function only searches for already instantiated declaration
4452  // however we have to make an exclusion for local types used before
4453  // definition as in the code:
4454  //
4455  // template<typename T> void f1() {
4456  // void g1(struct x1);
4457  // struct x1 {};
4458  // }
4459  //
4460  // In this case instantiation of the type of 'g1' requires definition of
4461  // 'x1', which is defined later. Error recovery may produce an enum used
4462  // before definition. In these cases we need to instantiate relevant
4463  // declarations here.
4464  bool NeedInstantiate = false;
4465  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
4466  NeedInstantiate = RD->isLocalClass();
4467  else
4468  NeedInstantiate = isa<EnumDecl>(D);
4469  if (NeedInstantiate) {
4470  Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
4472  return cast<TypeDecl>(Inst);
4473  }
4474 
4475  // If we didn't find the decl, then we must have a label decl that hasn't
4476  // been found yet. Lazily instantiate it and return it now.
4477  assert(isa<LabelDecl>(D));
4478 
4479  Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
4480  assert(Inst && "Failed to instantiate label??");
4481 
4483  return cast<LabelDecl>(Inst);
4484  }
4485 
4486  // For variable template specializations, update those that are still
4487  // type-dependent.
4488  if (VarTemplateSpecializationDecl *VarSpec =
4489  dyn_cast<VarTemplateSpecializationDecl>(D)) {
4490  bool InstantiationDependent = false;
4491  const TemplateArgumentListInfo &VarTemplateArgs =
4492  VarSpec->getTemplateArgsInfo();
4494  VarTemplateArgs, InstantiationDependent))
4495  D = cast<NamedDecl>(
4496  SubstDecl(D, VarSpec->getDeclContext(), TemplateArgs));
4497  return D;
4498  }
4499 
4500  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
4501  if (!Record->isDependentContext())
4502  return D;
4503 
4504  // Determine whether this record is the "templated" declaration describing
4505  // a class template or class template partial specialization.
4506  ClassTemplateDecl *ClassTemplate = Record->getDescribedClassTemplate();
4507  if (ClassTemplate)
4508  ClassTemplate = ClassTemplate->getCanonicalDecl();
4509  else if (ClassTemplatePartialSpecializationDecl *PartialSpec
4510  = dyn_cast<ClassTemplatePartialSpecializationDecl>(Record))
4511  ClassTemplate = PartialSpec->getSpecializedTemplate()->getCanonicalDecl();
4512 
4513  // Walk the current context to find either the record or an instantiation of
4514  // it.
4515  DeclContext *DC = CurContext;
4516  while (!DC->isFileContext()) {
4517  // If we're performing substitution while we're inside the template
4518  // definition, we'll find our own context. We're done.
4519  if (DC->Equals(Record))
4520  return Record;
4521 
4522  if (CXXRecordDecl *InstRecord = dyn_cast<CXXRecordDecl>(DC)) {
4523  // Check whether we're in the process of instantiating a class template
4524  // specialization of the template we're mapping.
4525  if (ClassTemplateSpecializationDecl *InstSpec
4526  = dyn_cast<ClassTemplateSpecializationDecl>(InstRecord)){
4527  ClassTemplateDecl *SpecTemplate = InstSpec->getSpecializedTemplate();
4528  if (ClassTemplate && isInstantiationOf(ClassTemplate, SpecTemplate))
4529  return InstRecord;
4530  }
4531 
4532  // Check whether we're in the process of instantiating a member class.
4533  if (isInstantiationOf(Record, InstRecord))
4534  return InstRecord;
4535  }
4536 
4537  // Move to the outer template scope.
4538  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) {
4539  if (FD->getFriendObjectKind() && FD->getDeclContext()->isFileContext()){
4540  DC = FD->getLexicalDeclContext();
4541  continue;
4542  }
4543  }
4544 
4545  DC = DC->getParent();
4546  }
4547 
4548  // Fall through to deal with other dependent record types (e.g.,
4549  // anonymous unions in class templates).
4550  }
4551 
4552  if (!ParentDC->isDependentContext())
4553  return D;
4554 
4555  ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
4556  if (!ParentDC)
4557  return nullptr;
4558 
4559  if (ParentDC != D->getDeclContext()) {
4560  // We performed some kind of instantiation in the parent context,
4561  // so now we need to look into the instantiated parent context to
4562  // find the instantiation of the declaration D.
4563 
4564  // If our context used to be dependent, we may need to instantiate
4565  // it before performing lookup into that context.
4566  bool IsBeingInstantiated = false;
4567  if (CXXRecordDecl *Spec = dyn_cast<CXXRecordDecl>(ParentDC)) {
4568  if (!Spec->isDependentContext()) {
4569  QualType T = Context.getTypeDeclType(Spec);
4570  const RecordType *Tag = T->getAs<RecordType>();
4571  assert(Tag && "type of non-dependent record is not a RecordType");
4572  if (Tag->isBeingDefined())
4573  IsBeingInstantiated = true;
4574  if (!Tag->isBeingDefined() &&
4575  RequireCompleteType(Loc, T, diag::err_incomplete_type))
4576  return nullptr;
4577 
4578  ParentDC = Tag->getDecl();
4579  }
4580  }
4581 
4582  NamedDecl *Result = nullptr;
4583  if (D->getDeclName()) {
4584  DeclContext::lookup_result Found = ParentDC->lookup(D->getDeclName());
4585  Result = findInstantiationOf(Context, D, Found.begin(), Found.end());
4586  } else {
4587  // Since we don't have a name for the entity we're looking for,
4588  // our only option is to walk through all of the declarations to
4589  // find that name. This will occur in a few cases:
4590  //
4591  // - anonymous struct/union within a template
4592  // - unnamed class/struct/union/enum within a template
4593  //
4594  // FIXME: Find a better way to find these instantiations!
4595  Result = findInstantiationOf(Context, D,
4596  ParentDC->decls_begin(),
4597  ParentDC->decls_end());
4598  }
4599 
4600  if (!Result) {
4601  if (isa<UsingShadowDecl>(D)) {
4602  // UsingShadowDecls can instantiate to nothing because of using hiding.
4603  } else if (Diags.hasErrorOccurred()) {
4604  // We've already complained about something, so most likely this
4605  // declaration failed to instantiate. There's no point in complaining
4606  // further, since this is normal in invalid code.
4607  } else if (IsBeingInstantiated) {
4608  // The class in which this member exists is currently being
4609  // instantiated, and we haven't gotten around to instantiating this
4610  // member yet. This can happen when the code uses forward declarations
4611  // of member classes, and introduces ordering dependencies via
4612  // template instantiation.
4613  Diag(Loc, diag::err_member_not_yet_instantiated)
4614  << D->getDeclName()
4615  << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
4616  Diag(D->getLocation(), diag::note_non_instantiated_member_here);
4617  } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
4618  // This enumeration constant was found when the template was defined,
4619  // but can't be found in the instantiation. This can happen if an
4620  // unscoped enumeration member is explicitly specialized.
4621  EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
4622  EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum,
4623  TemplateArgs));
4624  assert(Spec->getTemplateSpecializationKind() ==
4626  Diag(Loc, diag::err_enumerator_does_not_exist)
4627  << D->getDeclName()
4628  << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext()));
4629  Diag(Spec->getLocation(), diag::note_enum_specialized_here)
4630  << Context.getTypeDeclType(Spec);
4631  } else {
4632  // We should have found something, but didn't.
4633  llvm_unreachable("Unable to find instantiation of declaration!");
4634  }
4635  }
4636 
4637  D = Result;
4638  }
4639 
4640  return D;
4641 }
4642 
4643 /// \brief Performs template instantiation for all implicit template
4644 /// instantiations we have seen until this point.
4646  while (!PendingLocalImplicitInstantiations.empty() ||
4647  (!LocalOnly && !PendingInstantiations.empty())) {
4649 
4650  if (PendingLocalImplicitInstantiations.empty()) {
4651  Inst = PendingInstantiations.front();
4652  PendingInstantiations.pop_front();
4653  } else {
4654  Inst = PendingLocalImplicitInstantiations.front();
4656  }
4657 
4658  // Instantiate function definitions
4659  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
4660  PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(),
4661  "instantiating function definition");
4662  bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
4664  InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true,
4665  DefinitionRequired);
4666  continue;
4667  }
4668 
4669  // Instantiate variable definitions
4670  VarDecl *Var = cast<VarDecl>(Inst.first);
4671 
4672  assert((Var->isStaticDataMember() ||
4673  isa<VarTemplateSpecializationDecl>(Var)) &&
4674  "Not a static data member, nor a variable template"
4675  " specialization?");
4676 
4677  // Don't try to instantiate declarations if the most recent redeclaration
4678  // is invalid.
4679  if (Var->getMostRecentDecl()->isInvalidDecl())
4680  continue;
4681 
4682  // Check if the most recent declaration has changed the specialization kind
4683  // and removed the need for implicit instantiation.
4685  case TSK_Undeclared:
4686  llvm_unreachable("Cannot instantitiate an undeclared specialization.");
4689  continue; // No longer need to instantiate this type.
4691  // We only need an instantiation if the pending instantiation *is* the
4692  // explicit instantiation.
4693  if (Var != Var->getMostRecentDecl()) continue;
4694  case TSK_ImplicitInstantiation:
4695  break;
4696  }
4697 
4698  PrettyDeclStackTraceEntry CrashInfo(*this, Var, SourceLocation(),
4699  "instantiating variable definition");
4700  bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
4702 
4703  // Instantiate static data member definitions or variable template
4704  // specializations.
4705  InstantiateVariableDefinition(/*FIXME:*/ Inst.second, Var, true,
4706  DefinitionRequired);
4707  }
4708 }
4709 
4711  const MultiLevelTemplateArgumentList &TemplateArgs) {
4712  for (auto DD : Pattern->ddiags()) {
4713  switch (DD->getKind()) {
4715  HandleDependentAccessCheck(*DD, TemplateArgs);
4716  break;
4717  }
4718  }
4719 }
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.h:2087
Defines the clang::ASTContext interface.
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:504
iterator begin() const
Definition: DeclBase.h:1070
ExprResult PerformContextuallyConvertToBool(Expr *From)
TemplateParameterList * getExpansionTemplateParameters(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
no exception specification
SourceLocation getIdentLocation() const
Returns the location of this using declaration's identifier.
Definition: DeclCXX.h:2631
virtual void HandleCXXStaticMemberVarInstantiation(VarDecl *D)
HandleCXXStaticMemberVarInstantiation - Tell the consumer that this.
Definition: ASTConsumer.h:125
void setAnonymousStructOrUnion(bool Anon)
Definition: Decl.h:3295
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.
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:2202
ASTConsumer & Consumer
Definition: Sema.h:296
void InstantiatedLocal(const Decl *D, Decl *Inst)
LateTemplateParserCB * LateTemplateParser
Definition: Sema.h:526
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.
void UpdateExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI)
LateParsedTemplateMapT LateParsedTemplateMap
Definition: Sema.h:521
A stack-allocated class that identifies which local variable declaration instantiations are present i...
Definition: Template.h:178
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.
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...
IdentifierInfo * getIdentifier() const
Definition: Decl.h:163
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:1733
void addOuterTemplateArguments(const TemplateArgumentList *TemplateArgs)
Add a new outermost level to the multi-level template argument list.
Definition: Template.h:96
const LangOptions & getLangOpts() const
Definition: Sema.h:1019
CXXMethodDecl * getSpecialization() const
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3177
We are matching the template parameter lists of two templates that might be redeclarations.
Definition: Sema.h:5769
ExprResult SubstInitializer(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs, bool CXXDirectInit)
bool isParameterPack() const
Returns whether this is a parameter pack.
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration. If PrevDecl is NULL, set this as the first and only declaration...
Definition: Decl.h:3792
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:3199
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
Definition: Decl.cpp:3410
The current expression is potentially evaluated at run time, which means that code may be generated t...
Definition: Sema.h:781
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)
bool CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsExplicitSpecialization)
Perform semantic checking of a new function declaration.
Definition: SemaDecl.cpp:8052
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
QualType getUnderlyingType() const
Definition: Decl.h:2616
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1088
void setRangeEnd(SourceLocation E)
Definition: Decl.h:1716
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, NamedDecl **Params, unsigned NumParams, SourceLocation RAngleLoc)
chain_range chain() const
Definition: Decl.h:2510
TypeLoc getPatternLoc() const
Definition: TypeLoc.h:1960
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:1987
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed...
Definition: Sema.h:6826
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.cpp:1572
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.
Decl * InstantiateTypedefNameDecl(TypedefNameDecl *D, bool IsTypeAlias)
bool hasErrorOccurred() const
Definition: Diagnostic.h:573
Not a friend object.
Definition: DeclBase.h:949
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:814
bool isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD, bool AllowFunctionParameters)
Definition: SemaStmt.cpp:2658
PtrTy get() const
Definition: Ownership.h:163
static ClassTemplateSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate, const TemplateArgument *Args, unsigned NumArgs, ClassTemplateSpecializationDecl *PrevDecl)
std::deque< PendingImplicitInstantiation > PendingLocalImplicitInstantiations
The queue of implicit template instantiations that are required and must be performed within the curr...
Definition: Sema.h:6866
bool hasLinkage() const
Determine whether this declaration has linkage.
Definition: Decl.cpp:1577
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:851
const FunctionDecl * isLocalClass() const
If the class is a local class [class.local], returns the enclosing function declaration.
Definition: DeclCXX.h:1401
QualType getRecordType(const RecordDecl *Decl) const
Declaration of a variable template.
const Expr * getInit() const
Definition: Decl.h:1068
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:400
A container of type source information.
Definition: Decl.h:60
std::pair< ValueDecl *, SourceLocation > PendingImplicitInstantiation
An entity for which implicit template instantiation is required.
Definition: Sema.h:6822
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:3131
void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo)
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclBase.h:368
void setInitStyle(InitializationStyle Style)
Definition: Decl.h:1159
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.
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2147
TemplateName SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name, SourceLocation Loc, const MultiLevelTemplateArgumentList &TemplateArgs)
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
InClassInitStyle getInClassInitStyle() const
Definition: Decl.h:2369
bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous)
Perform semantic checking on a newly-created variable declaration.
Definition: SemaDecl.cpp:6496
void setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern)
Remember that the using decl Inst is an instantiation of the using decl Pattern of a class template...
const TemplateArgumentLoc * getArgumentArray() const
Definition: TemplateBase.h:543
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Definition: DeclSpec.cpp:135
const TemplateArgumentListInfo & templateArgs() const
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:539
virtual void ReadLateParsedTemplates(llvm::MapVector< const FunctionDecl *, LateParsedTemplate * > &LPTMap)
Read the set of late parsed template functions for this source.
RAII object that enters a new expression evaluation context.
Definition: Sema.h:9016
void HandleDependentAccessCheck(const DependentDiagnostic &DD, const MultiLevelTemplateArgumentList &TemplateArgs)
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:1935
DiagnosticsEngine & Diags
Definition: Sema.h:297
bool SubstQualifier(const DeclaratorDecl *OldDecl, DeclaratorDecl *NewDecl)
SourceLocation getRParenLoc() const
Definition: DeclCXX.h:3187
void InstantiatedLocalPackArg(const Decl *D, Decl *Inst)
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.
ExtProtoInfo - Extra information about a function prototype.
Definition: Type.h:3042
AccessSpecifier getAccess() const
Definition: DeclBase.h:416
TypeSourceInfo * SubstFunctionDeclType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, CXXRecordDecl *ThisContext, unsigned ThisTypeQuals)
Declaration context for names declared as extern "C" in C++. This is neither the semantic nor lexical...
Definition: Decl.h:122
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Definition: DeclCXX.cpp:2202
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:4512
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>". This is safe to be used inside an AST node, in contrast with TemplateArgumentListInfo.
Definition: TemplateBase.h:564
static void instantiateDependentCUDALaunchBoundsAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const CUDALaunchBoundsAttr &Attr, Decl *New)
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:46
decl_iterator decls_end() const
Definition: DeclBase.h:1415
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:470
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1334
static AccessSpecDecl * Create(ASTContext &C, AccessSpecifier AS, DeclContext *DC, SourceLocation ASLoc, SourceLocation ColonLoc)
Definition: DeclCXX.h:128
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:647
Provides information about a dependent function-template specialization declaration.
Definition: DeclTemplate.h:545
void ActOnUninitializedDecl(Decl *dcl, bool TypeMayContainAuto)
Definition: SemaDecl.cpp:9378
TypeSourceInfo * getFriendType() const
Definition: DeclFriend.h:113
unsigned getStaticLocalNumber(const VarDecl *VD) const
void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T)
Definition: SemaExpr.cpp:13419
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.
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3057
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:3124
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:6793
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3171
StringLiteral * getMessage()
Definition: DeclCXX.h:3182
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
Definition: Decl.cpp:3561
bool hasAttr() const
Definition: DeclBase.h:487
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:1742
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:89
A C++ nested-name-specifier augmented with source location information.
NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, const MultiLevelTemplateArgumentList &TemplateArgs)
The results of name lookup within a DeclContext. This is either a single result (with no stable stora...
Definition: DeclBase.h:1034
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3138
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Definition: DeclCXX.h:2733
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:2213
void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl)
bool CheckEnumUnderlyingType(TypeSourceInfo *TI)
Check that this is a valid underlying type for an enum declaration.
Definition: SemaDecl.cpp:11255
bool isReferenceType() const
Definition: Type.h:5241
bool isInIdentifierNamespace(unsigned NS) const
Definition: DeclBase.h:674
QualType getReturnType() const
Definition: Decl.h:1997
VarTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:882
bool isCompleteDefinition() const
Definition: Decl.h:2838
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:326
Decl * VisitVarTemplateSpecializationDecl(VarTemplateDecl *VarTemplate, VarDecl *FromVar, void *InsertPos, const TemplateArgumentListInfo &TemplateArgsInfo, ArrayRef< TemplateArgument > Converted)
bool isPure() const
Definition: Decl.h:1789
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:3419
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
Definition: Type.cpp:2862
ParmVarDecl * getParam(unsigned i) const
Definition: TypeLoc.h:1294
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:675
TagKind getTagKind() const
Definition: Decl.h:2897
bool isPreviousDeclInSameBlockScope() const
Definition: Decl.h:1252
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
void Exit()
Exit this local instantiation scope early.
Definition: Template.h:261
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:2628
unsigned size() const
Definition: DeclTemplate.h:87
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...
bool DefineUsedVTables()
Define all of the vtables that have been used in this translation unit and reference any virtual memb...
Represents an access specifier followed by colon ':'.
Definition: DeclCXX.h:101
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:1114
void PopExpressionEvaluationContext()
Definition: SemaExpr.cpp:12075
static bool adjustContextForLocalExternDecl(DeclContext *&DC)
Definition: SemaDecl.cpp:5555
bool isThisDeclarationADefinition() const
Definition: Decl.h:2832
StorageClass getStorageClass() const
Returns the storage class as written in the source. For the computed linkage of symbol, see getLinkage.
Definition: Decl.h:871
Expr * getUnderlyingExpr() const
Definition: Type.h:3430
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
void InstantiateMemInitializers(CXXConstructorDecl *New, const CXXConstructorDecl *Tmpl, const MultiLevelTemplateArgumentList &TemplateArgs)
bool isExplicitlyDefaulted() const
Definition: Decl.h:1810
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool isNull() const
Determine whether this template name is NULL.
Definition: TemplateName.h:220
Represents a C++ using-declaration.
Definition: DeclCXX.h:2871
FunctionTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Definition: DeclTemplate.h:897
void AddAssumeAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E, Expr *OE, unsigned SpellingListIndex)
static TemplateArgumentList * CreateCopy(ASTContext &Context, const TemplateArgument *Args, unsigned NumArgs)
Create a new template argument list that copies the given set of template arguments.
Represents the results of name lookup.
Definition: Lookup.h:30
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:2956
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
IdentifierInfo * getSetterId() const
Definition: DeclCXX.h:3247
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:3550
bool isImplicit() const
Definition: DeclBase.h:503
SourceLocation getRAngleLoc() const
Definition: TypeLoc.h:1450
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
QualType getReturnType() const
Definition: Type.h:2952
StmtResult SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs)
bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target, const LookupResult &PreviousDecls, UsingShadowDecl *&PrevShadow)
const CXXRecordDecl * getParent() const
Definition: DeclCXX.h:1817
bool isDefaulted() const
Definition: Decl.h:1805
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...
VarTemplateDecl * getInstantiatedFromMemberTemplate()
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Definition: TemplateBase.h:499
NamedDecl * BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, AttributeList *AttrList, bool IsInstantiation, bool HasTypenameKeyword, SourceLocation TypenameLoc)
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:569
bool isValueDependent() const
Definition: Expr.h:146
RecordDecl * getDecl() const
Definition: Type.h:3527
FunctionDecl * getTemplateInstantiationPattern() const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:3018
bool isOverloadedOperator() const
Definition: Decl.h:2050
void setInstantiatedFromMember(ClassTemplatePartialSpecializationDecl *PartialSpec)
FunctionTemplateDecl * getInstantiatedFromMemberTemplate()
Definition: DeclTemplate.h:929
void setSpecializationKind(TemplateSpecializationKind TSK)
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:651
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1006
SourceLocation getRBraceLoc() const
Definition: Decl.h:2813
SourceLocation getRAngleLoc() const
Definition: TemplateBase.h:536
void DiagnoseUnusedDecl(const NamedDecl *ND)
Definition: SemaDecl.cpp:1550
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:68
DeclContext * getLexicalDeclContext()
Definition: DeclBase.h:697
SourceLocation getTemplateNameLoc() const
Definition: TemplateBase.h:505
bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New)
Definition: SemaDecl.cpp:1874
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember()
Retrieve the member class template partial specialization from which this particular class template p...
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1785
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Definition: DeclCXX.cpp:2048
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &Converted)
Check that the given template arguments can be be provided to the given template, converting the argu...
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
Definition: SemaDecl.cpp:10726
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. Does not test the acceptance criteria...
Definition: Lookup.h:366
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1141
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
QualType getType() const
Definition: Decl.h:538
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:1683
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
Definition: DeclCXX.h:2746
RAII object used to change the argument pack substitution index within a Sema object.
Definition: Sema.h:6567
The lookup results will be used for redeclaration of a name, if an entity by that name already exists...
Definition: Sema.h:2631
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
Definition: Decl.cpp:2393
param_iterator param_begin()
Definition: Decl.h:1947
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:2901
TypeSourceInfo * getExpansionTypeSourceInfo(unsigned I) const
Retrieve a particular expansion type source info within an expanded parameter pack.
QualType getTemplateSpecializationType(TemplateName T, const TemplateArgument *Args, unsigned NumArgs, QualType Canon=QualType()) const
AnnotatingParser & P
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
Definition: Decl.h:1793
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:1402
void BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar, const MultiLevelTemplateArgumentList &TemplateArgs, LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner, LocalInstantiationScope *StartingScope, bool InstantiatingVarTemplate=false)
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D)
Definition: SemaDecl.cpp:10373
ExtInfo getExtInfo() const
Definition: Type.h:2961
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:258
bool isNamespace() const
Definition: DeclBase.h:1251
void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos)
Insert the specified specialization knowing that it is not already in. InsertPos must be obtained fro...
QualType getParamType(unsigned i) const
Definition: Type.h:3134
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit, bool TypeMayContainAuto)
Definition: SemaDecl.cpp:8838
static void instantiateDependentEnableIfAttr(Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs, const EnableIfAttr *A, const Decl *Tmpl, Decl *New)
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3166
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:1220
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2560
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:2336
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Definition: DeclCXX.h:2724
bool inferObjCARCLifetime(ValueDecl *decl)
Definition: SemaDecl.cpp:5261
Represents a ValueDecl that came out of a declarator. Contains type source information through TypeSo...
Definition: Decl.h:586
unsigned getChainingSize() const
Definition: Decl.h:2516
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:1620
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1592
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:206
ID
Defines the set of possible language-specific address spaces.
Definition: AddressSpaces.h:27
StorageClass getStorageClass() const
Returns the storage class as written in the source. For the computed linkage of symbol, see getLinkage.
Definition: Decl.h:2020
MemInitResult BuildMemberInitializer(ValueDecl *Member, Expr *Init, SourceLocation IdLoc)
void AddAlignValueAttr(SourceRange AttrRange, Decl *D, Expr *E, unsigned SpellingListIndex)
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
Definition: Decl.h:2211
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isInline, bool isImplicitlyDeclared)
Definition: DeclCXX.cpp:1903
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:1861
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, Optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2224
bool hasDeclaratorForAnonDecl() const
Definition: Decl.h:2928
const Type * getTypeForDecl() const
Definition: Decl.h:2557
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(NamedDecl *D, const TemplateArgumentList *Innermost=nullptr, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition: Type.h:5495
bool isDirectInit() const
Whether the initializer is a direct-initializer (list or call).
Definition: Decl.h:1178
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
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:1862
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. The actual template arguments (if any) are stored a...
Definition: TemplateBase.h:575
void PerformDependentDiagnostics(const DeclContext *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs)
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl, ClassTemplateDecl *PrevDecl)
Create a class template node.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
Expr * getBitWidth() const
Definition: Decl.h:2344
static DeclT * getPreviousDeclForInstantiation(DeclT *D)
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2358
void setInvalidDecl(bool Invalid=true)
Definition: DeclBase.cpp:96
bool CheckInheritingConstructorUsingDecl(UsingDecl *UD)
Additional checks for a using declaration referring to a constructor name.
Kind getKind() const
Definition: DeclBase.h:375
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:1968
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3142
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage. This will either be a local variabl...
Definition: DeclBase.h:908
ParmVarDecl * SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, Optional< unsigned > NumExpansions, bool ExpectParameterPack)
DeclContext * getDeclContext()
Definition: DeclBase.h:381
void CheckAlignasUnderalignment(Decl *D)
UsingShadowDecl * getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst)
const char * getDeclKindName() const
Definition: DeclBase.cpp:87
bool isFailed() const
Definition: DeclCXX.h:3185
Represents a C++ template name within the type system.
Definition: TemplateName.h:175
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
DecltypeType (C++0x)
Definition: Type.h:3422
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
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:6354
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:2040
void setConstexpr(bool IC)
Definition: Decl.h:1236
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:12652
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:303
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Definition: DeclTemplate.h:731
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3166
StorageClass
Storage classes.
Definition: Specifiers.h:173
ClassTemplateDecl * getInstantiatedFromMemberTemplate()
bool isDependentType() const
Definition: Type.h:1727
bool isFunctionOrMethod() const
Definition: DeclBase.h:1223
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:1174
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:624
static ClassTemplatePartialSpecializationDecl * Create(ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, ClassTemplateDecl *SpecializedTemplate, const TemplateArgument *Args, unsigned NumArgs, const TemplateArgumentListInfo &ArgInfos, QualType CanonInjectedType, ClassTemplatePartialSpecializationDecl *PrevDecl)
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.
SmallVector< ActiveTemplateInstantiation, 16 > ActiveTemplateInstantiations
List of active template instantiations.
Definition: Sema.h:6518
void setLocation(SourceLocation L)
Definition: DeclBase.h:373
NamedDecl * getInstantiatedFromUsingDecl(UsingDecl *Inst)
If the given using decl Inst is an instantiation of a (possibly unresolved) using decl from a templat...
SourceLocation getUsingLoc() const
Returns the source location of the 'using' keyword.
Definition: DeclCXX.h:3124
DeclarationName getDeclName() const
Definition: Decl.h:189
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1023
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
TemplateArgumentLoc * getTemplateArgs()
Retrieve the template arguments.
Definition: TemplateBase.h:584
SourceLocation getFriendLoc() const
Retrieves the location of the 'friend' keyword.
Definition: DeclFriend.h:131
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2405
The result type of a method or function.
bool hasNameForLinkage() const
Definition: Decl.h:2924
shadow_range shadows() const
Definition: DeclCXX.h:2968
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:611
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:5389
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:2937
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:1893
const Expr * getAnyInitializer() const
Definition: Decl.h:1056
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:1835
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:148
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:1784
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:95
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:2915
Attr * instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs)
void addAttr(Attr *A)
Definition: DeclBase.h:437
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute. The C++11 [[noreturn]] attr...
Definition: Type.h:2959
Stmt * getBody(const FunctionDecl *&Definition) const
Definition: Decl.cpp:2405
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:365
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.h:1367
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:1467
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:208
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl. It will iterate at least once ...
Definition: Redeclarable.h:228
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1511
IdentifierInfo * getGetterId() const
Definition: DeclCXX.h:3245
bool CheckUsingDeclQualifier(SourceLocation UsingLoc, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc)
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3028
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:136
A stack object to be created when performing template instantiation.
Definition: Sema.h:6610
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: Decl.cpp:3610
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
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...
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
enumerator_range enumerators() const
Definition: Decl.h:3087
unsigned getNumParams() const
Definition: Decl.cpp:2651
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.h:2110
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:264
Decl * BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, Expr *AssertExpr, StringLiteral *AssertMessageExpr, SourceLocation RParenLoc, bool Failed)
const TemplateArgumentListInfo & getTemplateArgsInfo() const
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool isExplicit, bool isInline, bool isImplicitlyDeclared, bool isConstexpr)
Definition: DeclCXX.cpp:1750
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.
reference front() const
Definition: DeclBase.h:1076
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2694
attr_range attrs() const
Definition: DeclBase.h:447
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:1026
SourceLocation getTargetNameLoc() const
Returns the location of the identifier in the named namespace.
Definition: DeclCXX.h:2752
void setReferenced(bool R=true)
Definition: DeclBase.h:532
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3017
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1717
unsigned getDepth() const
Retrieve the depth of the template parameter.
static bool isInstantiationOf(ClassTemplateDecl *Pattern, ClassTemplateDecl *Instance)
QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc)
Check that the type of a non-type template parameter is well-formed.
EnumDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.h:3038
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
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:192
FunctionDecl * getExceptionSpecTemplate() const
If this function type has an uninstantiated exception specification, this is the function whose excep...
Definition: Type.h:3218
SourceLocation getUsingLoc() const
Returns the source location of the 'using' keyword.
Definition: DeclCXX.h:3043
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
SourceLocation getLAngleLoc() const
Definition: TemplateBase.h:535
Decl * VisitVarDecl(VarDecl *D, bool InstantiatingVarTemplate)
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:880
void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern)
const T * castAs() const
Definition: Type.h:5586
bool isTypeDependent() const
Definition: Expr.h:166
lookup_result lookup(DeclarationName Name) const
Definition: DeclBase.cpp:1339
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:602
bool isFileContext() const
Definition: DeclBase.h:1239
bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Previous)
void ActOnMemInitializers(Decl *ConstructorDecl, SourceLocation ColonLoc, ArrayRef< CXXCtorInitializer * > MemInits, bool AnyErrors)
ActOnMemInitializers - Handle the member initializers for a constructor.
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3159
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:2195
void setInstantiatedFromMember(VarTemplatePartialSpecializationDecl *PartialSpec)
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2024
Attr * clone(ASTContext &C) const
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:538
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:68
unsigned getManglingNumber(const NamedDecl *ND) const
void setVirtualAsWritten(bool V)
Definition: Decl.h:1785
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Represents a pack expansion of types.
Definition: Type.h:4428
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:3970
MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init, CXXRecordDecl *ClassDecl)
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:2242
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1242
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:2576
bool isAnonymousStructOrUnion() const
Definition: Decl.h:3294
Represents a template argument.
Definition: TemplateBase.h:39
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1237
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument. ...
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3059
SourceLocation getColonLoc() const
The location of the colon following the access specifier.
Definition: DeclCXX.h:120
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
Definition: DeclCXX.cpp:1994
static bool addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function, const FunctionDecl *PatternDecl, LocalInstantiationScope &Scope, const MultiLevelTemplateArgumentList &TemplateArgs)
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Definition: Decl.h:2686
void setImplicitlyInline()
Flag that this function is implicitly inline.
Definition: Decl.h:2033
bool hasTypename() const
Return true if the using declaration has 'typename'.
Definition: DeclCXX.h:2923
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
Definition: Sema.h:6561
bool SubstParmTypes(SourceLocation Loc, ParmVarDecl **Params, unsigned NumParams, const MultiLevelTemplateArgumentList &TemplateArgs, SmallVectorImpl< QualType > &ParamTypes, SmallVectorImpl< ParmVarDecl * > *OutParams=nullptr)
Substitute the given template arguments into the given set of parameters, producing the set of parame...
Decl * VisitFunctionDecl(FunctionDecl *D, TemplateParameterList *TemplateParams)
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
Definition: SemaDecl.cpp:10213
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:161
LocalInstantiationScope * cloneScopes(LocalInstantiationScope *Outermost)
Clone this scope, and all outer scopes, down to the given outermost scope.
Definition: Template.h:274
void InstantiateVariableInitializer(VarDecl *Var, VarDecl *OldVar, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiate the initializer of a variable.
A template instantiation that is currently in progress.
Definition: Sema.h:6398
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
SourceLocation getEllipsisLoc() const
Definition: TypeLoc.h:1944
void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc, SourceLocation RBraceLoc, Decl *EnumDecl, ArrayRef< Decl * > Elements, Scope *S, AttributeList *Attr)
Definition: SemaDecl.cpp:13983
bool hasInit() const
Definition: Decl.h:1065
bool isInvalidDecl() const
Definition: DeclBase.h:498
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1044
DeclContext * getCommonAncestor()
Returns the common ancestor context of this using-directive and its nominated namespace.
Definition: DeclCXX.h:2620
static NamedDecl * findInstantiationOf(ASTContext &Ctx, NamedDecl *D, ForwardIterator first, ForwardIterator last)
bool hasWrittenPrototype() const
Definition: Decl.h:1827
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3100
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:1973
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.
bool isUsed(bool CheckUsedAttr=true) const
Whether this declaration was used, meaning that a definition is required.
Definition: DeclBase.cpp:305
bool isThisDeclarationADefinition() const
Definition: Decl.h:1766
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:633
SourceLocation LAngleLoc
The source location of the left angle bracket ('<').
Definition: TemplateBase.h:566
bool hasAttrs() const
Definition: DeclBase.h:427
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:131
void setPreviousDeclInSameBlockScope(bool Same)
Definition: Decl.h:1257
MemInitResult BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo, Expr *Init, CXXRecordDecl *ClassDecl, SourceLocation EllipsisLoc)
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:3503
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:3814
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false)
Instantiate the definition of the given function from its template.
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:919
unsigned getDepth() const
Get the nesting depth of the template parameter.
void setInitCapture(bool IC)
Definition: Decl.h:1245
QualType getNonReferenceType() const
Definition: Type.h:5182
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it's a function-local extern declaration...
Definition: DeclBase.h:892
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
Definition: Expr.cpp:2727
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:127
static VarTemplatePartialSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, TemplateParameterList *Params, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, const TemplateArgument *Args, unsigned NumArgs, const TemplateArgumentListInfo &ArgInfos)
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:279
VarTemplatePartialSpecializationDecl * getInstantiatedFromMember()
Retrieve the member variable template partial specialization from which this particular variable temp...
TypeSourceInfo * SubstFunctionType(FunctionDecl *D, SmallVectorImpl< ParmVarDecl * > &Params)
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
Definition: DeclBase.h:517
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
SourceManager & getSourceManager() const
Definition: Sema.h:1024
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:3465
static VarTemplateSpecializationDecl * Create(ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, StorageClass S, const TemplateArgument *Args, unsigned NumArgs)
const T * getAs() const
Definition: Type.h:5555
void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD)
Definition: DeclTemplate.h:782
NamedDecl * getFriendDecl() const
Definition: DeclFriend.h:126
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, bool IsDecltype=false)
Definition: SemaExpr.cpp:12056
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
Definition: Decl.h:2114
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
Definition: DeclBase.h:967
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:1626
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3149
EnumConstantDecl * CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *val)
Definition: SemaDecl.cpp:13507
QualType getIntegerType() const
Definition: Decl.h:3115
void setInstantiationOfStaticDataMember(VarDecl *VD, TemplateSpecializationKind TSK)
Specify that this variable is an instantiation of the static data member VD.
Definition: Decl.cpp:2265
bool isFunctionType() const
Definition: Type.h:5229
static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl, const MultiLevelTemplateArgumentList &TemplateArgs)
void * OpaqueParser
Definition: Sema.h:528
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:2908
bool isNRVOVariable() const
Determine whether this local variable can be used with the named return value optimization (NRVO)...
Definition: Decl.h:1202
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:958
InitializationStyle getInitStyle() const
The style of initialization for this declaration.
Definition: Decl.h:1173
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:1467
void setCXXForRangeDecl(bool FRD)
Definition: Decl.h:1215
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
static bool isInvalid(SourceLocation Loc, bool *Invalid)
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1228
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:371
void setInstantiationOfMemberClass(CXXRecordDecl *RD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member class RD.
Definition: DeclCXX.cpp:1228
void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto, const MultiLevelTemplateArgumentList &Args)
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:982
SourceLocation getTypenameLoc() const
Returns the source location of the 'typename' keyword.
Definition: DeclCXX.h:3127
OMPThreadPrivateDecl * CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef< Expr * > VarList)
Builds a new OpenMPThreadPrivateDecl and checks its correctness.
Definition: SemaOpenMP.cpp:941
void setInnerLocStart(SourceLocation L)
Definition: Decl.h:626
bool isCXXForRangeDecl() const
Determine whether this variable is the for-range-declaration in a C++0x for-range statement...
Definition: Decl.h:1212
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
A template argument list.
Definition: DeclTemplate.h:150
ExprResult SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs)
Call-style initialization (C++98)
Definition: Decl.h:719
Represents a field declaration created by an @defs(...).
Definition: DeclObjC.h:1679
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. InsertPos must be obtained fro...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
void setTSCSpec(ThreadStorageClassSpecifier TSC)
Definition: Decl.h:876
void MergeVarDecl(VarDecl *New, LookupResult &Previous)
Definition: SemaDecl.cpp:3329
void setDescribedVarTemplate(VarTemplateDecl *Template)
Definition: Decl.cpp:2229
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:2019
VarTemplateSpecializationDecl * CompleteVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl, const MultiLevelTemplateArgumentList &TemplateArgs)
Instantiates a variable template specialization by completing it with appropriate type information an...
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
Definition: Sema.h:776
virtual bool isOutOfLine() const
Definition: Decl.cpp:43
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
Definition: DeclBase.cpp:1202
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3131
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:3942
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:481
NamedDecl * FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs)
Find the instantiation of the given declaration within the current instantiation. ...
ClassTemplatePartialSpecializationDecl * findPartialSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the partial specialization with the provided arguments if it exists, otherwise return the inse...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:307
void AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads, Expr *MinBlocks, unsigned SpellingListIndex)
void setUnsupportedFriend(bool Unsupported)
Definition: DeclFriend.h:164
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
Definition: DeclCXX.cpp:2119
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.
DeclaratorDecl * getDeclaratorForAnonDecl() const
Definition: Decl.h:2932
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1233
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:335
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:115
unsigned getIndex() const
Retrieve the index of the template parameter.
void setDeclaratorForAnonDecl(DeclaratorDecl *DD)
Definition: Decl.h:2942
static bool isInstantiationOfStaticDataMember(VarDecl *Pattern, VarDecl *Instance)
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, QualType T, NamedDecl **CH, unsigned CHS)
Definition: Decl.cpp:3920
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1290
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3222
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:825
bool isRecord() const
Definition: DeclBase.h:1247
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:158
TranslationUnitDecl - The top declaration context.
Definition: Decl.h:78
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Definition: DeclCXX.h:2598
Optional< unsigned > getNumArgumentsInExpansion(QualType T, const MultiLevelTemplateArgumentList &TemplateArgs)
Determine the number of arguments in the given pack expansion type.
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
Definition: Sema.h:766
bool isPackExpansion() const
Whether this parameter pack is a pack expansion.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3053
SourceLocation getInnerLocStart() const
Definition: Decl.h:625
virtual bool HandleTopLevelDecl(DeclGroupRef D)
Definition: ASTConsumer.cpp:20
Contains a late templated function. Will be parsed at the end of the translation unit, used by Sema & Parser.
Definition: Sema.h:9049
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3170
bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy, const EnumDecl *Prev)
Definition: SemaDecl.cpp:11272
varlist_range varlists()
Definition: DeclOpenMP.h:73
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false)
TemplateParameterList * getTemplateParameterList(unsigned index) const
Definition: Decl.h:657
SourceLocation getLAngleLoc() const
Definition: TypeLoc.h:1443
static bool isPotentialConstantExprUnevaluated(Expr *E, const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
static bool anyDependentTemplateArguments(const TemplateArgumentLoc *Args, unsigned NumArgs, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
Definition: Type.cpp:2957
bool isInvalid() const
Determines whether we have exceeded the maximum recursive template instantiations.
Definition: Sema.h:6695
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:372
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo)
Set the underlying integer type source info.
Definition: Decl.h:3127
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:230
ASTContext & Context
Definition: Sema.h:295
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2590
DeclarationNameInfo getNameInfo() const
Definition: Decl.h:1709
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:2948
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:411
EnumDecl * getDefinition() const
Definition: Decl.h:3060
Represents a C++ namespace alias.
Definition: DeclCXX.h:2662
Declaration of a friend template.
Represents C++ using-directive.
Definition: DeclCXX.h:2559
bool isNull() const
isNull - Return true if this QualType doesn't point to a type yet.
Definition: Type.h:633
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:2611
void setTypeAsWritten(TypeSourceInfo *T)
Sets the type of this specialization as it was written by the user. This will be a class template spe...
void setNRVOVariable(bool NRVO)
Definition: Decl.h:1205
NamespaceDecl * getStdNamespace() const
void setType(QualType newType)
Definition: Decl.h:539
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:466
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclTemplate.h:130
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:1863
Decl * VisitCXXMethodDecl(CXXMethodDecl *D, TemplateParameterList *TemplateParams, bool IsClassScopeSpecialization=false)
This represents '#pragma omp threadprivate ...' directive. For example, in the following, both 'a' and 'A::b' are threadprivate:
Definition: DeclOpenMP.h:36
FunctionDecl * getClassScopeSpecializationPattern() const
Retrieve the class scope template pattern that this function template specialization is instantiated ...
Definition: Decl.cpp:3068
Optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
Definition: Type.h:4459
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3062
Declaration of a template function.
Definition: DeclTemplate.h:821
void clear()
Clears out any current state.
Definition: Lookup.h:494
Attr - This represents one attribute.
Definition: Attr.h:44
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:2779
SourceLocation getNamespaceLoc() const
Returns the location of the namespace keyword.
Definition: DeclCXX.h:2749
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > & getPartialSpecializations()
Retrieve the set of partial specializations of this class template.
TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity)
Perform substitution on the type T with a given set of template arguments.
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3060
bool isMutable() const
isMutable - Determines whether this field is mutable (C++ only).
Definition: Decl.h:2327
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:654
A RAII object to temporarily push a declaration context.
Definition: Sema.h:601
void DiagnoseUnusedNestedTypedefs(const RecordDecl *D)
Definition: SemaDecl.cpp:1536