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

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