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