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/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 (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
  60         if (NTTP->getType()->containsUnexpandedParameterPack())
  61           ContainsUnexpandedParameterPack = true;
  62
  63       if (TemplateTemplateParmDecl *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 TemplateTypeParmDecl *TTP
 122         = dyn_cast<TemplateTypeParmDecl>(FirstParm))
 123     return TTP->getDepth();
 124   else if (const NonTypeTemplateParmDecl *NTTP
 125              = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
 126     return NTTP->getDepth();
 127   else
 128     return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
 129 }
 130
 131 static void AdoptTemplateParameterList(TemplateParameterList *Params,
 132                                        DeclContext *Owner) {
 133   for (NamedDecl *P : *Params) {
 134     P->setDeclContext(Owner);
 135
 136     if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
 137       AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner);
 138   }
 139 }
 140
 141 namespace clang {
 142
 143 void *allocateDefaultArgStorageChain(const ASTContext &C) {
 144   return new (C) char[sizeof(void*) * 2];
 145 }
 146
 147 } // namespace clang
 148
 149 //===----------------------------------------------------------------------===//
 150 // RedeclarableTemplateDecl Implementation
 151 //===----------------------------------------------------------------------===//
 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   Common *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 //===----------------------------------------------------------------------===//
 305 // ClassTemplateDecl Implementation
 306 //===----------------------------------------------------------------------===//
 307
 308 ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
 309                                              DeclContext *DC,
 310                                              SourceLocation L,
 311                                              DeclarationName Name,
 312                                              TemplateParameterList *Params,
 313                                              NamedDecl *Decl,
 314                                              Expr *AssociatedConstraints) {
 315   AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
 316
 317   if (!AssociatedConstraints) {
 318     return new (C, DC) ClassTemplateDecl(C, DC, L, Name, Params, Decl);
 319   }
 320
 321   ConstrainedTemplateDeclInfo *const CTDI = new (C) ConstrainedTemplateDeclInfo;
 322   ClassTemplateDecl *const New =
 323       new (C, DC) ClassTemplateDecl(CTDI, C, DC, L, Name, Params, Decl);
 324   New->setAssociatedConstraints(AssociatedConstraints);
 325   return New;
 326 }
 327
 328 ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C,
 329                                                          unsigned ID) {
 330   return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(),
 331                                        DeclarationName(), nullptr, nullptr);
 332 }
 333
 334 void ClassTemplateDecl::LoadLazySpecializations() const {
 335   loadLazySpecializationsImpl();
 336 }
 337
 338 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
 339 ClassTemplateDecl::getSpecializations() const {
 340   LoadLazySpecializations();
 341   return getCommonPtr()->Specializations;
 342 }
 343
 344 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
 345 ClassTemplateDecl::getPartialSpecializations() {
 346   LoadLazySpecializations();
 347   return getCommonPtr()->PartialSpecializations;
 348 }
 349
 350 RedeclarableTemplateDecl::CommonBase *
 351 ClassTemplateDecl::newCommon(ASTContext &C) const {
 352   Common *CommonPtr = new (C) Common;
 353   C.addDestruction(CommonPtr);
 354   return CommonPtr;
 355 }
 356
 357 ClassTemplateSpecializationDecl *
 358 ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
 359                                       void *&InsertPos) {
 360   return findSpecializationImpl(getSpecializations(), Args, InsertPos);
 361 }
 362
 363 void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
 364                                           void *InsertPos) {
 365   addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
 366 }
 367
 368 ClassTemplatePartialSpecializationDecl *
 369 ClassTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
 370                                              void *&InsertPos) {
 371   return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
 372 }
 373
 374 void ClassTemplateDecl::AddPartialSpecialization(
 375                                       ClassTemplatePartialSpecializationDecl *D,
 376                                       void *InsertPos) {
 377   if (InsertPos)
 378     getPartialSpecializations().InsertNode(D, InsertPos);
 379   else {
 380     ClassTemplatePartialSpecializationDecl *Existing
 381       = getPartialSpecializations().GetOrInsertNode(D);
 382     (void)Existing;
 383     assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
 384   }
 385
 386   if (ASTMutationListener *L = getASTMutationListener())
 387     L->AddedCXXTemplateSpecialization(this, D);
 388 }
 389
 390 void ClassTemplateDecl::getPartialSpecializations(
 391           SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) {
 392   llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
 393     = getPartialSpecializations();
 394   PS.clear();
 395   PS.reserve(PartialSpecs.size());
 396   for (ClassTemplatePartialSpecializationDecl &P : PartialSpecs)
 397     PS.push_back(P.getMostRecentDecl());
 398 }
 399
 400 ClassTemplatePartialSpecializationDecl *
 401 ClassTemplateDecl::findPartialSpecialization(QualType T) {
 402   ASTContext &Context = getASTContext();
 403   for (ClassTemplatePartialSpecializationDecl &P :
 404        getPartialSpecializations()) {
 405     if (Context.hasSameType(P.getInjectedSpecializationType(), T))
 406       return P.getMostRecentDecl();
 407   }
 408
 409   return nullptr;
 410 }
 411
 412 ClassTemplatePartialSpecializationDecl *
 413 ClassTemplateDecl::findPartialSpecInstantiatedFromMember(
 414                                     ClassTemplatePartialSpecializationDecl *D) {
 415   Decl *DCanon = D->getCanonicalDecl();
 416   for (ClassTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
 417     if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
 418       return P.getMostRecentDecl();
 419   }
 420
 421   return nullptr;
 422 }
 423
 424 QualType
 425 ClassTemplateDecl::getInjectedClassNameSpecialization() {
 426   Common *CommonPtr = getCommonPtr();
 427   if (!CommonPtr->InjectedClassNameType.isNull())
 428     return CommonPtr->InjectedClassNameType;
 429
 430   // C++0x [temp.dep.type]p2:
 431   //  The template argument list of a primary template is a template argument
 432   //  list in which the nth template argument has the value of the nth template
 433   //  parameter of the class template. If the nth template parameter is a
 434   //  template parameter pack (14.5.3), the nth template argument is a pack
 435   //  expansion (14.5.3) whose pattern is the name of the template parameter
 436   //  pack.
 437   ASTContext &Context = getASTContext();
 438   TemplateParameterList *Params = getTemplateParameters();
 439   SmallVector<TemplateArgument, 16> TemplateArgs;
 440   Context.getInjectedTemplateArgs(Params, TemplateArgs);
 441   CommonPtr->InjectedClassNameType
 442     = Context.getTemplateSpecializationType(TemplateName(this),
 443                                             TemplateArgs);
 444   return CommonPtr->InjectedClassNameType;
 445 }
 446
 447 //===----------------------------------------------------------------------===//
 448 // TemplateTypeParm Allocation/Deallocation Method Implementations
 449 //===----------------------------------------------------------------------===//
 450
 451 TemplateTypeParmDecl *
 452 TemplateTypeParmDecl::Create(const ASTContext &C, DeclContext *DC,
 453                              SourceLocation KeyLoc, SourceLocation NameLoc,
 454                              unsigned D, unsigned P, IdentifierInfo *Id,
 455                              bool Typename, bool ParameterPack) {
 456   TemplateTypeParmDecl *TTPDecl =
 457     new (C, DC) TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename);
 458   QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
 459   TTPDecl->setTypeForDecl(TTPType.getTypePtr());
 460   return TTPDecl;
 461 }
 462
 463 TemplateTypeParmDecl *
 464 TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
 465   return new (C, ID) TemplateTypeParmDecl(nullptr, SourceLocation(),
 466                                           SourceLocation(), nullptr, false);
 467 }
 468
 469 SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
 470   return hasDefaultArgument()
 471              ? getDefaultArgumentInfo()->getTypeLoc().getBeginLoc()
 472              : SourceLocation();
 473 }
 474
 475 SourceRange TemplateTypeParmDecl::getSourceRange() const {
 476   if (hasDefaultArgument() && !defaultArgumentWasInherited())
 477     return SourceRange(getLocStart(),
 478                        getDefaultArgumentInfo()->getTypeLoc().getEndLoc());
 479   else
 480     return TypeDecl::getSourceRange();
 481 }
 482
 483 unsigned TemplateTypeParmDecl::getDepth() const {
 484   return getTypeForDecl()->getAs<TemplateTypeParmType>()->getDepth();
 485 }
 486
 487 unsigned TemplateTypeParmDecl::getIndex() const {
 488   return getTypeForDecl()->getAs<TemplateTypeParmType>()->getIndex();
 489 }
 490
 491 bool TemplateTypeParmDecl::isParameterPack() const {
 492   return getTypeForDecl()->getAs<TemplateTypeParmType>()->isParameterPack();
 493 }
 494
 495 //===----------------------------------------------------------------------===//
 496 // NonTypeTemplateParmDecl Method Implementations
 497 //===----------------------------------------------------------------------===//
 498
 499 NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(
 500     DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D,
 501     unsigned P, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
 502     ArrayRef<QualType> ExpandedTypes, ArrayRef<TypeSourceInfo *> ExpandedTInfos)
 503     : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
 504       TemplateParmPosition(D, P), ParameterPack(true),
 505       ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) {
 506   if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) {
 507     auto TypesAndInfos =
 508         getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
 509     for (unsigned I = 0; I != NumExpandedTypes; ++I) {
 510       new (&TypesAndInfos[I].first) QualType(ExpandedTypes[I]);
 511       TypesAndInfos[I].second = ExpandedTInfos[I];
 512     }
 513   }
 514 }
 515
 516 NonTypeTemplateParmDecl *
 517 NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
 518                                 SourceLocation StartLoc, SourceLocation IdLoc,
 519                                 unsigned D, unsigned P, IdentifierInfo *Id,
 520                                 QualType T, bool ParameterPack,
 521                                 TypeSourceInfo *TInfo) {
 522   return new (C, DC) NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id,
 523                                              T, ParameterPack, TInfo);
 524 }
 525
 526 NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
 527     const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
 528     SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
 529     QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
 530     ArrayRef<TypeSourceInfo *> ExpandedTInfos) {
 531   return new (C, DC,
 532               additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
 533                   ExpandedTypes.size()))
 534       NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo,
 535                               ExpandedTypes, ExpandedTInfos);
 536 }
 537
 538 NonTypeTemplateParmDecl *
 539 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
 540   return new (C, ID) NonTypeTemplateParmDecl(nullptr, SourceLocation(),
 541                                              SourceLocation(), 0, 0, nullptr,
 542                                              QualType(), false, nullptr);
 543 }
 544
 545 NonTypeTemplateParmDecl *
 546 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
 547                                             unsigned NumExpandedTypes) {
 548   auto *NTTP =
 549       new (C, ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
 550                       NumExpandedTypes))
 551           NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
 552                                   0, 0, nullptr, QualType(), nullptr, None,
 553                                   None);
 554   NTTP->NumExpandedTypes = NumExpandedTypes;
 555   return NTTP;
 556 }
 557
 558 SourceRange NonTypeTemplateParmDecl::getSourceRange() const {
 559   if (hasDefaultArgument() && !defaultArgumentWasInherited())
 560     return SourceRange(getOuterLocStart(),
 561                        getDefaultArgument()->getSourceRange().getEnd());
 562   return DeclaratorDecl::getSourceRange();
 563 }
 564
 565 SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
 566   return hasDefaultArgument()
 567     ? getDefaultArgument()->getSourceRange().getBegin()
 568     : SourceLocation();
 569 }
 570
 571 //===----------------------------------------------------------------------===//
 572 // TemplateTemplateParmDecl Method Implementations
 573 //===----------------------------------------------------------------------===//
 574
 575 void TemplateTemplateParmDecl::anchor() {}
 576
 577 TemplateTemplateParmDecl::TemplateTemplateParmDecl(
 578     DeclContext *DC, SourceLocation L, unsigned D, unsigned P,
 579     IdentifierInfo *Id, TemplateParameterList *Params,
 580     ArrayRef<TemplateParameterList *> Expansions)
 581     : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
 582       TemplateParmPosition(D, P), ParameterPack(true),
 583       ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) {
 584   if (!Expansions.empty())
 585     std::uninitialized_copy(Expansions.begin(), Expansions.end(),
 586                             getTrailingObjects<TemplateParameterList *>());
 587 }
 588
 589 TemplateTemplateParmDecl *
 590 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
 591                                  SourceLocation L, unsigned D, unsigned P,
 592                                  bool ParameterPack, IdentifierInfo *Id,
 593                                  TemplateParameterList *Params) {
 594   return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
 595                                               Params);
 596 }
 597
 598 TemplateTemplateParmDecl *
 599 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
 600                                  SourceLocation L, unsigned D, unsigned P,
 601                                  IdentifierInfo *Id,
 602                                  TemplateParameterList *Params,
 603                                  ArrayRef<TemplateParameterList *> Expansions) {
 604   return new (C, DC,
 605               additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
 606       TemplateTemplateParmDecl(DC, L, D, P, Id, Params, Expansions);
 607 }
 608
 609 TemplateTemplateParmDecl *
 610 TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
 611   return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0,
 612                                               false, nullptr, nullptr);
 613 }
 614
 615 TemplateTemplateParmDecl *
 616 TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
 617                                              unsigned NumExpansions) {
 618   auto *TTP =
 619       new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))
 620           TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr,
 621                                    nullptr, None);
 622   TTP->NumExpandedParams = NumExpansions;
 623   return TTP;
 624 }
 625
 626 SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const {
 627   return hasDefaultArgument() ? getDefaultArgument().getLocation()
 628                               : SourceLocation();
 629 }
 630
 631 void TemplateTemplateParmDecl::setDefaultArgument(
 632     const ASTContext &C, const TemplateArgumentLoc &DefArg) {
 633   if (DefArg.getArgument().isNull())
 634     DefaultArgument.set(nullptr);
 635   else
 636     DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg));
 637 }
 638
 639 //===----------------------------------------------------------------------===//
 640 // TemplateArgumentList Implementation
 641 //===----------------------------------------------------------------------===//
 642 TemplateArgumentList::TemplateArgumentList(ArrayRef<TemplateArgument> Args)
 643     : Arguments(getTrailingObjects<TemplateArgument>()),
 644       NumArguments(Args.size()) {
 645   std::uninitialized_copy(Args.begin(), Args.end(),
 646                           getTrailingObjects<TemplateArgument>());
 647 }
 648
 649 TemplateArgumentList *
 650 TemplateArgumentList::CreateCopy(ASTContext &Context,
 651                                  ArrayRef<TemplateArgument> Args) {
 652   void *Mem = Context.Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));
 653   return new (Mem) TemplateArgumentList(Args);
 654 }
 655
 656 FunctionTemplateSpecializationInfo *
 657 FunctionTemplateSpecializationInfo::Create(ASTContext &C, FunctionDecl *FD,
 658                                            FunctionTemplateDecl *Template,
 659                                            TemplateSpecializationKind TSK,
 660                                        const TemplateArgumentList *TemplateArgs,
 661                           const TemplateArgumentListInfo *TemplateArgsAsWritten,
 662                                            SourceLocation POI) {
 663   const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
 664   if (TemplateArgsAsWritten)
 665     ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C,
 666                                                         *TemplateArgsAsWritten);
 667
 668   return new (C) FunctionTemplateSpecializationInfo(FD, Template, TSK,
 669                                                     TemplateArgs,
 670                                                     ArgsAsWritten,
 671                                                     POI);
 672 }
 673
 674 //===----------------------------------------------------------------------===//
 675 // TemplateDecl Implementation
 676 //===----------------------------------------------------------------------===//
 677
 678 void TemplateDecl::anchor() {}
 679
 680 //===----------------------------------------------------------------------===//
 681 // ClassTemplateSpecializationDecl Implementation
 682 //===----------------------------------------------------------------------===//
 683
 684 ClassTemplateSpecializationDecl::
 685 ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
 686                                 DeclContext *DC, SourceLocation StartLoc,
 687                                 SourceLocation IdLoc,
 688                                 ClassTemplateDecl *SpecializedTemplate,
 689                                 ArrayRef<TemplateArgument> Args,
 690                                 ClassTemplateSpecializationDecl *PrevDecl)
 691     : CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc,
 692                     SpecializedTemplate->getIdentifier(), PrevDecl),
 693     SpecializedTemplate(SpecializedTemplate),
 694     TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
 695     SpecializationKind(TSK_Undeclared) {
 696 }
 697
 698 ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C,
 699                                                                  Kind DK)
 700     : CXXRecordDecl(DK, TTK_Struct, C, nullptr, SourceLocation(),
 701                     SourceLocation(), nullptr, nullptr),
 702       SpecializationKind(TSK_Undeclared) {}
 703
 704 ClassTemplateSpecializationDecl *
 705 ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
 706                                         DeclContext *DC,
 707                                         SourceLocation StartLoc,
 708                                         SourceLocation IdLoc,
 709                                         ClassTemplateDecl *SpecializedTemplate,
 710                                         ArrayRef<TemplateArgument> Args,
 711                                    ClassTemplateSpecializationDecl *PrevDecl) {
 712   ClassTemplateSpecializationDecl *Result =
 713       new (Context, DC) ClassTemplateSpecializationDecl(
 714           Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
 715           SpecializedTemplate, Args, PrevDecl);
 716   Result->MayHaveOutOfDateDef = false;
 717
 718   Context.getTypeDeclType(Result, PrevDecl);
 719   return Result;
 720 }
 721
 722 ClassTemplateSpecializationDecl *
 723 ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
 724                                                     unsigned ID) {
 725   ClassTemplateSpecializationDecl *Result =
 726     new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
 727   Result->MayHaveOutOfDateDef = false;
 728   return Result;
 729 }
 730
 731 void ClassTemplateSpecializationDecl::getNameForDiagnostic(
 732     raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
 733   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
 734
 735   auto *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(this);
 736   if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
 737           PS ? PS->getTemplateArgsAsWritten() : nullptr) {
 738     printTemplateArgumentList(OS, ArgsAsWritten->arguments(), Policy);
 739   } else {
 740     const TemplateArgumentList &TemplateArgs = getTemplateArgs();
 741     printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
 742   }
 743 }
 744
 745 ClassTemplateDecl *
 746 ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
 747   if (SpecializedPartialSpecialization *PartialSpec
 748       = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
 749     return PartialSpec->PartialSpecialization->getSpecializedTemplate();
 750   return SpecializedTemplate.get<ClassTemplateDecl*>();
 751 }
 752
 753 SourceRange
 754 ClassTemplateSpecializationDecl::getSourceRange() const {
 755   if (ExplicitInfo) {
 756     SourceLocation Begin = getTemplateKeywordLoc();
 757     if (Begin.isValid()) {
 758       // Here we have an explicit (partial) specialization or instantiation.
 759       assert(getSpecializationKind() == TSK_ExplicitSpecialization ||
 760              getSpecializationKind() == TSK_ExplicitInstantiationDeclaration ||
 761              getSpecializationKind() == TSK_ExplicitInstantiationDefinition);
 762       if (getExternLoc().isValid())
 763         Begin = getExternLoc();
 764       SourceLocation End = getBraceRange().getEnd();
 765       if (End.isInvalid())
 766         End = getTypeAsWritten()->getTypeLoc().getEndLoc();
 767       return SourceRange(Begin, End);
 768     }
 769     // An implicit instantiation of a class template partial specialization
 770     // uses ExplicitInfo to record the TypeAsWritten, but the source
 771     // locations should be retrieved from the instantiation pattern.
 772     using CTPSDecl = ClassTemplatePartialSpecializationDecl;
 773     CTPSDecl *ctpsd = const_cast<CTPSDecl*>(cast<CTPSDecl>(this));
 774     CTPSDecl *inst_from = ctpsd->getInstantiatedFromMember();
 775     assert(inst_from != nullptr);
 776     return inst_from->getSourceRange();
 777   }
 778   else {
 779     // No explicit info available.
 780     llvm::PointerUnion<ClassTemplateDecl *,
 781                        ClassTemplatePartialSpecializationDecl *>
 782       inst_from = getInstantiatedFrom();
 783     if (inst_from.isNull())
 784       return getSpecializedTemplate()->getSourceRange();
 785     if (ClassTemplateDecl *ctd = inst_from.dyn_cast<ClassTemplateDecl*>())
 786       return ctd->getSourceRange();
 787     return inst_from.get<ClassTemplatePartialSpecializationDecl*>()
 788       ->getSourceRange();
 789   }
 790 }
 791
 792 //===----------------------------------------------------------------------===//
 793 // ClassTemplatePartialSpecializationDecl Implementation
 794 //===----------------------------------------------------------------------===//
 795 void ClassTemplatePartialSpecializationDecl::anchor() {}
 796
 797 ClassTemplatePartialSpecializationDecl::
 798 ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
 799                                        DeclContext *DC,
 800                                        SourceLocation StartLoc,
 801                                        SourceLocation IdLoc,
 802                                        TemplateParameterList *Params,
 803                                        ClassTemplateDecl *SpecializedTemplate,
 804                                        ArrayRef<TemplateArgument> Args,
 805                                const ASTTemplateArgumentListInfo *ArgInfos,
 806                                ClassTemplatePartialSpecializationDecl *PrevDecl)
 807     : ClassTemplateSpecializationDecl(Context,
 808                                       ClassTemplatePartialSpecialization,
 809                                       TK, DC, StartLoc, IdLoc,
 810                                       SpecializedTemplate, Args, PrevDecl),
 811       TemplateParams(Params), ArgsAsWritten(ArgInfos),
 812       InstantiatedFromMember(nullptr, false) {
 813   AdoptTemplateParameterList(Params, this);
 814 }
 815
 816 ClassTemplatePartialSpecializationDecl *
 817 ClassTemplatePartialSpecializationDecl::
 818 Create(ASTContext &Context, TagKind TK,DeclContext *DC,
 819        SourceLocation StartLoc, SourceLocation IdLoc,
 820        TemplateParameterList *Params,
 821        ClassTemplateDecl *SpecializedTemplate,
 822        ArrayRef<TemplateArgument> Args,
 823        const TemplateArgumentListInfo &ArgInfos,
 824        QualType CanonInjectedType,
 825        ClassTemplatePartialSpecializationDecl *PrevDecl) {
 826   const ASTTemplateArgumentListInfo *ASTArgInfos =
 827     ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
 828
 829   ClassTemplatePartialSpecializationDecl *Result = new (Context, DC)
 830       ClassTemplatePartialSpecializationDecl(Context, TK, DC, StartLoc, IdLoc,
 831                                              Params, SpecializedTemplate, Args,
 832                                              ASTArgInfos, PrevDecl);
 833   Result->setSpecializationKind(TSK_ExplicitSpecialization);
 834   Result->MayHaveOutOfDateDef = false;
 835
 836   Context.getInjectedClassNameType(Result, CanonInjectedType);
 837   return Result;
 838 }
 839
 840 ClassTemplatePartialSpecializationDecl *
 841 ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
 842                                                            unsigned ID) {
 843   ClassTemplatePartialSpecializationDecl *Result =
 844       new (C, ID) ClassTemplatePartialSpecializationDecl(C);
 845   Result->MayHaveOutOfDateDef = false;
 846   return Result;
 847 }
 848
 849 //===----------------------------------------------------------------------===//
 850 // FriendTemplateDecl Implementation
 851 //===----------------------------------------------------------------------===//
 852
 853 void FriendTemplateDecl::anchor() {}
 854
 855 FriendTemplateDecl *
 856 FriendTemplateDecl::Create(ASTContext &Context, DeclContext *DC,
 857                            SourceLocation L,
 858                            MutableArrayRef<TemplateParameterList *> Params,
 859                            FriendUnion Friend, SourceLocation FLoc) {
 860   return new (Context, DC) FriendTemplateDecl(DC, L, Params, Friend, FLoc);
 861 }
 862
 863 FriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C,
 864                                                            unsigned ID) {
 865   return new (C, ID) FriendTemplateDecl(EmptyShell());
 866 }
 867
 868 //===----------------------------------------------------------------------===//
 869 // TypeAliasTemplateDecl Implementation
 870 //===----------------------------------------------------------------------===//
 871
 872 TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C,
 873                                                      DeclContext *DC,
 874                                                      SourceLocation L,
 875                                                      DeclarationName Name,
 876                                                   TemplateParameterList *Params,
 877                                                      NamedDecl *Decl) {
 878   AdoptTemplateParameterList(Params, DC);
 879   return new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl);
 880 }
 881
 882 TypeAliasTemplateDecl *TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C,
 883                                                                  unsigned ID) {
 884   return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(),
 885                                            DeclarationName(), nullptr, nullptr);
 886 }
 887
 888 RedeclarableTemplateDecl::CommonBase *
 889 TypeAliasTemplateDecl::newCommon(ASTContext &C) const {
 890   Common *CommonPtr = new (C) Common;
 891   C.addDestruction(CommonPtr);
 892   return CommonPtr;
 893 }
 894
 895 //===----------------------------------------------------------------------===//
 896 // ClassScopeFunctionSpecializationDecl Implementation
 897 //===----------------------------------------------------------------------===//
 898
 899 void ClassScopeFunctionSpecializationDecl::anchor() {}
 900
 901 ClassScopeFunctionSpecializationDecl *
 902 ClassScopeFunctionSpecializationDecl::CreateDeserialized(ASTContext &C,
 903                                                          unsigned ID) {
 904   return new (C, ID) ClassScopeFunctionSpecializationDecl(
 905       nullptr, SourceLocation(), nullptr, false, TemplateArgumentListInfo());
 906 }
 907
 908 //===----------------------------------------------------------------------===//
 909 // VarTemplateDecl Implementation
 910 //===----------------------------------------------------------------------===//
 911
 912 VarTemplateDecl *VarTemplateDecl::getDefinition() {
 913   VarTemplateDecl *CurD = this;
 914   while (CurD) {
 915     if (CurD->isThisDeclarationADefinition())
 916       return CurD;
 917     CurD = CurD->getPreviousDecl();
 918   }
 919   return nullptr;
 920 }
 921
 922 VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C, DeclContext *DC,
 923                                          SourceLocation L, DeclarationName Name,
 924                                          TemplateParameterList *Params,
 925                                          VarDecl *Decl) {
 926   return new (C, DC) VarTemplateDecl(C, DC, L, Name, Params, Decl);
 927 }
 928
 929 VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C,
 930                                                      unsigned ID) {
 931   return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(),
 932                                      DeclarationName(), nullptr, nullptr);
 933 }
 934
 935 void VarTemplateDecl::LoadLazySpecializations() const {
 936   loadLazySpecializationsImpl();
 937 }
 938
 939 llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
 940 VarTemplateDecl::getSpecializations() const {
 941   LoadLazySpecializations();
 942   return getCommonPtr()->Specializations;
 943 }
 944
 945 llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
 946 VarTemplateDecl::getPartialSpecializations() {
 947   LoadLazySpecializations();
 948   return getCommonPtr()->PartialSpecializations;
 949 }
 950
 951 RedeclarableTemplateDecl::CommonBase *
 952 VarTemplateDecl::newCommon(ASTContext &C) const {
 953   Common *CommonPtr = new (C) Common;
 954   C.addDestruction(CommonPtr);
 955   return CommonPtr;
 956 }
 957
 958 VarTemplateSpecializationDecl *
 959 VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
 960                                     void *&InsertPos) {
 961   return findSpecializationImpl(getSpecializations(), Args, InsertPos);
 962 }
 963
 964 void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D,
 965                                         void *InsertPos) {
 966   addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
 967 }
 968
 969 VarTemplatePartialSpecializationDecl *
 970 VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
 971                                            void *&InsertPos) {
 972   return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
 973 }
 974
 975 void VarTemplateDecl::AddPartialSpecialization(
 976     VarTemplatePartialSpecializationDecl *D, void *InsertPos) {
 977   if (InsertPos)
 978     getPartialSpecializations().InsertNode(D, InsertPos);
 979   else {
 980     VarTemplatePartialSpecializationDecl *Existing =
 981         getPartialSpecializations().GetOrInsertNode(D);
 982     (void)Existing;
 983     assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
 984   }
 985
 986   if (ASTMutationListener *L = getASTMutationListener())
 987     L->AddedCXXTemplateSpecialization(this, D);
 988 }
 989
 990 void VarTemplateDecl::getPartialSpecializations(
 991     SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS) {
 992   llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &PartialSpecs =
 993       getPartialSpecializations();
 994   PS.clear();
 995   PS.reserve(PartialSpecs.size());
 996   for (VarTemplatePartialSpecializationDecl &P : PartialSpecs)
 997     PS.push_back(P.getMostRecentDecl());
 998 }
 999
