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