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