lib/AST/DeclTemplate.cpp

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