contrib/llvm/tools/clang/lib/AST/DeclTemplate.cpp

   1 //===--- DeclTemplate.cpp - Template Declaration AST Node Implementation --===//
   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 //
  10 // This file implements the C++ related Decl classes for templates.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/DeclTemplate.h"
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/ASTMutationListener.h"
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/Expr.h"
  19 #include "clang/AST/ExprCXX.h"
  20 #include "clang/AST/TypeLoc.h"
  21 #include "clang/Basic/Builtins.h"
  22 #include "clang/Basic/IdentifierTable.h"
  23 #include "llvm/ADT/STLExtras.h"
  24 #include <memory>
  25 using namespace clang;
  26
  27 //===----------------------------------------------------------------------===//
  28 // TemplateParameterList Implementation
  29 //===----------------------------------------------------------------------===//
  30
  31 TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc,
  32                                              SourceLocation LAngleLoc,
  33                                              ArrayRef<NamedDecl *> Params,
  34                                              SourceLocation RAngleLoc)
  35   : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
  36     NumParams(Params.size()), ContainsUnexpandedParameterPack(false) {
  37   assert(this->NumParams == NumParams && "Too many template parameters");
  38   for (unsigned Idx = 0; Idx < NumParams; ++Idx) {
  39     NamedDecl *P = Params[Idx];
  40     begin()[Idx] = P;
  41
  42     if (!P->isTemplateParameterPack()) {
  43       if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
  44         if (NTTP->getType()->containsUnexpandedParameterPack())
  45           ContainsUnexpandedParameterPack = true;
  46
  47       if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
  48         if (TTP->getTemplateParameters()->containsUnexpandedParameterPack())
  49           ContainsUnexpandedParameterPack = true;
  50
  51       // FIXME: If a default argument contains an unexpanded parameter pack, the
  52       // template parameter list does too.
  53     }
  54   }
  55 }
  56
  57 TemplateParameterList *TemplateParameterList::Create(
  58     const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc,
  59     ArrayRef<NamedDecl *> Params, SourceLocation RAngleLoc) {
  60   void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *>(Params.size()),
  61                          llvm::alignOf<TemplateParameterList>());
  62   return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params,
  63                                          RAngleLoc);
  64 }
  65
  66 unsigned TemplateParameterList::getMinRequiredArguments() const {
  67   unsigned NumRequiredArgs = 0;
  68   for (const NamedDecl *P : asArray()) {
  69     if (P->isTemplateParameterPack()) {
  70       if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
  71         if (NTTP->isExpandedParameterPack()) {
  72           NumRequiredArgs += NTTP->getNumExpansionTypes();
  73           continue;
  74         }
  75
  76       break;
  77     }
  78
  79     if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
  80       if (TTP->hasDefaultArgument())
  81         break;
  82     } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
  83       if (NTTP->hasDefaultArgument())
  84         break;
  85     } else if (cast<TemplateTemplateParmDecl>(P)->hasDefaultArgument())
  86       break;
  87
  88     ++NumRequiredArgs;
  89   }
  90
  91   return NumRequiredArgs;
  92 }
  93
  94 unsigned TemplateParameterList::getDepth() const {
  95   if (size() == 0)
  96     return 0;
  97
  98   const NamedDecl *FirstParm = getParam(0);
  99   if (const TemplateTypeParmDecl *TTP
 100         = dyn_cast<TemplateTypeParmDecl>(FirstParm))
 101     return TTP->getDepth();
 102   else if (const NonTypeTemplateParmDecl *NTTP
 103              = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
 104     return NTTP->getDepth();
 105   else
 106     return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
 107 }
 108
 109 static void AdoptTemplateParameterList(TemplateParameterList *Params,
 110                                        DeclContext *Owner) {
 111   for (NamedDecl *P : *Params) {
 112     P->setDeclContext(Owner);
 113
 114     if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
 115       AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner);
 116   }
 117 }
 118
 119 namespace clang {
 120 void *allocateDefaultArgStorageChain(const ASTContext &C) {
 121   return new (C) char[sizeof(void*) * 2];
 122 }
 123 }
 124
 125 //===----------------------------------------------------------------------===//
 126 // RedeclarableTemplateDecl Implementation
 127 //===----------------------------------------------------------------------===//
 128
 129 RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() const {
 130   if (Common)
 131     return Common;
 132
 133   // Walk the previous-declaration chain until we either find a declaration
 134   // with a common pointer or we run out of previous declarations.
 135   SmallVector<const RedeclarableTemplateDecl *, 2> PrevDecls;
 136   for (const RedeclarableTemplateDecl *Prev = getPreviousDecl(); Prev;
 137        Prev = Prev->getPreviousDecl()) {
 138     if (Prev->Common) {
 139       Common = Prev->Common;
 140       break;
 141     }
 142
 143     PrevDecls.push_back(Prev);
 144   }
 145
 146   // If we never found a common pointer, allocate one now.
 147   if (!Common) {
 148     // FIXME: If any of the declarations is from an AST file, we probably
 149     // need an update record to add the common data.
 150
 151     Common = newCommon(getASTContext());
 152   }
 153
 154   // Update any previous declarations we saw with the common pointer.
 155   for (const RedeclarableTemplateDecl *Prev : PrevDecls)
 156     Prev->Common = Common;
 157
 158   return Common;
 159 }
 160
 161 template<class EntryType>
 162 typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
 163 RedeclarableTemplateDecl::findSpecializationImpl(
 164     llvm::FoldingSetVector<EntryType> &Specs, ArrayRef<TemplateArgument> Args,
 165     void *&InsertPos) {
 166   typedef SpecEntryTraits<EntryType> SETraits;
 167   llvm::FoldingSetNodeID ID;
 168   EntryType::Profile(ID,Args, getASTContext());
 169   EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos);
 170   return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr;
 171 }
 172
 173 template<class Derived, class EntryType>
 174 void RedeclarableTemplateDecl::addSpecializationImpl(
 175     llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry,
 176     void *InsertPos) {
 177   typedef SpecEntryTraits<EntryType> SETraits;
 178   if (InsertPos) {
 179 #ifndef NDEBUG
 180     void *CorrectInsertPos;
 181     assert(!findSpecializationImpl(Specializations,
 182                                    SETraits::getTemplateArgs(Entry),
 183                                    CorrectInsertPos) &&
 184            InsertPos == CorrectInsertPos &&
 185            "given incorrect InsertPos for specialization");
 186 #endif
 187     Specializations.InsertNode(Entry, InsertPos);
 188   } else {
 189     EntryType *Existing = Specializations.GetOrInsertNode(Entry);
 190     (void)Existing;
 191     assert(SETraits::getDecl(Existing)->isCanonicalDecl() &&
 192            "non-canonical specialization?");
 193   }
 194
 195   if (ASTMutationListener *L = getASTMutationListener())
 196     L->AddedCXXTemplateSpecialization(cast<Derived>(this),
 197                                       SETraits::getDecl(Entry));
 198 }
 199
 200 /// \brief Generate the injected template arguments for the given template
 201 /// parameter list, e.g., for the injected-class-name of a class template.
 202 static void GenerateInjectedTemplateArgs(ASTContext &Context,
 203                                          TemplateParameterList *Params,
 204                                          TemplateArgument *Args) {
 205   for (NamedDecl *Param : *Params) {
 206     TemplateArgument Arg;
 207     if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
 208       QualType ArgType = Context.getTypeDeclType(TTP);
 209       if (TTP->isParameterPack())
 210         ArgType = Context.getPackExpansionType(ArgType, None);
 211
 212       Arg = TemplateArgument(ArgType);
 213     } else if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
 214       Expr *E = new (Context) DeclRefExpr(NTTP, /*enclosing*/ false,
 215                                   NTTP->getType().getNonLValueExprType(Context),
 216                                   Expr::getValueKindForType(NTTP->getType()),
 217                                           NTTP->getLocation());
 218
 219       if (NTTP->isParameterPack())
 220         E = new (Context) PackExpansionExpr(Context.DependentTy, E,
 221                                             NTTP->getLocation(), None);
 222       Arg = TemplateArgument(E);
 223     } else {
 224       auto *TTP = cast<TemplateTemplateParmDecl>(Param);
 225       if (TTP->isParameterPack())
 226         Arg = TemplateArgument(TemplateName(TTP), Optional<unsigned>());
 227       else
 228         Arg = TemplateArgument(TemplateName(TTP));
 229     }
 230
 231     if (Param->isTemplateParameterPack())
 232       Arg = TemplateArgument::CreatePackCopy(Context, Arg);
 233
 234     *Args++ = Arg;
 235   }
 236 }
 237
 238 //===----------------------------------------------------------------------===//
 239 // FunctionTemplateDecl Implementation
 240 //===----------------------------------------------------------------------===//
 241
 242 void FunctionTemplateDecl::DeallocateCommon(void *Ptr) {
 243   static_cast<Common *>(Ptr)->~Common();
 244 }
 245
 246 FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
 247                                                    DeclContext *DC,
 248                                                    SourceLocation L,
 249                                                    DeclarationName Name,
 250                                                TemplateParameterList *Params,
 251                                                    NamedDecl *Decl) {
 252   AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
 253   return new (C, DC) FunctionTemplateDecl(C, DC, L, Name, Params, Decl);
 254 }
 255
 256 FunctionTemplateDecl *FunctionTemplateDecl::CreateDeserialized(ASTContext &C,
 257                                                                unsigned ID) {
 258   return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(),
 259                                           DeclarationName(), nullptr, nullptr);
 260 }
 261
 262 RedeclarableTemplateDecl::CommonBase *
 263 FunctionTemplateDecl::newCommon(ASTContext &C) const {
 264   Common *CommonPtr = new (C) Common;
 265   C.AddDeallocation(DeallocateCommon, CommonPtr);
 266   return CommonPtr;
 267 }
 268
 269 void FunctionTemplateDecl::LoadLazySpecializations() const {
 270   // Grab the most recent declaration to ensure we've loaded any lazy
 271   // redeclarations of this template.
 272   //
 273   // FIXME: Avoid walking the entire redeclaration chain here.
 274   Common *CommonPtr = getMostRecentDecl()->getCommonPtr();
 275   if (CommonPtr->LazySpecializations) {
 276     ASTContext &Context = getASTContext();
 277     uint32_t *Specs = CommonPtr->LazySpecializations;
 278     CommonPtr->LazySpecializations = nullptr;
 279     for (uint32_t I = 0, N = *Specs++; I != N; ++I)
 280       (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
 281   }
 282 }
 283
 284 llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
 285 FunctionTemplateDecl::getSpecializations() const {
 286   LoadLazySpecializations();
 287   return getCommonPtr()->Specializations;
 288 }
 289
 290 FunctionDecl *
 291 FunctionTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
 292                                          void *&InsertPos) {
 293   return findSpecializationImpl(getSpecializations(), Args, InsertPos);
 294 }
 295
 296 void FunctionTemplateDecl::addSpecialization(
 297       FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
 298   addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
 299                                               InsertPos);
 300 }
 301
 302 ArrayRef<TemplateArgument> FunctionTemplateDecl::getInjectedTemplateArgs() {
 303   TemplateParameterList *Params = getTemplateParameters();
 304   Common *CommonPtr = getCommonPtr();
 305   if (!CommonPtr->InjectedArgs) {
 306     CommonPtr->InjectedArgs
 307       = new (getASTContext()) TemplateArgument[Params->size()];
 308     GenerateInjectedTemplateArgs(getASTContext(), Params,
 309                                  CommonPtr->InjectedArgs);
 310   }
 311
 312   return llvm::makeArrayRef(CommonPtr->InjectedArgs, Params->size());
 313 }
 314
 315 //===----------------------------------------------------------------------===//
 316 // ClassTemplateDecl Implementation
 317 //===----------------------------------------------------------------------===//
 318
 319 void ClassTemplateDecl::DeallocateCommon(void *Ptr) {
 320   static_cast<Common *>(Ptr)->~Common();
 321 }
 322
 323 ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
 324                                              DeclContext *DC,
 325                                              SourceLocation L,
 326                                              DeclarationName Name,
 327                                              TemplateParameterList *Params,
 328                                              NamedDecl *Decl,
 329                                              ClassTemplateDecl *PrevDecl) {
 330   AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
 331   ClassTemplateDecl *New = new (C, DC) ClassTemplateDecl(C, DC, L, Name,
 332                                                          Params, Decl);
 333   New->setPreviousDecl(PrevDecl);
 334   return New;
 335 }
 336
 337 ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C,
 338                                                          unsigned ID) {
 339   return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(),
 340                                        DeclarationName(), nullptr, nullptr);
 341 }
 342
 343 void ClassTemplateDecl::LoadLazySpecializations() const {
 344   // Grab the most recent declaration to ensure we've loaded any lazy
 345   // redeclarations of this template.
 346   //
 347   // FIXME: Avoid walking the entire redeclaration chain here.
 348   Common *CommonPtr = getMostRecentDecl()->getCommonPtr();
 349   if (CommonPtr->LazySpecializations) {
 350     ASTContext &Context = getASTContext();
 351     uint32_t *Specs = CommonPtr->LazySpecializations;
 352     CommonPtr->LazySpecializations = nullptr;
 353     for (uint32_t I = 0, N = *Specs++; I != N; ++I)
 354       (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
 355   }
 356 }
 357
 358 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
 359 ClassTemplateDecl::getSpecializations() const {
 360   LoadLazySpecializations();
 361   return getCommonPtr()->Specializations;
 362 }
 363
 364 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
 365 ClassTemplateDecl::getPartialSpecializations() {
 366   LoadLazySpecializations();
 367   return getCommonPtr()->PartialSpecializations;
 368 }
 369
 370 RedeclarableTemplateDecl::CommonBase *
 371 ClassTemplateDecl::newCommon(ASTContext &C) const {
 372   Common *CommonPtr = new (C) Common;
 373   C.AddDeallocation(DeallocateCommon, CommonPtr);
 374   return CommonPtr;
 375 }
 376
 377 ClassTemplateSpecializationDecl *
 378 ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
 379                                       void *&InsertPos) {
 380   return findSpecializationImpl(getSpecializations(), Args, InsertPos);
 381 }
 382
 383 void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
 384                                           void *InsertPos) {
 385   addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
 386 }
 387
 388 ClassTemplatePartialSpecializationDecl *
 389 ClassTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
 390                                              void *&InsertPos) {
 391   return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
 392 }
 393
 394 void ClassTemplateDecl::AddPartialSpecialization(
 395                                       ClassTemplatePartialSpecializationDecl *D,
 396                                       void *InsertPos) {
 397   if (InsertPos)
 398     getPartialSpecializations().InsertNode(D, InsertPos);
 399   else {
 400     ClassTemplatePartialSpecializationDecl *Existing
 401       = getPartialSpecializations().GetOrInsertNode(D);
 402     (void)Existing;
 403     assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
 404   }
 405
 406   if (ASTMutationListener *L = getASTMutationListener())
 407     L->AddedCXXTemplateSpecialization(this, D);
 408 }
 409
 410 void ClassTemplateDecl::getPartialSpecializations(
 411           SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) {
 412   llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
 413     = getPartialSpecializations();
 414   PS.clear();
 415   PS.reserve(PartialSpecs.size());
 416   for (ClassTemplatePartialSpecializationDecl &P : PartialSpecs)
 417     PS.push_back(P.getMostRecentDecl());
 418 }
 419
 420 ClassTemplatePartialSpecializationDecl *
 421 ClassTemplateDecl::findPartialSpecialization(QualType T) {
 422   ASTContext &Context = getASTContext();
 423   for (ClassTemplatePartialSpecializationDecl &P :
 424        getPartialSpecializations()) {
 425     if (Context.hasSameType(P.getInjectedSpecializationType(), T))
 426       return P.getMostRecentDecl();
 427   }
 428
 429   return nullptr;
 430 }
 431
 432 ClassTemplatePartialSpecializationDecl *
 433 ClassTemplateDecl::findPartialSpecInstantiatedFromMember(
 434                                     ClassTemplatePartialSpecializationDecl *D) {
 435   Decl *DCanon = D->getCanonicalDecl();
 436   for (ClassTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
 437     if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
 438       return P.getMostRecentDecl();
 439   }
 440
 441   return nullptr;
 442 }
 443
 444 QualType
 445 ClassTemplateDecl::getInjectedClassNameSpecialization() {
 446   Common *CommonPtr = getCommonPtr();
 447   if (!CommonPtr->InjectedClassNameType.isNull())
 448     return CommonPtr->InjectedClassNameType;
 449
 450   // C++0x [temp.dep.type]p2:
 451   //  The template argument list of a primary template is a template argument
 452   //  list in which the nth template argument has the value of the nth template
 453   //  parameter of the class template. If the nth template parameter is a
 454   //  template parameter pack (14.5.3), the nth template argument is a pack
 455   //  expansion (14.5.3) whose pattern is the name of the template parameter
 456   //  pack.
 457   ASTContext &Context = getASTContext();
 458   TemplateParameterList *Params = getTemplateParameters();
 459   SmallVector<TemplateArgument, 16> TemplateArgs;
 460   TemplateArgs.resize(Params->size());
 461   GenerateInjectedTemplateArgs(getASTContext(), Params, TemplateArgs.data());
 462   CommonPtr->InjectedClassNameType
 463     = Context.getTemplateSpecializationType(TemplateName(this),
 464                                             TemplateArgs);
 465   return CommonPtr->InjectedClassNameType;
 466 }
 467
 468 //===----------------------------------------------------------------------===//
 469 // TemplateTypeParm Allocation/Deallocation Method Implementations
 470 //===----------------------------------------------------------------------===//
 471
 472 TemplateTypeParmDecl *
 473 TemplateTypeParmDecl::Create(const ASTContext &C, DeclContext *DC,
 474                              SourceLocation KeyLoc, SourceLocation NameLoc,
 475                              unsigned D, unsigned P, IdentifierInfo *Id,
 476                              bool Typename, bool ParameterPack) {
 477   TemplateTypeParmDecl *TTPDecl =
 478     new (C, DC) TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename);
 479   QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
 480   TTPDecl->setTypeForDecl(TTPType.getTypePtr());
 481   return TTPDecl;
 482 }
 483
 484 TemplateTypeParmDecl *
 485 TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
 486   return new (C, ID) TemplateTypeParmDecl(nullptr, SourceLocation(),
 487                                           SourceLocation(), nullptr, false);
 488 }
 489
 490 SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
 491   return hasDefaultArgument()
 492              ? getDefaultArgumentInfo()->getTypeLoc().getBeginLoc()
 493              : SourceLocation();
 494 }
 495
 496 SourceRange TemplateTypeParmDecl::getSourceRange() const {
 497   if (hasDefaultArgument() && !defaultArgumentWasInherited())
 498     return SourceRange(getLocStart(),
 499                        getDefaultArgumentInfo()->getTypeLoc().getEndLoc());
 500   else
 501     return TypeDecl::getSourceRange();
 502 }
 503
 504 unsigned TemplateTypeParmDecl::getDepth() const {
 505   return getTypeForDecl()->getAs<TemplateTypeParmType>()->getDepth();
 506 }
 507
 508 unsigned TemplateTypeParmDecl::getIndex() const {
 509   return getTypeForDecl()->getAs<TemplateTypeParmType>()->getIndex();
 510 }
 511
 512 bool TemplateTypeParmDecl::isParameterPack() const {
 513   return getTypeForDecl()->getAs<TemplateTypeParmType>()->isParameterPack();
 514 }
 515
 516 //===----------------------------------------------------------------------===//
 517 // NonTypeTemplateParmDecl Method Implementations
 518 //===----------------------------------------------------------------------===//
 519
 520 NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(
 521     DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D,
 522     unsigned P, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
 523     ArrayRef<QualType> ExpandedTypes, ArrayRef<TypeSourceInfo *> ExpandedTInfos)
 524     : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
 525       TemplateParmPosition(D, P), ParameterPack(true),
 526       ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) {
 527   if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) {
 528     auto TypesAndInfos =
 529         getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
 530     for (unsigned I = 0; I != NumExpandedTypes; ++I) {
 531       new (&TypesAndInfos[I].first) QualType(ExpandedTypes[I]);
 532       TypesAndInfos[I].second = ExpandedTInfos[I];
 533     }
 534   }
 535 }
 536
 537 NonTypeTemplateParmDecl *
 538 NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
 539                                 SourceLocation StartLoc, SourceLocation IdLoc,
 540                                 unsigned D, unsigned P, IdentifierInfo *Id,
 541                                 QualType T, bool ParameterPack,
 542                                 TypeSourceInfo *TInfo) {
 543   return new (C, DC) NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id,
 544                                              T, ParameterPack, TInfo);
 545 }
 546
 547 NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
 548     const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
 549     SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
 550     QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
 551     ArrayRef<TypeSourceInfo *> ExpandedTInfos) {
 552   return new (C, DC,
 553               additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
 554                   ExpandedTypes.size()))
 555       NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo,
 556                               ExpandedTypes, ExpandedTInfos);
 557 }
 558
 559 NonTypeTemplateParmDecl *
 560 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
 561   return new (C, ID) NonTypeTemplateParmDecl(nullptr, SourceLocation(),
 562                                              SourceLocation(), 0, 0, nullptr,
 563                                              QualType(), false, nullptr);
 564 }
 565
 566 NonTypeTemplateParmDecl *
 567 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
 568                                             unsigned NumExpandedTypes) {
 569   auto *NTTP =
 570       new (C, ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
 571                       NumExpandedTypes))
 572           NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
 573                                   0, 0, nullptr, QualType(), nullptr, None,
 574                                   None);
 575   NTTP->NumExpandedTypes = NumExpandedTypes;
 576   return NTTP;
 577 }
 578
 579 SourceRange NonTypeTemplateParmDecl::getSourceRange() const {
 580   if (hasDefaultArgument() && !defaultArgumentWasInherited())
 581     return SourceRange(getOuterLocStart(),
 582                        getDefaultArgument()->getSourceRange().getEnd());
 583   return DeclaratorDecl::getSourceRange();
 584 }
 585
 586 SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
 587   return hasDefaultArgument()
 588     ? getDefaultArgument()->getSourceRange().getBegin()
 589     : SourceLocation();
 590 }
 591
 592 //===----------------------------------------------------------------------===//
 593 // TemplateTemplateParmDecl Method Implementations
 594 //===----------------------------------------------------------------------===//
 595
 596 void TemplateTemplateParmDecl::anchor() { }
 597
 598 TemplateTemplateParmDecl::TemplateTemplateParmDecl(
 599     DeclContext *DC, SourceLocation L, unsigned D, unsigned P,
 600     IdentifierInfo *Id, TemplateParameterList *Params,
 601     ArrayRef<TemplateParameterList *> Expansions)
 602     : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
 603       TemplateParmPosition(D, P), ParameterPack(true),
 604       ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) {
 605   if (!Expansions.empty())
 606     std::uninitialized_copy(Expansions.begin(), Expansions.end(),
 607                             getTrailingObjects<TemplateParameterList *>());
 608 }
 609
 610 TemplateTemplateParmDecl *
 611 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
 612                                  SourceLocation L, unsigned D, unsigned P,
 613                                  bool ParameterPack, IdentifierInfo *Id,
 614                                  TemplateParameterList *Params) {
 615   return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
 616                                               Params);
 617 }
 618
 619 TemplateTemplateParmDecl *
 620 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
 621                                  SourceLocation L, unsigned D, unsigned P,
 622                                  IdentifierInfo *Id,
 623                                  TemplateParameterList *Params,
 624                                  ArrayRef<TemplateParameterList *> Expansions) {
 625   return new (C, DC,
 626               additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
 627       TemplateTemplateParmDecl(DC, L, D, P, Id, Params, Expansions);
 628 }
 629
 630 TemplateTemplateParmDecl *
 631 TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
 632   return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0,
 633                                               false, nullptr, nullptr);
 634 }
 635
 636 TemplateTemplateParmDecl *
 637 TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
 638                                              unsigned NumExpansions) {
 639   auto *TTP =
 640       new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))
 641           TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr,
 642                                    nullptr, None);
 643   TTP->NumExpandedParams = NumExpansions;
 644   return TTP;
 645 }
 646
 647 SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const {
 648   return hasDefaultArgument() ? getDefaultArgument().getLocation()
 649                               : SourceLocation();
 650 }
 651
 652 void TemplateTemplateParmDecl::setDefaultArgument(
 653     const ASTContext &C, const TemplateArgumentLoc &DefArg) {
 654   if (DefArg.getArgument().isNull())
 655     DefaultArgument.set(nullptr);
 656   else
 657     DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg));
 658 }
 659
 660 //===----------------------------------------------------------------------===//
 661 // TemplateArgumentList Implementation
 662 //===----------------------------------------------------------------------===//
 663 TemplateArgumentList::TemplateArgumentList(ArrayRef<TemplateArgument> Args)
 664     : Arguments(getTrailingObjects<TemplateArgument>()),
 665       NumArguments(Args.size()) {
 666   std::uninitialized_copy(Args.begin(), Args.end(),
 667                           getTrailingObjects<TemplateArgument>());
 668 }
 669
 670 TemplateArgumentList *
 671 TemplateArgumentList::CreateCopy(ASTContext &Context,
 672                                  ArrayRef<TemplateArgument> Args) {
 673   void *Mem = Context.Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));
 674   return new (Mem) TemplateArgumentList(Args);
 675 }
 676
 677 FunctionTemplateSpecializationInfo *
 678 FunctionTemplateSpecializationInfo::Create(ASTContext &C, FunctionDecl *FD,
 679                                            FunctionTemplateDecl *Template,
 680                                            TemplateSpecializationKind TSK,
 681                                        const TemplateArgumentList *TemplateArgs,
 682                           const TemplateArgumentListInfo *TemplateArgsAsWritten,
 683                                            SourceLocation POI) {
 684   const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
 685   if (TemplateArgsAsWritten)
 686     ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C,
 687                                                         *TemplateArgsAsWritten);
 688
 689   return new (C) FunctionTemplateSpecializationInfo(FD, Template, TSK,
 690                                                     TemplateArgs,
 691                                                     ArgsAsWritten,
 692                                                     POI);
 693 }
 694
 695 //===----------------------------------------------------------------------===//
 696 // TemplateDecl Implementation
 697 //===----------------------------------------------------------------------===//
 698
 699 void TemplateDecl::anchor() { }
 700
 701 //===----------------------------------------------------------------------===//
 702 // ClassTemplateSpecializationDecl Implementation
 703 //===----------------------------------------------------------------------===//
 704 ClassTemplateSpecializationDecl::
 705 ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
 706                                 DeclContext *DC, SourceLocation StartLoc,
 707                                 SourceLocation IdLoc,
 708                                 ClassTemplateDecl *SpecializedTemplate,
 709                                 ArrayRef<TemplateArgument> Args,
 710                                 ClassTemplateSpecializationDecl *PrevDecl)
 711   : CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc,
 712                   SpecializedTemplate->getIdentifier(),
 713                   PrevDecl),
 714     SpecializedTemplate(SpecializedTemplate),
 715     ExplicitInfo(nullptr),
 716     TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
 717     SpecializationKind(TSK_Undeclared) {
 718 }
 719
 720 ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C,
 721                                                                  Kind DK)
 722     : CXXRecordDecl(DK, TTK_Struct, C, nullptr, SourceLocation(),
 723                     SourceLocation(), nullptr, nullptr),
 724       ExplicitInfo(nullptr), SpecializationKind(TSK_Undeclared) {}
 725
 726 ClassTemplateSpecializationDecl *
 727 ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
 728                                         DeclContext *DC,
 729                                         SourceLocation StartLoc,
 730                                         SourceLocation IdLoc,
 731                                         ClassTemplateDecl *SpecializedTemplate,
 732                                         ArrayRef<TemplateArgument> Args,
 733                                    ClassTemplateSpecializationDecl *PrevDecl) {
 734   ClassTemplateSpecializationDecl *Result =
 735       new (Context, DC) ClassTemplateSpecializationDecl(
 736           Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
 737           SpecializedTemplate, Args, PrevDecl);
 738   Result->MayHaveOutOfDateDef = false;
 739
 740   Context.getTypeDeclType(Result, PrevDecl);
 741   return Result;
 742 }
 743
 744 ClassTemplateSpecializationDecl *
 745 ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
 746                                                     unsigned ID) {
 747   ClassTemplateSpecializationDecl *Result =
 748     new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
 749   Result->MayHaveOutOfDateDef = false;
 750   return Result;
 751 }
 752
 753 void ClassTemplateSpecializationDecl::getNameForDiagnostic(
 754     raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
 755   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
 756
 757   const TemplateArgumentList &TemplateArgs = getTemplateArgs();
 758   TemplateSpecializationType::PrintTemplateArgumentList(
 759       OS, TemplateArgs.asArray(), Policy);
 760 }
 761
 762 ClassTemplateDecl *
 763 ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
 764   if (SpecializedPartialSpecialization *PartialSpec
 765       = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
 766     return PartialSpec->PartialSpecialization->getSpecializedTemplate();
 767   return SpecializedTemplate.get<ClassTemplateDecl*>();
 768 }
 769
 770 SourceRange
 771 ClassTemplateSpecializationDecl::getSourceRange() const {
 772   if (ExplicitInfo) {
 773     SourceLocation Begin = getTemplateKeywordLoc();
 774     if (Begin.isValid()) {
 775       // Here we have an explicit (partial) specialization or instantiation.
 776       assert(getSpecializationKind() == TSK_ExplicitSpecialization ||
 777              getSpecializationKind() == TSK_ExplicitInstantiationDeclaration ||
 778              getSpecializationKind() == TSK_ExplicitInstantiationDefinition);
 779       if (getExternLoc().isValid())
 780         Begin = getExternLoc();
 781       SourceLocation End = getBraceRange().getEnd();
 782       if (End.isInvalid())
 783         End = getTypeAsWritten()->getTypeLoc().getEndLoc();
 784       return SourceRange(Begin, End);
 785     }
 786     // An implicit instantiation of a class template partial specialization
 787     // uses ExplicitInfo to record the TypeAsWritten, but the source
 788     // locations should be retrieved from the instantiation pattern.
 789     typedef ClassTemplatePartialSpecializationDecl CTPSDecl;
 790     CTPSDecl *ctpsd = const_cast<CTPSDecl*>(cast<CTPSDecl>(this));
 791     CTPSDecl *inst_from = ctpsd->getInstantiatedFromMember();
 792     assert(inst_from != nullptr);
 793     return inst_from->getSourceRange();
 794   }
 795   else {
 796     // No explicit info available.
 797     llvm::PointerUnion<ClassTemplateDecl *,
 798                        ClassTemplatePartialSpecializationDecl *>
 799       inst_from = getInstantiatedFrom();
 800     if (inst_from.isNull())
 801       return getSpecializedTemplate()->getSourceRange();
 802     if (ClassTemplateDecl *ctd = inst_from.dyn_cast<ClassTemplateDecl*>())
 803       return ctd->getSourceRange();
 804     return inst_from.get<ClassTemplatePartialSpecializationDecl*>()
 805       ->getSourceRange();
 806   }
 807 }
 808
 809 //===----------------------------------------------------------------------===//
 810 // ClassTemplatePartialSpecializationDecl Implementation
 811 //===----------------------------------------------------------------------===//
 812 void ClassTemplatePartialSpecializationDecl::anchor() { }
 813
 814 ClassTemplatePartialSpecializationDecl::
 815 ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
 816                                        DeclContext *DC,
 817                                        SourceLocation StartLoc,
 818                                        SourceLocation IdLoc,
 819                                        TemplateParameterList *Params,
 820                                        ClassTemplateDecl *SpecializedTemplate,
 821                                        ArrayRef<TemplateArgument> Args,
 822                                const ASTTemplateArgumentListInfo *ArgInfos,
 823                                ClassTemplatePartialSpecializationDecl *PrevDecl)
 824   : ClassTemplateSpecializationDecl(Context,
 825                                     ClassTemplatePartialSpecialization,
 826                                     TK, DC, StartLoc, IdLoc,
 827                                     SpecializedTemplate,
 828                                     Args, PrevDecl),
 829     TemplateParams(Params), ArgsAsWritten(ArgInfos),
 830     InstantiatedFromMember(nullptr, false)
 831 {
 832   AdoptTemplateParameterList(Params, this);
 833 }
 834
 835 ClassTemplatePartialSpecializationDecl *
 836 ClassTemplatePartialSpecializationDecl::
 837 Create(ASTContext &Context, TagKind TK,DeclContext *DC,
 838        SourceLocation StartLoc, SourceLocation IdLoc,
 839        TemplateParameterList *Params,
 840        ClassTemplateDecl *SpecializedTemplate,
 841        ArrayRef<TemplateArgument> Args,
 842        const TemplateArgumentListInfo &ArgInfos,
 843        QualType CanonInjectedType,
 844        ClassTemplatePartialSpecializationDecl *PrevDecl) {
 845   const ASTTemplateArgumentListInfo *ASTArgInfos =
 846     ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
 847
 848   ClassTemplatePartialSpecializationDecl *Result = new (Context, DC)
 849       ClassTemplatePartialSpecializationDecl(Context, TK, DC, StartLoc, IdLoc,
 850                                              Params, SpecializedTemplate, Args,
 851                                              ASTArgInfos, PrevDecl);
 852   Result->setSpecializationKind(TSK_ExplicitSpecialization);
 853   Result->MayHaveOutOfDateDef = false;
 854
 855   Context.getInjectedClassNameType(Result, CanonInjectedType);
 856   return Result;
 857 }
 858
 859 ClassTemplatePartialSpecializationDecl *
 860 ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
 861                                                            unsigned ID) {
 862   ClassTemplatePartialSpecializationDecl *Result =
 863       new (C, ID) ClassTemplatePartialSpecializationDecl(C);
 864   Result->MayHaveOutOfDateDef = false;
 865   return Result;
 866 }
 867
 868 //===----------------------------------------------------------------------===//
 869 // FriendTemplateDecl Implementation
 870 //===----------------------------------------------------------------------===//
 871
 872 void FriendTemplateDecl::anchor() { }
 873
 874 FriendTemplateDecl *
 875 FriendTemplateDecl::Create(ASTContext &Context, DeclContext *DC,
 876                            SourceLocation L,
 877                            MutableArrayRef<TemplateParameterList *> Params,
 878                            FriendUnion Friend, SourceLocation FLoc) {
 879   return new (Context, DC) FriendTemplateDecl(DC, L, Params, Friend, FLoc);
 880 }
 881
 882 FriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C,
 883                                                            unsigned ID) {
 884   return new (C, ID) FriendTemplateDecl(EmptyShell());
 885 }
 886
 887 //===----------------------------------------------------------------------===//
 888 // TypeAliasTemplateDecl Implementation
 889 //===----------------------------------------------------------------------===//
 890
 891 TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C,
 892                                                      DeclContext *DC,
 893                                                      SourceLocation L,
 894                                                      DeclarationName Name,
 895                                                   TemplateParameterList *Params,
 896                                                      NamedDecl *Decl) {
 897   AdoptTemplateParameterList(Params, DC);
 898   return new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl);
 899 }
 900
 901 TypeAliasTemplateDecl *TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C,
 902                                                                  unsigned ID) {
 903   return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(),
 904                                            DeclarationName(), nullptr, nullptr);
 905 }
 906
 907 void TypeAliasTemplateDecl::DeallocateCommon(void *Ptr) {
 908   static_cast<Common *>(Ptr)->~Common();
 909 }
 910 RedeclarableTemplateDecl::CommonBase *
 911 TypeAliasTemplateDecl::newCommon(ASTContext &C) const {
 912   Common *CommonPtr = new (C) Common;
 913   C.AddDeallocation(DeallocateCommon, CommonPtr);
 914   return CommonPtr;
 915 }
 916
 917 //===----------------------------------------------------------------------===//
 918 // ClassScopeFunctionSpecializationDecl Implementation
 919 //===----------------------------------------------------------------------===//
 920
 921 void ClassScopeFunctionSpecializationDecl::anchor() { }
 922
 923 ClassScopeFunctionSpecializationDecl *
 924 ClassScopeFunctionSpecializationDecl::CreateDeserialized(ASTContext &C,
 925                                                          unsigned ID) {
 926   return new (C, ID) ClassScopeFunctionSpecializationDecl(
 927       nullptr, SourceLocation(), nullptr, false, TemplateArgumentListInfo());
 928 }
 929
 930 //===----------------------------------------------------------------------===//
 931 // VarTemplateDecl Implementation
 932 //===----------------------------------------------------------------------===//
 933
 934 void VarTemplateDecl::DeallocateCommon(void *Ptr) {
 935   static_cast<Common *>(Ptr)->~Common();
 936 }
 937
 938 VarTemplateDecl *VarTemplateDecl::getDefinition() {
 939   VarTemplateDecl *CurD = this;
 940   while (CurD) {
 941     if (CurD->isThisDeclarationADefinition())
 942       return CurD;
 943     CurD = CurD->getPreviousDecl();
 944   }
 945   return nullptr;
 946 }
 947
 948 VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C, DeclContext *DC,
 949                                          SourceLocation L, DeclarationName Name,
 950                                          TemplateParameterList *Params,
 951                                          VarDecl *Decl) {
 952   return new (C, DC) VarTemplateDecl(C, DC, L, Name, Params, Decl);
 953 }
 954
 955 VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C,
 956                                                      unsigned ID) {
 957   return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(),
 958                                      DeclarationName(), nullptr, nullptr);
 959 }
 960
 961 // TODO: Unify across class, function and variable templates?
 962 //       May require moving this and Common to RedeclarableTemplateDecl.
 963 void VarTemplateDecl::LoadLazySpecializations() const {
 964   // Grab the most recent declaration to ensure we've loaded any lazy
 965   // redeclarations of this template.
 966   //
 967   // FIXME: Avoid walking the entire redeclaration chain here.
 968   Common *CommonPtr = getMostRecentDecl()->getCommonPtr();
 969   if (CommonPtr->LazySpecializations) {
 970     ASTContext &Context = getASTContext();
 971     uint32_t *Specs = CommonPtr->LazySpecializations;
 972     CommonPtr->LazySpecializations = nullptr;
 973     for (uint32_t I = 0, N = *Specs++; I != N; ++I)
 974       (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
 975   }
 976 }
 977
 978 llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
 979 VarTemplateDecl::getSpecializations() const {
 980   LoadLazySpecializations();
 981   return getCommonPtr()->Specializations;
 982 }
 983
 984 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
 985 VarTemplateDecl::getPartialSpecializations() {
 986   LoadLazySpecializations();
 987   return getCommonPtr()->PartialSpecializations;
 988 }
 989
 990 RedeclarableTemplateDecl::CommonBase *
 991 VarTemplateDecl::newCommon(ASTContext &C) const {
 992   Common *CommonPtr = new (C) Common;
 993   C.AddDeallocation(DeallocateCommon, CommonPtr);
 994   return CommonPtr;
 995 }
 996
 997 VarTemplateSpecializationDecl *
 998 VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
 999                                     void *&InsertPos) {
1000   return findSpecializationImpl(getSpecializations(), Args, InsertPos);
1001 }
1002
1003 void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D,
1004                                         void *InsertPos) {
1005   addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
1006 }
1007
1008 VarTemplatePartialSpecializationDecl *
1009 VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
1010                                            void *&InsertPos) {
1011   return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
1012 }
1013
1014 void VarTemplateDecl::AddPartialSpecialization(
1015     VarTemplatePartialSpecializationDecl *D, void *InsertPos) {
1016   if (InsertPos)
1017     getPartialSpecializations().InsertNode(D, InsertPos);
1018   else {
1019     VarTemplatePartialSpecializationDecl *Existing =
1020         getPartialSpecializations().GetOrInsertNode(D);
1021     (void)Existing;
1022     assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
1023   }
1024
1025   if (ASTMutationListener *L = getASTMutationListener())
1026     L->AddedCXXTemplateSpecialization(this, D);
1027 }
1028
1029 void VarTemplateDecl::getPartialSpecializations(
1030     SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) {
1031   llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs =
1032       getPartialSpecializations();
1033   PS.clear();
1034   PS.reserve(PartialSpecs.size());
1035   for (VarTemplatePartialSpecializationDecl &P : PartialSpecs)
1036     PS.push_back(P.getMostRecentDecl());
1037 }
1038
1039 VarTemplatePartialSpecializationDecl *
1040 VarTemplateDecl::findPartialSpecInstantiatedFromMember(
1041     VarTemplatePartialSpecializationDecl *D) {
1042   Decl *DCanon = D->getCanonicalDecl();
1043   for (VarTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
1044     if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
1045       return P.getMostRecentDecl();
1046   }
1047
1048   return nullptr;
1049 }
1050
1051 //===----------------------------------------------------------------------===//
1052 // VarTemplateSpecializationDecl Implementation
1053 //===----------------------------------------------------------------------===//
1054 VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(
1055     Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1056     SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1057     TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args)
1058     : VarDecl(DK, Context, DC, StartLoc, IdLoc,
1059               SpecializedTemplate->getIdentifier(), T, TInfo, S),
1060       SpecializedTemplate(SpecializedTemplate), ExplicitInfo(nullptr),
1061       TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
1062       SpecializationKind(TSK_Undeclared) {}
1063
1064 VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(Kind DK,
1065                                                              ASTContext &C)
1066     : VarDecl(DK, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
1067               QualType(), nullptr, SC_None),
1068       ExplicitInfo(nullptr), SpecializationKind(TSK_Undeclared) {}
1069
1070 VarTemplateSpecializationDecl *VarTemplateSpecializationDecl::Create(
1071     ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1072     SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1073     TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args) {
1074   return new (Context, DC) VarTemplateSpecializationDecl(
1075       VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,
1076       SpecializedTemplate, T, TInfo, S, Args);
1077 }
1078
1079 VarTemplateSpecializationDecl *
1080 VarTemplateSpecializationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1081   return new (C, ID)
1082       VarTemplateSpecializationDecl(VarTemplateSpecialization, C);
1083 }
1084
1085 void VarTemplateSpecializationDecl::getNameForDiagnostic(
1086     raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
1087   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
1088
1089   const TemplateArgumentList &TemplateArgs = getTemplateArgs();
1090   TemplateSpecializationType::PrintTemplateArgumentList(
1091       OS, TemplateArgs.asArray(), Policy);
1092 }
1093
1094 VarTemplateDecl *VarTemplateSpecializationDecl::getSpecializedTemplate() const {
1095   if (SpecializedPartialSpecialization *PartialSpec =
1096           SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1097     return PartialSpec->PartialSpecialization->getSpecializedTemplate();
1098   return SpecializedTemplate.get<VarTemplateDecl *>();
1099 }
1100
1101 void VarTemplateSpecializationDecl::setTemplateArgsInfo(
1102     const TemplateArgumentListInfo &ArgsInfo) {
1103   TemplateArgsInfo.setLAngleLoc(ArgsInfo.getLAngleLoc());
1104   TemplateArgsInfo.setRAngleLoc(ArgsInfo.getRAngleLoc());
1105   for (const TemplateArgumentLoc &Loc : ArgsInfo.arguments())
1106     TemplateArgsInfo.addArgument(Loc);
1107 }
1108
1109 //===----------------------------------------------------------------------===//
1110 // VarTemplatePartialSpecializationDecl Implementation
1111 //===----------------------------------------------------------------------===//
1112 void VarTemplatePartialSpecializationDecl::anchor() {}
1113
1114 VarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl(
1115     ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1116     SourceLocation IdLoc, TemplateParameterList *Params,
1117     VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1118     StorageClass S, ArrayRef<TemplateArgument> Args,
1119     const ASTTemplateArgumentListInfo *ArgInfos)
1120     : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context,
1121                                     DC, StartLoc, IdLoc, SpecializedTemplate, T,
1122                                     TInfo, S, Args),
1123       TemplateParams(Params), ArgsAsWritten(ArgInfos),
1124       InstantiatedFromMember(nullptr, false) {
1125   // TODO: The template parameters should be in DC by now. Verify.
1126   // AdoptTemplateParameterList(Params, DC);
1127 }
1128
1129 VarTemplatePartialSpecializationDecl *
1130 VarTemplatePartialSpecializationDecl::Create(
1131     ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1132     SourceLocation IdLoc, TemplateParameterList *Params,
1133     VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1134     StorageClass S, ArrayRef<TemplateArgument> Args,
1135     const TemplateArgumentListInfo &ArgInfos) {
1136   const ASTTemplateArgumentListInfo *ASTArgInfos
1137     = ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
1138
1139   VarTemplatePartialSpecializationDecl *Result =
1140       new (Context, DC) VarTemplatePartialSpecializationDecl(
1141           Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo,
1142           S, Args, ASTArgInfos);
1143   Result->setSpecializationKind(TSK_ExplicitSpecialization);
1144   return Result;
1145 }
1146
1147 VarTemplatePartialSpecializationDecl *
1148 VarTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
1149                                                          unsigned ID) {
1150   return new (C, ID) VarTemplatePartialSpecializationDecl(C);
1151 }
1152
1153 static TemplateParameterList *
1154 createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC) {
1155   // typename T
1156   auto *T = TemplateTypeParmDecl::Create(
1157       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,
1158       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false);
1159   T->setImplicit(true);
1160
1161   // T ...Ints
1162   TypeSourceInfo *TI =
1163       C.getTrivialTypeSourceInfo(QualType(T->getTypeForDecl(), 0));
1164   auto *N = NonTypeTemplateParmDecl::Create(
1165       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1166       /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true, TI);
1167   N->setImplicit(true);
1168
1169   // <typename T, T ...Ints>
1170   NamedDecl *P[2] = {T, N};
1171   auto *TPL = TemplateParameterList::Create(
1172       C, SourceLocation(), SourceLocation(), P, SourceLocation());
1173
1174   // template <typename T, ...Ints> class IntSeq
1175   auto *TemplateTemplateParm = TemplateTemplateParmDecl::Create(
1176       C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/0,
1177       /*ParameterPack=*/false, /*Id=*/nullptr, TPL);
1178   TemplateTemplateParm->setImplicit(true);
1179
1180   // typename T
1181   auto *TemplateTypeParm = TemplateTypeParmDecl::Create(
1182       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1183       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false);
1184   TemplateTypeParm->setImplicit(true);
1185
1186   // T N
1187   TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(
1188       QualType(TemplateTypeParm->getTypeForDecl(), 0));
1189   auto *NonTypeTemplateParm = NonTypeTemplateParmDecl::Create(
1190       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/2,
1191       /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1192   NamedDecl *Params[] = {TemplateTemplateParm, TemplateTypeParm,
1193                          NonTypeTemplateParm};
1194
1195   // template <template <typename T, T ...Ints> class IntSeq, typename T, T N>
1196   return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
1197                                        Params, SourceLocation());
1198 }
1199
1200 static TemplateParameterList *
1201 createTypePackElementParameterList(const ASTContext &C, DeclContext *DC) {
1202   // std::size_t Index
1203   TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(C.getSizeType());
1204   auto *Index = NonTypeTemplateParmDecl::Create(
1205       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
1206       /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1207
1208   // typename ...T
1209   auto *Ts = TemplateTypeParmDecl::Create(
1210       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1211       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/true);
1212   Ts->setImplicit(true);
1213
1214   // template <std::size_t Index, typename ...T>
1215   NamedDecl *Params[] = {Index, Ts};
1216   return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
1217                                        llvm::makeArrayRef(Params),
1218                                        SourceLocation());
1219 }
1220
1221 static TemplateParameterList *createBuiltinTemplateParameterList(
1222     const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) {
1223   switch (BTK) {
1224   case BTK__make_integer_seq:
1225     return createMakeIntegerSeqParameterList(C, DC);
1226   case BTK__type_pack_element:
1227     return createTypePackElementParameterList(C, DC);
1228   }
1229
1230   llvm_unreachable("unhandled BuiltinTemplateKind!");
1231 }
1232
1233 void BuiltinTemplateDecl::anchor() {}
1234
1235 BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
1236                                          DeclarationName Name,
1237                                          BuiltinTemplateKind BTK)
1238     : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name,
1239                    createBuiltinTemplateParameterList(C, DC, BTK)),
1240       BTK(BTK) {}