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