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