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 //===----------------------------------------------------------------------===//
 128 // RedeclarableTemplateDecl Implementation
 129 //===----------------------------------------------------------------------===//
 130
 131 RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() const {
 132   if (!Common) {
 133     // Walk the previous-declaration chain until we either find a declaration
 134     // with a common pointer or we run out of previous declarations.
 135     SmallVector<const RedeclarableTemplateDecl *, 2> PrevDecls;
 136     for (const RedeclarableTemplateDecl *Prev = getPreviousDecl(); Prev;
 137          Prev = Prev->getPreviousDecl()) {
 138       if (Prev->Common) {
 139         Common = Prev->Common;
 140         break;
 141       }
 142
 143       PrevDecls.push_back(Prev);
 144     }
 145
 146     // If we never found a common pointer, allocate one now.
 147     if (!Common) {
 148       // FIXME: If any of the declarations is from an AST file, we probably
 149       // need an update record to add the common data.
 150
 151       Common = newCommon(getASTContext());
 152     }
 153
 154     // Update any previous declarations we saw with the common pointer.
 155     for (unsigned I = 0, N = PrevDecls.size(); I != N; ++I)
 156       PrevDecls[I]->Common = Common;
 157   }
 158
 159   return Common;
 160 }
 161
 162 template <class EntryType>
 163 typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType*
 164 RedeclarableTemplateDecl::findSpecializationImpl(
 165                                  llvm::FoldingSetVector<EntryType> &Specs,
 166                                  const TemplateArgument *Args, unsigned NumArgs,
 167                                  void *&InsertPos) {
 168   typedef SpecEntryTraits<EntryType> SETraits;
 169   llvm::FoldingSetNodeID ID;
 170   EntryType::Profile(ID,Args,NumArgs, getASTContext());
 171   EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos);
 172   return Entry ? SETraits::getMostRecentDecl(Entry) : 0;
 173 }
 174
 175 /// \brief Generate the injected template arguments for the given template
 176 /// parameter list, e.g., for the injected-class-name of a class template.
 177 static void GenerateInjectedTemplateArgs(ASTContext &Context,
 178                                         TemplateParameterList *Params,
 179                                          TemplateArgument *Args) {
 180   for (TemplateParameterList::iterator Param = Params->begin(),
 181                                     ParamEnd = Params->end();
 182        Param != ParamEnd; ++Param) {
 183     TemplateArgument Arg;
 184     if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
 185       QualType ArgType = Context.getTypeDeclType(TTP);
 186       if (TTP->isParameterPack())
 187         ArgType = Context.getPackExpansionType(ArgType, None);
 188
 189       Arg = TemplateArgument(ArgType);
 190     } else if (NonTypeTemplateParmDecl *NTTP =
 191                dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
 192       Expr *E = new (Context) DeclRefExpr(NTTP, /*enclosing*/ false,
 193                                   NTTP->getType().getNonLValueExprType(Context),
 194                                   Expr::getValueKindForType(NTTP->getType()),
 195                                           NTTP->getLocation());
 196
 197       if (NTTP->isParameterPack())
 198         E = new (Context) PackExpansionExpr(Context.DependentTy, E,
 199                                             NTTP->getLocation(), None);
 200       Arg = TemplateArgument(E);
 201     } else {
 202       TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param);
 203       if (TTP->isParameterPack())
 204         Arg = TemplateArgument(TemplateName(TTP), Optional<unsigned>());
 205       else
 206         Arg = TemplateArgument(TemplateName(TTP));
 207     }
 208
 209     if ((*Param)->isTemplateParameterPack())
 210       Arg = TemplateArgument::CreatePackCopy(Context, &Arg, 1);
 211
 212     *Args++ = Arg;
 213   }
 214 }
 215
 216 //===----------------------------------------------------------------------===//
 217 // FunctionTemplateDecl Implementation
 218 //===----------------------------------------------------------------------===//
 219
 220 void FunctionTemplateDecl::DeallocateCommon(void *Ptr) {
 221   static_cast<Common *>(Ptr)->~Common();
 222 }
 223
 224 FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
 225                                                    DeclContext *DC,
 226                                                    SourceLocation L,
 227                                                    DeclarationName Name,
 228                                                TemplateParameterList *Params,
 229                                                    NamedDecl *Decl) {
 230   AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
 231   return new (C) FunctionTemplateDecl(DC, L, Name, Params, Decl);
 232 }
 233
 234 FunctionTemplateDecl *FunctionTemplateDecl::CreateDeserialized(ASTContext &C,
 235                                                                unsigned ID) {
 236   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FunctionTemplateDecl));
 237   return new (Mem) FunctionTemplateDecl(0, SourceLocation(), DeclarationName(),
 238                                         0, 0);
 239 }
 240
 241 RedeclarableTemplateDecl::CommonBase *
 242 FunctionTemplateDecl::newCommon(ASTContext &C) const {
 243   Common *CommonPtr = new (C) Common;
 244   C.AddDeallocation(DeallocateCommon, CommonPtr);
 245   return CommonPtr;
 246 }
 247
 248 FunctionDecl *
 249 FunctionTemplateDecl::findSpecialization(const TemplateArgument *Args,
 250                                          unsigned NumArgs, void *&InsertPos) {
 251   return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos);
 252 }
 253
 254 void FunctionTemplateDecl::addSpecialization(
 255       FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
 256   if (InsertPos)
 257     getSpecializations().InsertNode(Info, InsertPos);
 258   else
 259     getSpecializations().GetOrInsertNode(Info);
 260   if (ASTMutationListener *L = getASTMutationListener())
 261     L->AddedCXXTemplateSpecialization(this, Info->Function);
 262 }
 263
 264 std::pair<const TemplateArgument *, unsigned>
 265 FunctionTemplateDecl::getInjectedTemplateArgs() {
 266   TemplateParameterList *Params = getTemplateParameters();
 267   Common *CommonPtr = getCommonPtr();
 268   if (!CommonPtr->InjectedArgs) {
 269     CommonPtr->InjectedArgs
 270       = new (getASTContext()) TemplateArgument [Params->size()];
 271     GenerateInjectedTemplateArgs(getASTContext(), Params,
 272                                  CommonPtr->InjectedArgs);
 273   }
 274
 275   return std::make_pair(CommonPtr->InjectedArgs, Params->size());
 276 }
 277
 278 //===----------------------------------------------------------------------===//
 279 // ClassTemplateDecl Implementation
 280 //===----------------------------------------------------------------------===//
 281
 282 void ClassTemplateDecl::DeallocateCommon(void *Ptr) {
 283   static_cast<Common *>(Ptr)->~Common();
 284 }
 285
 286 ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
 287                                              DeclContext *DC,
 288                                              SourceLocation L,
 289                                              DeclarationName Name,
 290                                              TemplateParameterList *Params,
 291                                              NamedDecl *Decl,
 292                                              ClassTemplateDecl *PrevDecl) {
 293   AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
 294   ClassTemplateDecl *New = new (C) ClassTemplateDecl(DC, L, Name, Params, Decl);
 295   New->setPreviousDeclaration(PrevDecl);
 296   return New;
 297 }
 298
 299 ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C,
 300                                                          unsigned ID) {
 301   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ClassTemplateDecl));
 302   return new (Mem) ClassTemplateDecl(EmptyShell());
 303 }
 304
 305 void ClassTemplateDecl::LoadLazySpecializations() const {
 306   Common *CommonPtr = getCommonPtr();
 307   if (CommonPtr->LazySpecializations) {
 308     ASTContext &Context = getASTContext();
 309     uint32_t *Specs = CommonPtr->LazySpecializations;
 310     CommonPtr->LazySpecializations = 0;
 311     for (uint32_t I = 0, N = *Specs++; I != N; ++I)
 312       (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
 313   }
 314 }
 315
 316 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
 317 ClassTemplateDecl::getSpecializations() const {
 318   LoadLazySpecializations();
 319   return getCommonPtr()->Specializations;
 320 }
 321
 322 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
 323 ClassTemplateDecl::getPartialSpecializations() {
 324   LoadLazySpecializations();
 325   return getCommonPtr()->PartialSpecializations;
 326 }
 327
 328 RedeclarableTemplateDecl::CommonBase *
 329 ClassTemplateDecl::newCommon(ASTContext &C) const {
 330   Common *CommonPtr = new (C) Common;
 331   C.AddDeallocation(DeallocateCommon, CommonPtr);
 332   return CommonPtr;
 333 }
 334
 335 ClassTemplateSpecializationDecl *
 336 ClassTemplateDecl::findSpecialization(const TemplateArgument *Args,
 337                                       unsigned NumArgs, void *&InsertPos) {
 338   return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos);
 339 }
 340
 341 void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
 342                                           void *InsertPos) {
 343   if (InsertPos)
 344     getSpecializations().InsertNode(D, InsertPos);
 345   else {
 346     ClassTemplateSpecializationDecl *Existing
 347       = getSpecializations().GetOrInsertNode(D);
 348     (void)Existing;
 349     assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
 350   }
 351   if (ASTMutationListener *L = getASTMutationListener())
 352     L->AddedCXXTemplateSpecialization(this, D);
 353 }
 354
 355 ClassTemplatePartialSpecializationDecl *
 356 ClassTemplateDecl::findPartialSpecialization(const TemplateArgument *Args,
 357                                              unsigned NumArgs,
 358                                              void *&InsertPos) {
 359   return findSpecializationImpl(getPartialSpecializations(), Args, NumArgs,
 360                                 InsertPos);
 361 }
 362
 363 void ClassTemplateDecl::AddPartialSpecialization(
 364                                       ClassTemplatePartialSpecializationDecl *D,
 365                                       void *InsertPos) {
 366   if (InsertPos)
 367     getPartialSpecializations().InsertNode(D, InsertPos);
 368   else {
 369     ClassTemplatePartialSpecializationDecl *Existing
 370       = getPartialSpecializations().GetOrInsertNode(D);
 371     (void)Existing;
 372     assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
 373   }
 374
 375   if (ASTMutationListener *L = getASTMutationListener())
 376     L->AddedCXXTemplateSpecialization(this, D);
 377 }
 378
 379 void ClassTemplateDecl::getPartialSpecializations(
 380           SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) {
 381   llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
 382     = getPartialSpecializations();
 383   PS.clear();
 384   PS.resize(PartialSpecs.size());
 385   for (llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>::iterator
 386        P = PartialSpecs.begin(), PEnd = PartialSpecs.end();
 387        P != PEnd; ++P) {
 388     assert(!PS[P->getSequenceNumber()]);
 389     PS[P->getSequenceNumber()] = P->getMostRecentDecl();
 390   }
 391 }
 392
 393 ClassTemplatePartialSpecializationDecl *
 394 ClassTemplateDecl::findPartialSpecialization(QualType T) {
 395   ASTContext &Context = getASTContext();
 396   using llvm::FoldingSetVector;
 397   typedef FoldingSetVector<ClassTemplatePartialSpecializationDecl>::iterator
 398     partial_spec_iterator;
 399   for (partial_spec_iterator P = getPartialSpecializations().begin(),
 400                           PEnd = getPartialSpecializations().end();
 401        P != PEnd; ++P) {
 402     if (Context.hasSameType(P->getInjectedSpecializationType(), T))
 403       return P->getMostRecentDecl();
 404   }
 405
 406   return 0;
 407 }
 408
 409 ClassTemplatePartialSpecializationDecl *
 410 ClassTemplateDecl::findPartialSpecInstantiatedFromMember(
 411                                     ClassTemplatePartialSpecializationDecl *D) {
 412   Decl *DCanon = D->getCanonicalDecl();
 413   for (llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>::iterator
 414             P = getPartialSpecializations().begin(),
 415          PEnd = getPartialSpecializations().end();
 416        P != PEnd; ++P) {
 417     if (P->getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
 418       return P->getMostRecentDecl();
 419   }
 420
 421   return 0;
 422 }
 423
 424 QualType
 425 ClassTemplateDecl::getInjectedClassNameSpecialization() {
 426   Common *CommonPtr = getCommonPtr();
 427   if (!CommonPtr->InjectedClassNameType.isNull())
 428     return CommonPtr->InjectedClassNameType;
 429
 430   // C++0x [temp.dep.type]p2:
 431   //  The template argument list of a primary template is a template argument
 432   //  list in which the nth template argument has the value of the nth template
 433   //  parameter of the class template. If the nth template parameter is a
 434   //  template parameter pack (14.5.3), the nth template argument is a pack
 435   //  expansion (14.5.3) whose pattern is the name of the template parameter
 436   //  pack.
 437   ASTContext &Context = getASTContext();
 438   TemplateParameterList *Params = getTemplateParameters();
 439   SmallVector<TemplateArgument, 16> TemplateArgs;
 440   TemplateArgs.resize(Params->size());
 441   GenerateInjectedTemplateArgs(getASTContext(), Params, TemplateArgs.data());
 442   CommonPtr->InjectedClassNameType
 443     = Context.getTemplateSpecializationType(TemplateName(this),
 444                                             &TemplateArgs[0],
 445                                             TemplateArgs.size());
 446   return CommonPtr->InjectedClassNameType;
 447 }
 448
 449 //===----------------------------------------------------------------------===//
 450 // TemplateTypeParm Allocation/Deallocation Method Implementations
 451 //===----------------------------------------------------------------------===//
 452
 453 TemplateTypeParmDecl *
 454 TemplateTypeParmDecl::Create(const ASTContext &C, DeclContext *DC,
 455                              SourceLocation KeyLoc, SourceLocation NameLoc,
 456                              unsigned D, unsigned P, IdentifierInfo *Id,
 457                              bool Typename, bool ParameterPack) {
 458   TemplateTypeParmDecl *TTPDecl =
 459     new (C) TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename);
 460   QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
 461   TTPDecl->TypeForDecl = TTPType.getTypePtr();
 462   return TTPDecl;
 463 }
 464
 465 TemplateTypeParmDecl *
 466 TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
 467   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(TemplateTypeParmDecl));
 468   return new (Mem) TemplateTypeParmDecl(0, SourceLocation(), SourceLocation(),
 469                                         0, false);
 470 }
 471
 472 SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
 473   return hasDefaultArgument()
 474     ? DefaultArgument->getTypeLoc().getBeginLoc()
 475     : SourceLocation();
 476 }
 477
 478 SourceRange TemplateTypeParmDecl::getSourceRange() const {
 479   if (hasDefaultArgument() && !defaultArgumentWasInherited())
 480     return SourceRange(getLocStart(),
 481                        DefaultArgument->getTypeLoc().getEndLoc());
 482   else
 483     return TypeDecl::getSourceRange();
 484 }
 485
 486 unsigned TemplateTypeParmDecl::getDepth() const {
 487   return TypeForDecl->getAs<TemplateTypeParmType>()->getDepth();
 488 }
 489
 490 unsigned TemplateTypeParmDecl::getIndex() const {
 491   return TypeForDecl->getAs<TemplateTypeParmType>()->getIndex();
 492 }
 493
 494 bool TemplateTypeParmDecl::isParameterPack() const {
 495   return TypeForDecl->getAs<TemplateTypeParmType>()->isParameterPack();
 496 }
 497
 498 //===----------------------------------------------------------------------===//
 499 // NonTypeTemplateParmDecl Method Implementations
 500 //===----------------------------------------------------------------------===//
 501
 502 NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(DeclContext *DC,
 503                                                  SourceLocation StartLoc,
 504                                                  SourceLocation IdLoc,
 505                                                  unsigned D, unsigned P,
 506                                                  IdentifierInfo *Id,
 507                                                  QualType T,
 508                                                  TypeSourceInfo *TInfo,
 509                                                  const QualType *ExpandedTypes,
 510                                                  unsigned NumExpandedTypes,
 511                                                 TypeSourceInfo **ExpandedTInfos)
 512   : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
 513     TemplateParmPosition(D, P), DefaultArgumentAndInherited(0, false),
 514     ParameterPack(true), ExpandedParameterPack(true),
 515     NumExpandedTypes(NumExpandedTypes)
 516 {
 517   if (ExpandedTypes && ExpandedTInfos) {
 518     void **TypesAndInfos = reinterpret_cast<void **>(this + 1);
 519     for (unsigned I = 0; I != NumExpandedTypes; ++I) {
 520       TypesAndInfos[2*I] = ExpandedTypes[I].getAsOpaquePtr();
 521       TypesAndInfos[2*I + 1] = ExpandedTInfos[I];
 522     }
 523   }
 524 }
 525
 526 NonTypeTemplateParmDecl *
 527 NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
 528                                 SourceLocation StartLoc, SourceLocation IdLoc,
 529                                 unsigned D, unsigned P, IdentifierInfo *Id,
 530                                 QualType T, bool ParameterPack,
 531                                 TypeSourceInfo *TInfo) {
 532   return new (C) NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id,
 533                                          T, ParameterPack, TInfo);
 534 }
 535
 536 NonTypeTemplateParmDecl *
 537 NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
 538                                 SourceLocation StartLoc, SourceLocation IdLoc,
 539                                 unsigned D, unsigned P,
 540                                 IdentifierInfo *Id, QualType T,
 541                                 TypeSourceInfo *TInfo,
 542                                 const QualType *ExpandedTypes,
 543                                 unsigned NumExpandedTypes,
 544                                 TypeSourceInfo **ExpandedTInfos) {
 545   unsigned Size = sizeof(NonTypeTemplateParmDecl)
 546                 + NumExpandedTypes * 2 * sizeof(void*);
 547   void *Mem = C.Allocate(Size);
 548   return new (Mem) NonTypeTemplateParmDecl(DC, StartLoc, IdLoc,
 549                                            D, P, Id, T, TInfo,
 550                                            ExpandedTypes, NumExpandedTypes,
 551                                            ExpandedTInfos);
 552 }
 553
 554 NonTypeTemplateParmDecl *
 555 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
 556   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(NonTypeTemplateParmDecl));
 557   return new (Mem) NonTypeTemplateParmDecl(0, SourceLocation(),
 558                                            SourceLocation(), 0, 0, 0,
 559                                            QualType(), false, 0);
 560 }
 561
 562 NonTypeTemplateParmDecl *
 563 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
 564                                             unsigned NumExpandedTypes) {
 565   unsigned Size = sizeof(NonTypeTemplateParmDecl)
 566                 + NumExpandedTypes * 2 * sizeof(void*);
 567
 568   void *Mem = AllocateDeserializedDecl(C, ID, Size);
 569   return new (Mem) NonTypeTemplateParmDecl(0, SourceLocation(),
 570                                            SourceLocation(), 0, 0, 0,
 571                                            QualType(), 0, 0, NumExpandedTypes,
 572                                            0);
 573 }
 574
 575 SourceRange NonTypeTemplateParmDecl::getSourceRange() const {
 576   if (hasDefaultArgument() && !defaultArgumentWasInherited())
 577     return SourceRange(getOuterLocStart(),
 578                        getDefaultArgument()->getSourceRange().getEnd());
 579   return DeclaratorDecl::getSourceRange();
 580 }
 581
 582 SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
 583   return hasDefaultArgument()
 584     ? getDefaultArgument()->getSourceRange().getBegin()
 585     : SourceLocation();
 586 }
 587
 588 //===----------------------------------------------------------------------===//
 589 // TemplateTemplateParmDecl Method Implementations
 590 //===----------------------------------------------------------------------===//
 591
 592 void TemplateTemplateParmDecl::anchor() { }
 593
 594 TemplateTemplateParmDecl::TemplateTemplateParmDecl(
 595     DeclContext *DC, SourceLocation L, unsigned D, unsigned P,
 596     IdentifierInfo *Id, TemplateParameterList *Params,
 597     unsigned NumExpansions, TemplateParameterList * const *Expansions)
 598   : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
 599     TemplateParmPosition(D, P), DefaultArgument(),
 600     DefaultArgumentWasInherited(false), ParameterPack(true),
 601     ExpandedParameterPack(true), NumExpandedParams(NumExpansions) {
 602   if (Expansions)
 603     std::memcpy(reinterpret_cast<void*>(this + 1), Expansions,
 604                 sizeof(TemplateParameterList*) * NumExpandedParams);
 605 }
 606
 607 TemplateTemplateParmDecl *
 608 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
 609                                  SourceLocation L, unsigned D, unsigned P,
 610                                  bool ParameterPack, IdentifierInfo *Id,
 611                                  TemplateParameterList *Params) {
 612   return new (C) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
 613                                           Params);
 614 }
 615
 616 TemplateTemplateParmDecl *
 617 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
 618                                  SourceLocation L, unsigned D, unsigned P,
 619                                  IdentifierInfo *Id,
 620                                  TemplateParameterList *Params,
 621                                  ArrayRef<TemplateParameterList *> Expansions) {
 622   void *Mem = C.Allocate(sizeof(TemplateTemplateParmDecl) +
 623                          sizeof(TemplateParameterList*) * Expansions.size());
 624   return new (Mem) TemplateTemplateParmDecl(DC, L, D, P, Id, Params,
 625                                             Expansions.size(),
 626                                             Expansions.data());
 627 }
 628
 629 TemplateTemplateParmDecl *
 630 TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
 631   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(TemplateTemplateParmDecl));
 632   return new (Mem) TemplateTemplateParmDecl(0, SourceLocation(), 0, 0, false,
 633                                             0, 0);
 634 }
 635
 636 TemplateTemplateParmDecl *
 637 TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
 638                                              unsigned NumExpansions) {
 639   unsigned Size = sizeof(TemplateTemplateParmDecl) +
 640                   sizeof(TemplateParameterList*) * NumExpansions;
 641   void *Mem = AllocateDeserializedDecl(C, ID, Size);
 642   return new (Mem) TemplateTemplateParmDecl(0, SourceLocation(), 0, 0, 0, 0,
 643                                             NumExpansions, 0);
 644 }
 645
 646 //===----------------------------------------------------------------------===//
 647 // TemplateArgumentList Implementation
 648 //===----------------------------------------------------------------------===//
 649 TemplateArgumentList *
 650 TemplateArgumentList::CreateCopy(ASTContext &Context,
 651                                  const TemplateArgument *Args,
 652                                  unsigned NumArgs) {
 653   std::size_t Size = sizeof(TemplateArgumentList)
 654                    + NumArgs * sizeof(TemplateArgument);
 655   void *Mem = Context.Allocate(Size);
 656   TemplateArgument *StoredArgs
 657     = reinterpret_cast<TemplateArgument *>(
 658                                 static_cast<TemplateArgumentList *>(Mem) + 1);
 659   std::uninitialized_copy(Args, Args + NumArgs, StoredArgs);
 660   return new (Mem) TemplateArgumentList(StoredArgs, NumArgs, true);
 661 }
 662
 663 FunctionTemplateSpecializationInfo *
 664 FunctionTemplateSpecializationInfo::Create(ASTContext &C, FunctionDecl *FD,
 665                                            FunctionTemplateDecl *Template,
 666                                            TemplateSpecializationKind TSK,
 667                                        const TemplateArgumentList *TemplateArgs,
 668                           const TemplateArgumentListInfo *TemplateArgsAsWritten,
 669                                            SourceLocation POI) {
 670   const ASTTemplateArgumentListInfo *ArgsAsWritten = 0;
 671   if (TemplateArgsAsWritten)
 672     ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C,
 673                                                         *TemplateArgsAsWritten);
 674
 675   return new (C) FunctionTemplateSpecializationInfo(FD, Template, TSK,
 676                                                     TemplateArgs,
 677                                                     ArgsAsWritten,
 678                                                     POI);
 679 }
 680
 681 //===----------------------------------------------------------------------===//
 682 // TemplateDecl Implementation
 683 //===----------------------------------------------------------------------===//
 684
 685 void TemplateDecl::anchor() { }
 686
 687 //===----------------------------------------------------------------------===//
 688 // ClassTemplateSpecializationDecl Implementation
 689 //===----------------------------------------------------------------------===//
 690 ClassTemplateSpecializationDecl::
 691 ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
 692                                 DeclContext *DC, SourceLocation StartLoc,
 693                                 SourceLocation IdLoc,
 694                                 ClassTemplateDecl *SpecializedTemplate,
 695                                 const TemplateArgument *Args,
 696                                 unsigned NumArgs,
 697                                 ClassTemplateSpecializationDecl *PrevDecl)
 698   : CXXRecordDecl(DK, TK, DC, StartLoc, IdLoc,
 699                   SpecializedTemplate->getIdentifier(),
 700                   PrevDecl),
 701     SpecializedTemplate(SpecializedTemplate),
 702     ExplicitInfo(0),
 703     TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args, NumArgs)),
 704     SpecializationKind(TSK_Undeclared) {
 705 }
 706
 707 ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(Kind DK)
 708   : CXXRecordDecl(DK, TTK_Struct, 0, SourceLocation(), SourceLocation(), 0, 0),
 709     ExplicitInfo(0),
 710     SpecializationKind(TSK_Undeclared) {
 711 }
 712
 713 ClassTemplateSpecializationDecl *
 714 ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
 715                                         DeclContext *DC,
 716                                         SourceLocation StartLoc,
 717                                         SourceLocation IdLoc,
 718                                         ClassTemplateDecl *SpecializedTemplate,
 719                                         const TemplateArgument *Args,
 720                                         unsigned NumArgs,
 721                                    ClassTemplateSpecializationDecl *PrevDecl) {
 722   ClassTemplateSpecializationDecl *Result
 723     = new (Context)ClassTemplateSpecializationDecl(Context,
 724                                                    ClassTemplateSpecialization,
 725                                                    TK, DC, StartLoc, IdLoc,
 726                                                    SpecializedTemplate,
 727                                                    Args, NumArgs,
 728                                                    PrevDecl);
 729   Result->MayHaveOutOfDateDef = false;
 730
 731   Context.getTypeDeclType(Result, PrevDecl);
 732   return Result;
 733 }
 734
 735 ClassTemplateSpecializationDecl *
 736 ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
 737                                                     unsigned ID) {
 738   void *Mem = AllocateDeserializedDecl(C, ID,
 739                                        sizeof(ClassTemplateSpecializationDecl));
 740   ClassTemplateSpecializationDecl *Result =
 741     new (Mem) ClassTemplateSpecializationDecl(ClassTemplateSpecialization);
 742   Result->MayHaveOutOfDateDef = false;
 743   return Result;
 744 }
 745
 746 void ClassTemplateSpecializationDecl::getNameForDiagnostic(
 747     raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
 748   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
 749
 750   const TemplateArgumentList &TemplateArgs = getTemplateArgs();
 751   TemplateSpecializationType::PrintTemplateArgumentList(
 752       OS, TemplateArgs.data(), TemplateArgs.size(), Policy);
 753 }
 754
 755 ClassTemplateDecl *
 756 ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
 757   if (SpecializedPartialSpecialization *PartialSpec
 758       = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
 759     return PartialSpec->PartialSpecialization->getSpecializedTemplate();
 760   return SpecializedTemplate.get<ClassTemplateDecl*>();
 761 }
 762
 763 SourceRange
 764 ClassTemplateSpecializationDecl::getSourceRange() const {
 765   if (ExplicitInfo) {
 766     SourceLocation Begin = getTemplateKeywordLoc();
 767     if (Begin.isValid()) {
 768       // Here we have an explicit (partial) specialization or instantiation.
 769       assert(getSpecializationKind() == TSK_ExplicitSpecialization ||
 770              getSpecializationKind() == TSK_ExplicitInstantiationDeclaration ||
 771              getSpecializationKind() == TSK_ExplicitInstantiationDefinition);
 772       if (getExternLoc().isValid())
 773         Begin = getExternLoc();
 774       SourceLocation End = getRBraceLoc();
 775       if (End.isInvalid())
 776         End = getTypeAsWritten()->getTypeLoc().getEndLoc();
 777       return SourceRange(Begin, End);
 778     }
 779     // An implicit instantiation of a class template partial specialization
 780     // uses ExplicitInfo to record the TypeAsWritten, but the source
 781     // locations should be retrieved from the instantiation pattern.
 782     typedef ClassTemplatePartialSpecializationDecl CTPSDecl;
 783     CTPSDecl *ctpsd = const_cast<CTPSDecl*>(cast<CTPSDecl>(this));
 784     CTPSDecl *inst_from = ctpsd->getInstantiatedFromMember();
 785     assert(inst_from != 0);
 786     return inst_from->getSourceRange();
 787   }
 788   else {
 789     // No explicit info available.
 790     llvm::PointerUnion<ClassTemplateDecl *,
 791                        ClassTemplatePartialSpecializationDecl *>
 792       inst_from = getInstantiatedFrom();
 793     if (inst_from.isNull())
 794       return getSpecializedTemplate()->getSourceRange();
 795     if (ClassTemplateDecl *ctd = inst_from.dyn_cast<ClassTemplateDecl*>())
 796       return ctd->getSourceRange();
 797     return inst_from.get<ClassTemplatePartialSpecializationDecl*>()
 798       ->getSourceRange();
 799   }
 800 }
 801
 802 //===----------------------------------------------------------------------===//
 803 // ClassTemplatePartialSpecializationDecl Implementation
 804 //===----------------------------------------------------------------------===//
 805 void ClassTemplatePartialSpecializationDecl::anchor() { }
 806
 807 ClassTemplatePartialSpecializationDecl::
 808 ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
 809                                        DeclContext *DC,
 810                                        SourceLocation StartLoc,
 811                                        SourceLocation IdLoc,
 812                                        TemplateParameterList *Params,
 813                                        ClassTemplateDecl *SpecializedTemplate,
 814                                        const TemplateArgument *Args,
 815                                        unsigned NumArgs,
 816                                        TemplateArgumentLoc *ArgInfos,
 817                                        unsigned NumArgInfos,
 818                                ClassTemplatePartialSpecializationDecl *PrevDecl,
 819                                        unsigned SequenceNumber)
 820   : ClassTemplateSpecializationDecl(Context,
 821                                     ClassTemplatePartialSpecialization,
 822                                     TK, DC, StartLoc, IdLoc,
 823                                     SpecializedTemplate,
 824                                     Args, NumArgs, PrevDecl),
 825     TemplateParams(Params), ArgsAsWritten(ArgInfos),
 826     NumArgsAsWritten(NumArgInfos), SequenceNumber(SequenceNumber),
 827     InstantiatedFromMember(0, false)
 828 {
 829   AdoptTemplateParameterList(Params, this);
 830 }
 831
 832 ClassTemplatePartialSpecializationDecl *
 833 ClassTemplatePartialSpecializationDecl::
 834 Create(ASTContext &Context, TagKind TK,DeclContext *DC,
 835        SourceLocation StartLoc, SourceLocation IdLoc,
 836        TemplateParameterList *Params,
 837        ClassTemplateDecl *SpecializedTemplate,
 838        const TemplateArgument *Args,
 839        unsigned NumArgs,
 840        const TemplateArgumentListInfo &ArgInfos,
 841        QualType CanonInjectedType,
 842        ClassTemplatePartialSpecializationDecl *PrevDecl,
 843        unsigned SequenceNumber) {
 844   unsigned N = ArgInfos.size();
 845   TemplateArgumentLoc *ClonedArgs = new (Context) TemplateArgumentLoc[N];
 846   for (unsigned I = 0; I != N; ++I)
 847     ClonedArgs[I] = ArgInfos[I];
 848
 849   ClassTemplatePartialSpecializationDecl *Result
 850     = new (Context)ClassTemplatePartialSpecializationDecl(Context, TK, DC,
 851                                                           StartLoc, IdLoc,
 852                                                           Params,
 853                                                           SpecializedTemplate,
 854                                                           Args, NumArgs,
 855                                                           ClonedArgs, N,
 856                                                           PrevDecl,
 857                                                           SequenceNumber);
 858   Result->setSpecializationKind(TSK_ExplicitSpecialization);
 859   Result->MayHaveOutOfDateDef = false;
 860
 861   Context.getInjectedClassNameType(Result, CanonInjectedType);
 862   return Result;
 863 }
 864
 865 ClassTemplatePartialSpecializationDecl *
 866 ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
 867                                                            unsigned ID) {
 868   void *Mem = AllocateDeserializedDecl(C, ID,
 869                 sizeof(ClassTemplatePartialSpecializationDecl));
 870   ClassTemplatePartialSpecializationDecl *Result
 871     = new (Mem) ClassTemplatePartialSpecializationDecl();
 872   Result->MayHaveOutOfDateDef = false;
 873   return Result;
 874 }
 875
 876 //===----------------------------------------------------------------------===//
 877 // FriendTemplateDecl Implementation
 878 //===----------------------------------------------------------------------===//
 879
 880 void FriendTemplateDecl::anchor() { }
 881
 882 FriendTemplateDecl *FriendTemplateDecl::Create(ASTContext &Context,
 883                                                DeclContext *DC,
 884                                                SourceLocation L,
 885                                                unsigned NParams,
 886                                                TemplateParameterList **Params,
 887                                                FriendUnion Friend,
 888                                                SourceLocation FLoc) {
 889   FriendTemplateDecl *Result
 890     = new (Context) FriendTemplateDecl(DC, L, NParams, Params, Friend, FLoc);
 891   return Result;
 892 }
 893
 894 FriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C,
 895                                                            unsigned ID) {
 896   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FriendTemplateDecl));
 897   return new (Mem) FriendTemplateDecl(EmptyShell());
 898 }
 899
 900 //===----------------------------------------------------------------------===//
 901 // TypeAliasTemplateDecl Implementation
 902 //===----------------------------------------------------------------------===//
 903
 904 TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C,
 905                                                      DeclContext *DC,
 906                                                      SourceLocation L,
 907                                                      DeclarationName Name,
 908                                                   TemplateParameterList *Params,
 909                                                      NamedDecl *Decl) {
 910   AdoptTemplateParameterList(Params, DC);
 911   return new (C) TypeAliasTemplateDecl(DC, L, Name, Params, Decl);
 912 }
 913
 914 TypeAliasTemplateDecl *TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C,
 915                                                                  unsigned ID) {
 916   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(TypeAliasTemplateDecl));
 917   return new (Mem) TypeAliasTemplateDecl(0, SourceLocation(), DeclarationName(),
 918                                          0, 0);
 919 }
 920
 921 void TypeAliasTemplateDecl::DeallocateCommon(void *Ptr) {
 922   static_cast<Common *>(Ptr)->~Common();
 923 }
 924 RedeclarableTemplateDecl::CommonBase *
 925 TypeAliasTemplateDecl::newCommon(ASTContext &C) const {
 926   Common *CommonPtr = new (C) Common;
 927   C.AddDeallocation(DeallocateCommon, CommonPtr);
 928   return CommonPtr;
 929 }
 930
 931 //===----------------------------------------------------------------------===//
 932 // ClassScopeFunctionSpecializationDecl Implementation
 933 //===----------------------------------------------------------------------===//
 934
 935 void ClassScopeFunctionSpecializationDecl::anchor() { }
 936
 937 ClassScopeFunctionSpecializationDecl *
 938 ClassScopeFunctionSpecializationDecl::CreateDeserialized(ASTContext &C,
 939                                                          unsigned ID) {
 940   void *Mem = AllocateDeserializedDecl(C, ID,
 941                 sizeof(ClassScopeFunctionSpecializationDecl));
 942   return new (Mem) ClassScopeFunctionSpecializationDecl(0, SourceLocation(), 0,
 943                                              false, TemplateArgumentListInfo());
 944 }