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