contrib/llvm-project/clang/lib/AST/DeclTemplate.cpp

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