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