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