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

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