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