1000 VarTemplatePartialSpecializationDecl *
1001 VarTemplateDecl::findPartialSpecInstantiatedFromMember(
1002     VarTemplatePartialSpecializationDecl *D) {
1003   Decl *DCanon = D->getCanonicalDecl();
1004   for (VarTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
1005     if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
1006       return P.getMostRecentDecl();
1007   }
1008
1009   return nullptr;
1010 }
1011
1012 //===----------------------------------------------------------------------===//
1013 // VarTemplateSpecializationDecl Implementation
1014 //===----------------------------------------------------------------------===//
1015
1016 VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(
1017     Kind DK, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1018     SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1019     TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args)
1020     : VarDecl(DK, Context, DC, StartLoc, IdLoc,
1021               SpecializedTemplate->getIdentifier(), T, TInfo, S),
1022       SpecializedTemplate(SpecializedTemplate),
1023       TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
1024       SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
1025
1026 VarTemplateSpecializationDecl::VarTemplateSpecializationDecl(Kind DK,
1027                                                              ASTContext &C)
1028     : VarDecl(DK, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
1029               QualType(), nullptr, SC_None),
1030       SpecializationKind(TSK_Undeclared), IsCompleteDefinition(false) {}
1031
1032 VarTemplateSpecializationDecl *VarTemplateSpecializationDecl::Create(
1033     ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1034     SourceLocation IdLoc, VarTemplateDecl *SpecializedTemplate, QualType T,
1035     TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args) {
1036   return new (Context, DC) VarTemplateSpecializationDecl(
1037       VarTemplateSpecialization, Context, DC, StartLoc, IdLoc,
1038       SpecializedTemplate, T, TInfo, S, Args);
1039 }
1040
1041 VarTemplateSpecializationDecl *
1042 VarTemplateSpecializationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1043   return new (C, ID)
1044       VarTemplateSpecializationDecl(VarTemplateSpecialization, C);
1045 }
1046
1047 void VarTemplateSpecializationDecl::getNameForDiagnostic(
1048     raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
1049   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
1050
1051   auto *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(this);
1052   if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
1053           PS ? PS->getTemplateArgsAsWritten() : nullptr) {
1054     printTemplateArgumentList(OS, ArgsAsWritten->arguments(), Policy);
1055   } else {
1056     const TemplateArgumentList &TemplateArgs = getTemplateArgs();
1057     printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
1058   }
1059 }
1060
1061 VarTemplateDecl *VarTemplateSpecializationDecl::getSpecializedTemplate() const {
1062   if (SpecializedPartialSpecialization *PartialSpec =
1063           SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
1064     return PartialSpec->PartialSpecialization->getSpecializedTemplate();
1065   return SpecializedTemplate.get<VarTemplateDecl *>();
1066 }
1067
1068 void VarTemplateSpecializationDecl::setTemplateArgsInfo(
1069     const TemplateArgumentListInfo &ArgsInfo) {
1070   TemplateArgsInfo.setLAngleLoc(ArgsInfo.getLAngleLoc());
1071   TemplateArgsInfo.setRAngleLoc(ArgsInfo.getRAngleLoc());
1072   for (const TemplateArgumentLoc &Loc : ArgsInfo.arguments())
1073     TemplateArgsInfo.addArgument(Loc);
1074 }
1075
1076 //===----------------------------------------------------------------------===//
1077 // VarTemplatePartialSpecializationDecl Implementation
1078 //===----------------------------------------------------------------------===//
1079
1080 void VarTemplatePartialSpecializationDecl::anchor() {}
1081
1082 VarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl(
1083     ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1084     SourceLocation IdLoc, TemplateParameterList *Params,
1085     VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1086     StorageClass S, ArrayRef<TemplateArgument> Args,
1087     const ASTTemplateArgumentListInfo *ArgInfos)
1088     : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context,
1089                                     DC, StartLoc, IdLoc, SpecializedTemplate, T,
1090                                     TInfo, S, Args),
1091       TemplateParams(Params), ArgsAsWritten(ArgInfos),
1092       InstantiatedFromMember(nullptr, false) {
1093   // TODO: The template parameters should be in DC by now. Verify.
1094   // AdoptTemplateParameterList(Params, DC);
1095 }
1096
1097 VarTemplatePartialSpecializationDecl *
1098 VarTemplatePartialSpecializationDecl::Create(
1099     ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
1100     SourceLocation IdLoc, TemplateParameterList *Params,
1101     VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
1102     StorageClass S, ArrayRef<TemplateArgument> Args,
1103     const TemplateArgumentListInfo &ArgInfos) {
1104   const ASTTemplateArgumentListInfo *ASTArgInfos
1105     = ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
1106
1107   VarTemplatePartialSpecializationDecl *Result =
1108       new (Context, DC) VarTemplatePartialSpecializationDecl(
1109           Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo,
1110           S, Args, ASTArgInfos);
1111   Result->setSpecializationKind(TSK_ExplicitSpecialization);
1112   return Result;
1113 }
1114
1115 VarTemplatePartialSpecializationDecl *
1116 VarTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
1117                                                          unsigned ID) {
1118   return new (C, ID) VarTemplatePartialSpecializationDecl(C);
1119 }
1120
1121 static TemplateParameterList *
1122 createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC) {
1123   // typename T
1124   auto *T = TemplateTypeParmDecl::Create(
1125       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,
1126       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false);
1127   T->setImplicit(true);
1128
1129   // T ...Ints
1130   TypeSourceInfo *TI =
1131       C.getTrivialTypeSourceInfo(QualType(T->getTypeForDecl(), 0));
1132   auto *N = NonTypeTemplateParmDecl::Create(
1133       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1134       /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true, TI);
1135   N->setImplicit(true);
1136
1137   // <typename T, T ...Ints>
1138   NamedDecl *P[2] = {T, N};
1139   auto *TPL = TemplateParameterList::Create(
1140       C, SourceLocation(), SourceLocation(), P, SourceLocation(), nullptr);
1141
1142   // template <typename T, ...Ints> class IntSeq
1143   auto *TemplateTemplateParm = TemplateTemplateParmDecl::Create(
1144       C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/0,
1145       /*ParameterPack=*/false, /*Id=*/nullptr, TPL);
1146   TemplateTemplateParm->setImplicit(true);
1147
1148   // typename T
1149   auto *TemplateTypeParm = TemplateTypeParmDecl::Create(
1150       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1151       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/false);
1152   TemplateTypeParm->setImplicit(true);
1153
1154   // T N
1155   TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(
1156       QualType(TemplateTypeParm->getTypeForDecl(), 0));
1157   auto *NonTypeTemplateParm = NonTypeTemplateParmDecl::Create(
1158       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/2,
1159       /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1160   NamedDecl *Params[] = {TemplateTemplateParm, TemplateTypeParm,
1161                          NonTypeTemplateParm};
1162
1163   // template <template <typename T, T ...Ints> class IntSeq, typename T, T N>
1164   return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
1165                                        Params, SourceLocation(), nullptr);
1166 }
1167
1168 static TemplateParameterList *
1169 createTypePackElementParameterList(const ASTContext &C, DeclContext *DC) {
1170   // std::size_t Index
1171   TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(C.getSizeType());
1172   auto *Index = NonTypeTemplateParmDecl::Create(
1173       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
1174       /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
1175
1176   // typename ...T
1177   auto *Ts = TemplateTypeParmDecl::Create(
1178       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
1179       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/true);
1180   Ts->setImplicit(true);
1181
1182   // template <std::size_t Index, typename ...T>
1183   NamedDecl *Params[] = {Index, Ts};
1184   return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
1185                                        llvm::makeArrayRef(Params),
1186                                        SourceLocation(), nullptr);
1187 }
1188
1189 static TemplateParameterList *createBuiltinTemplateParameterList(
1190     const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) {
1191   switch (BTK) {
1192   case BTK__make_integer_seq:
1193     return createMakeIntegerSeqParameterList(C, DC);
1194   case BTK__type_pack_element:
1195     return createTypePackElementParameterList(C, DC);
1196   }
1197
1198   llvm_unreachable("unhandled BuiltinTemplateKind!");
1199 }
1200
1201 void BuiltinTemplateDecl::anchor() {}
1202
1203 BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
1204                                          DeclarationName Name,
1205                                          BuiltinTemplateKind BTK)
1206     : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name,
1207                    createBuiltinTemplateParameterList(C, DC, BTK)),
1208       BTK(BTK) {}