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

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