contrib/llvm/tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

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