DeclTemplate.cpp revision 99ba9e3bd70671f3441fb974895f226a83ce0e66
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/DeclCXX.h" 15#include "clang/AST/DeclTemplate.h" 16#include "clang/AST/Expr.h" 17#include "clang/AST/ExprCXX.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/TypeLoc.h" 20#include "clang/AST/ASTMutationListener.h" 21#include "clang/Basic/IdentifierTable.h" 22#include "llvm/ADT/STLExtras.h" 23#include <memory> 24using namespace clang; 25 26//===----------------------------------------------------------------------===// 27// TemplateParameterList Implementation 28//===----------------------------------------------------------------------===// 29 30TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc, 31 SourceLocation LAngleLoc, 32 NamedDecl **Params, unsigned NumParams, 33 SourceLocation RAngleLoc) 34 : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc), 35 NumParams(NumParams) { 36 for (unsigned Idx = 0; Idx < NumParams; ++Idx) 37 begin()[Idx] = Params[Idx]; 38} 39 40TemplateParameterList * 41TemplateParameterList::Create(const ASTContext &C, SourceLocation TemplateLoc, 42 SourceLocation LAngleLoc, NamedDecl **Params, 43 unsigned NumParams, SourceLocation RAngleLoc) { 44 unsigned Size = sizeof(TemplateParameterList) 45 + sizeof(NamedDecl *) * NumParams; 46 unsigned Align = llvm::AlignOf<TemplateParameterList>::Alignment; 47 void *Mem = C.Allocate(Size, Align); 48 return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params, 49 NumParams, RAngleLoc); 50} 51 52unsigned TemplateParameterList::getMinRequiredArguments() const { 53 unsigned NumRequiredArgs = 0; 54 for (iterator P = const_cast<TemplateParameterList *>(this)->begin(), 55 PEnd = const_cast<TemplateParameterList *>(this)->end(); 56 P != PEnd; ++P) { 57 if ((*P)->isTemplateParameterPack()) { 58 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) 59 if (NTTP->isExpandedParameterPack()) { 60 NumRequiredArgs += NTTP->getNumExpansionTypes(); 61 continue; 62 } 63 64 break; 65 } 66 67 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) { 68 if (TTP->hasDefaultArgument()) 69 break; 70 } else if (NonTypeTemplateParmDecl *NTTP 71 = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 72 if (NTTP->hasDefaultArgument()) 73 break; 74 } else if (cast<TemplateTemplateParmDecl>(*P)->hasDefaultArgument()) 75 break; 76 77 ++NumRequiredArgs; 78 } 79 80 return NumRequiredArgs; 81} 82 83unsigned TemplateParameterList::getDepth() const { 84 if (size() == 0) 85 return 0; 86 87 const NamedDecl *FirstParm = getParam(0); 88 if (const TemplateTypeParmDecl *TTP 89 = dyn_cast<TemplateTypeParmDecl>(FirstParm)) 90 return TTP->getDepth(); 91 else if (const NonTypeTemplateParmDecl *NTTP 92 = dyn_cast<NonTypeTemplateParmDecl>(FirstParm)) 93 return NTTP->getDepth(); 94 else 95 return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth(); 96} 97 98static void AdoptTemplateParameterList(TemplateParameterList *Params, 99 DeclContext *Owner) { 100 for (TemplateParameterList::iterator P = Params->begin(), 101 PEnd = Params->end(); 102 P != PEnd; ++P) { 103 (*P)->setDeclContext(Owner); 104 105 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(*P)) 106 AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner); 107 } 108} 109 110//===----------------------------------------------------------------------===// 111// RedeclarableTemplateDecl Implementation 112//===----------------------------------------------------------------------===// 113 114RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() { 115 // Find the first declaration of this function template. 116 RedeclarableTemplateDecl *First = getCanonicalDecl(); 117 118 if (First->CommonOrPrev.isNull()) { 119 CommonBase *CommonPtr = First->newCommon(getASTContext()); 120 First->CommonOrPrev = CommonPtr; 121 CommonPtr->Latest = First; 122 } 123 return First->CommonOrPrev.get<CommonBase*>(); 124} 125 126 127RedeclarableTemplateDecl *RedeclarableTemplateDecl::getCanonicalDeclImpl() { 128 RedeclarableTemplateDecl *Tmpl = this; 129 while (Tmpl->getPreviousDeclaration()) 130 Tmpl = Tmpl->getPreviousDeclaration(); 131 return Tmpl; 132} 133 134void RedeclarableTemplateDecl::setPreviousDeclarationImpl( 135 RedeclarableTemplateDecl *Prev) { 136 if (Prev) { 137 CommonBase *Common = Prev->getCommonPtr(); 138 Prev = Common->Latest; 139 Common->Latest = this; 140 CommonOrPrev = Prev; 141 } else { 142 assert(CommonOrPrev.is<CommonBase*>() && "Cannot reset TemplateDecl Prev"); 143 } 144} 145 146RedeclarableTemplateDecl *RedeclarableTemplateDecl::getNextRedeclaration() { 147 if (CommonOrPrev.is<RedeclarableTemplateDecl*>()) 148 return CommonOrPrev.get<RedeclarableTemplateDecl*>(); 149 CommonBase *Common = CommonOrPrev.get<CommonBase*>(); 150 return Common ? Common->Latest : this; 151} 152 153template <class EntryType> 154typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType* 155RedeclarableTemplateDecl::findSpecializationImpl( 156 llvm::FoldingSet<EntryType> &Specs, 157 const TemplateArgument *Args, unsigned NumArgs, 158 void *&InsertPos) { 159 typedef SpecEntryTraits<EntryType> SETraits; 160 llvm::FoldingSetNodeID ID; 161 EntryType::Profile(ID,Args,NumArgs, getASTContext()); 162 EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos); 163 return Entry ? SETraits::getMostRecentDeclaration(Entry) : 0; 164} 165 166/// \brief Generate the injected template arguments for the given template 167/// parameter list, e.g., for the injected-class-name of a class template. 168static void GenerateInjectedTemplateArgs(ASTContext &Context, 169 TemplateParameterList *Params, 170 TemplateArgument *Args) { 171 for (TemplateParameterList::iterator Param = Params->begin(), 172 ParamEnd = Params->end(); 173 Param != ParamEnd; ++Param) { 174 TemplateArgument Arg; 175 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) { 176 QualType ArgType = Context.getTypeDeclType(TTP); 177 if (TTP->isParameterPack()) 178 ArgType = Context.getPackExpansionType(ArgType, 179 llvm::Optional<unsigned>()); 180 181 Arg = TemplateArgument(ArgType); 182 } else if (NonTypeTemplateParmDecl *NTTP = 183 dyn_cast<NonTypeTemplateParmDecl>(*Param)) { 184 Expr *E = new (Context) DeclRefExpr(NTTP, 185 NTTP->getType().getNonLValueExprType(Context), 186 Expr::getValueKindForType(NTTP->getType()), 187 NTTP->getLocation()); 188 189 if (NTTP->isParameterPack()) 190 E = new (Context) PackExpansionExpr(Context.DependentTy, E, 191 NTTP->getLocation(), 192 llvm::Optional<unsigned>()); 193 Arg = TemplateArgument(E); 194 } else { 195 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param); 196 if (TTP->isParameterPack()) 197 Arg = TemplateArgument(TemplateName(TTP), llvm::Optional<unsigned>()); 198 else 199 Arg = TemplateArgument(TemplateName(TTP)); 200 } 201 202 if ((*Param)->isTemplateParameterPack()) 203 Arg = TemplateArgument::CreatePackCopy(Context, &Arg, 1); 204 205 *Args++ = Arg; 206 } 207} 208 209//===----------------------------------------------------------------------===// 210// FunctionTemplateDecl Implementation 211//===----------------------------------------------------------------------===// 212 213void FunctionTemplateDecl::DeallocateCommon(void *Ptr) { 214 static_cast<Common *>(Ptr)->~Common(); 215} 216 217FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C, 218 DeclContext *DC, 219 SourceLocation L, 220 DeclarationName Name, 221 TemplateParameterList *Params, 222 NamedDecl *Decl) { 223 AdoptTemplateParameterList(Params, cast<DeclContext>(Decl)); 224 return new (C) FunctionTemplateDecl(DC, L, Name, Params, Decl); 225} 226 227FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C, EmptyShell) { 228 return new (C) FunctionTemplateDecl(0, SourceLocation(), DeclarationName(), 229 0, 0); 230} 231 232RedeclarableTemplateDecl::CommonBase * 233FunctionTemplateDecl::newCommon(ASTContext &C) { 234 Common *CommonPtr = new (C) Common; 235 C.AddDeallocation(DeallocateCommon, CommonPtr); 236 return CommonPtr; 237} 238 239FunctionDecl * 240FunctionTemplateDecl::findSpecialization(const TemplateArgument *Args, 241 unsigned NumArgs, void *&InsertPos) { 242 return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos); 243} 244 245void FunctionTemplateDecl::addSpecialization( 246 FunctionTemplateSpecializationInfo *Info, void *InsertPos) { 247 getSpecializations().InsertNode(Info, InsertPos); 248 if (ASTMutationListener *L = getASTMutationListener()) 249 L->AddedCXXTemplateSpecialization(this, Info->Function); 250} 251 252std::pair<const TemplateArgument *, unsigned> 253FunctionTemplateDecl::getInjectedTemplateArgs() { 254 TemplateParameterList *Params = getTemplateParameters(); 255 Common *CommonPtr = getCommonPtr(); 256 if (!CommonPtr->InjectedArgs) { 257 CommonPtr->InjectedArgs 258 = new (getASTContext()) TemplateArgument [Params->size()]; 259 GenerateInjectedTemplateArgs(getASTContext(), Params, 260 CommonPtr->InjectedArgs); 261 } 262 263 return std::make_pair(CommonPtr->InjectedArgs, Params->size()); 264} 265 266//===----------------------------------------------------------------------===// 267// ClassTemplateDecl Implementation 268//===----------------------------------------------------------------------===// 269 270void ClassTemplateDecl::DeallocateCommon(void *Ptr) { 271 static_cast<Common *>(Ptr)->~Common(); 272} 273 274ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C, 275 DeclContext *DC, 276 SourceLocation L, 277 DeclarationName Name, 278 TemplateParameterList *Params, 279 NamedDecl *Decl, 280 ClassTemplateDecl *PrevDecl) { 281 AdoptTemplateParameterList(Params, cast<DeclContext>(Decl)); 282 ClassTemplateDecl *New = new (C) ClassTemplateDecl(DC, L, Name, Params, Decl); 283 New->setPreviousDeclaration(PrevDecl); 284 return New; 285} 286 287ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C, EmptyShell Empty) { 288 return new (C) ClassTemplateDecl(Empty); 289} 290 291void ClassTemplateDecl::LoadLazySpecializations() { 292 Common *CommonPtr = getCommonPtr(); 293 if (CommonPtr->LazySpecializations) { 294 ASTContext &Context = getASTContext(); 295 uint32_t *Specs = CommonPtr->LazySpecializations; 296 CommonPtr->LazySpecializations = 0; 297 for (uint32_t I = 0, N = *Specs++; I != N; ++I) 298 (void)Context.getExternalSource()->GetExternalDecl(Specs[I]); 299 } 300} 301 302llvm::FoldingSet<ClassTemplateSpecializationDecl> & 303ClassTemplateDecl::getSpecializations() { 304 LoadLazySpecializations(); 305 return getCommonPtr()->Specializations; 306} 307 308llvm::FoldingSet<ClassTemplatePartialSpecializationDecl> & 309ClassTemplateDecl::getPartialSpecializations() { 310 LoadLazySpecializations(); 311 return getCommonPtr()->PartialSpecializations; 312} 313 314RedeclarableTemplateDecl::CommonBase * 315ClassTemplateDecl::newCommon(ASTContext &C) { 316 Common *CommonPtr = new (C) Common; 317 C.AddDeallocation(DeallocateCommon, CommonPtr); 318 return CommonPtr; 319} 320 321ClassTemplateSpecializationDecl * 322ClassTemplateDecl::findSpecialization(const TemplateArgument *Args, 323 unsigned NumArgs, void *&InsertPos) { 324 return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos); 325} 326 327void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D, 328 void *InsertPos) { 329 getSpecializations().InsertNode(D, InsertPos); 330 if (ASTMutationListener *L = getASTMutationListener()) 331 L->AddedCXXTemplateSpecialization(this, D); 332} 333 334ClassTemplatePartialSpecializationDecl * 335ClassTemplateDecl::findPartialSpecialization(const TemplateArgument *Args, 336 unsigned NumArgs, 337 void *&InsertPos) { 338 return findSpecializationImpl(getPartialSpecializations(), Args, NumArgs, 339 InsertPos); 340} 341 342void ClassTemplateDecl::AddPartialSpecialization( 343 ClassTemplatePartialSpecializationDecl *D, 344 void *InsertPos) { 345 getPartialSpecializations().InsertNode(D, InsertPos); 346 if (ASTMutationListener *L = getASTMutationListener()) 347 L->AddedCXXTemplateSpecialization(this, D); 348} 349 350void ClassTemplateDecl::getPartialSpecializations( 351 SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) { 352 llvm::FoldingSet<ClassTemplatePartialSpecializationDecl> &PartialSpecs 353 = getPartialSpecializations(); 354 PS.clear(); 355 PS.resize(PartialSpecs.size()); 356 for (llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator 357 P = PartialSpecs.begin(), PEnd = PartialSpecs.end(); 358 P != PEnd; ++P) { 359 assert(!PS[P->getSequenceNumber()]); 360 PS[P->getSequenceNumber()] = P->getMostRecentDeclaration(); 361 } 362} 363 364ClassTemplatePartialSpecializationDecl * 365ClassTemplateDecl::findPartialSpecialization(QualType T) { 366 ASTContext &Context = getASTContext(); 367 typedef llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator 368 partial_spec_iterator; 369 for (partial_spec_iterator P = getPartialSpecializations().begin(), 370 PEnd = getPartialSpecializations().end(); 371 P != PEnd; ++P) { 372 if (Context.hasSameType(P->getInjectedSpecializationType(), T)) 373 return P->getMostRecentDeclaration(); 374 } 375 376 return 0; 377} 378 379ClassTemplatePartialSpecializationDecl * 380ClassTemplateDecl::findPartialSpecInstantiatedFromMember( 381 ClassTemplatePartialSpecializationDecl *D) { 382 Decl *DCanon = D->getCanonicalDecl(); 383 for (llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator 384 P = getPartialSpecializations().begin(), 385 PEnd = getPartialSpecializations().end(); 386 P != PEnd; ++P) { 387 if (P->getInstantiatedFromMember()->getCanonicalDecl() == DCanon) 388 return P->getMostRecentDeclaration(); 389 } 390 391 return 0; 392} 393 394QualType 395ClassTemplateDecl::getInjectedClassNameSpecialization() { 396 Common *CommonPtr = getCommonPtr(); 397 if (!CommonPtr->InjectedClassNameType.isNull()) 398 return CommonPtr->InjectedClassNameType; 399 400 // C++0x [temp.dep.type]p2: 401 // The template argument list of a primary template is a template argument 402 // list in which the nth template argument has the value of the nth template 403 // parameter of the class template. If the nth template parameter is a 404 // template parameter pack (14.5.3), the nth template argument is a pack 405 // expansion (14.5.3) whose pattern is the name of the template parameter 406 // pack. 407 ASTContext &Context = getASTContext(); 408 TemplateParameterList *Params = getTemplateParameters(); 409 SmallVector<TemplateArgument, 16> TemplateArgs; 410 TemplateArgs.resize(Params->size()); 411 GenerateInjectedTemplateArgs(getASTContext(), Params, TemplateArgs.data()); 412 CommonPtr->InjectedClassNameType 413 = Context.getTemplateSpecializationType(TemplateName(this), 414 &TemplateArgs[0], 415 TemplateArgs.size()); 416 return CommonPtr->InjectedClassNameType; 417} 418 419//===----------------------------------------------------------------------===// 420// TemplateTypeParm Allocation/Deallocation Method Implementations 421//===----------------------------------------------------------------------===// 422 423TemplateTypeParmDecl * 424TemplateTypeParmDecl::Create(const ASTContext &C, DeclContext *DC, 425 SourceLocation KeyLoc, SourceLocation NameLoc, 426 unsigned D, unsigned P, IdentifierInfo *Id, 427 bool Typename, bool ParameterPack) { 428 TemplateTypeParmDecl *TTPDecl = 429 new (C) TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename); 430 QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl); 431 TTPDecl->TypeForDecl = TTPType.getTypePtr(); 432 return TTPDecl; 433} 434 435TemplateTypeParmDecl * 436TemplateTypeParmDecl::Create(const ASTContext &C, EmptyShell Empty) { 437 return new (C) TemplateTypeParmDecl(0, SourceLocation(), SourceLocation(), 438 0, false); 439} 440 441SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const { 442 return hasDefaultArgument() 443 ? DefaultArgument->getTypeLoc().getBeginLoc() 444 : SourceLocation(); 445} 446 447SourceRange TemplateTypeParmDecl::getSourceRange() const { 448 if (hasDefaultArgument() && !defaultArgumentWasInherited()) 449 return SourceRange(getLocStart(), 450 DefaultArgument->getTypeLoc().getEndLoc()); 451 else 452 return TypeDecl::getSourceRange(); 453} 454 455unsigned TemplateTypeParmDecl::getDepth() const { 456 return TypeForDecl->getAs<TemplateTypeParmType>()->getDepth(); 457} 458 459unsigned TemplateTypeParmDecl::getIndex() const { 460 return TypeForDecl->getAs<TemplateTypeParmType>()->getIndex(); 461} 462 463bool TemplateTypeParmDecl::isParameterPack() const { 464 return TypeForDecl->getAs<TemplateTypeParmType>()->isParameterPack(); 465} 466 467//===----------------------------------------------------------------------===// 468// NonTypeTemplateParmDecl Method Implementations 469//===----------------------------------------------------------------------===// 470 471NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(DeclContext *DC, 472 SourceLocation StartLoc, 473 SourceLocation IdLoc, 474 unsigned D, unsigned P, 475 IdentifierInfo *Id, 476 QualType T, 477 TypeSourceInfo *TInfo, 478 const QualType *ExpandedTypes, 479 unsigned NumExpandedTypes, 480 TypeSourceInfo **ExpandedTInfos) 481 : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc), 482 TemplateParmPosition(D, P), DefaultArgumentAndInherited(0, false), 483 ParameterPack(true), ExpandedParameterPack(true), 484 NumExpandedTypes(NumExpandedTypes) 485{ 486 if (ExpandedTypes && ExpandedTInfos) { 487 void **TypesAndInfos = reinterpret_cast<void **>(this + 1); 488 for (unsigned I = 0; I != NumExpandedTypes; ++I) { 489 TypesAndInfos[2*I] = ExpandedTypes[I].getAsOpaquePtr(); 490 TypesAndInfos[2*I + 1] = ExpandedTInfos[I]; 491 } 492 } 493} 494 495NonTypeTemplateParmDecl * 496NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC, 497 SourceLocation StartLoc, SourceLocation IdLoc, 498 unsigned D, unsigned P, IdentifierInfo *Id, 499 QualType T, bool ParameterPack, 500 TypeSourceInfo *TInfo) { 501 return new (C) NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, 502 T, ParameterPack, TInfo); 503} 504 505NonTypeTemplateParmDecl * 506NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC, 507 SourceLocation StartLoc, SourceLocation IdLoc, 508 unsigned D, unsigned P, 509 IdentifierInfo *Id, QualType T, 510 TypeSourceInfo *TInfo, 511 const QualType *ExpandedTypes, 512 unsigned NumExpandedTypes, 513 TypeSourceInfo **ExpandedTInfos) { 514 unsigned Size = sizeof(NonTypeTemplateParmDecl) 515 + NumExpandedTypes * 2 * sizeof(void*); 516 void *Mem = C.Allocate(Size); 517 return new (Mem) NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, 518 D, P, Id, T, TInfo, 519 ExpandedTypes, NumExpandedTypes, 520 ExpandedTInfos); 521} 522 523SourceRange NonTypeTemplateParmDecl::getSourceRange() const { 524 if (hasDefaultArgument() && !defaultArgumentWasInherited()) 525 return SourceRange(getOuterLocStart(), 526 getDefaultArgument()->getSourceRange().getEnd()); 527 return DeclaratorDecl::getSourceRange(); 528} 529 530SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const { 531 return hasDefaultArgument() 532 ? getDefaultArgument()->getSourceRange().getBegin() 533 : SourceLocation(); 534} 535 536//===----------------------------------------------------------------------===// 537// TemplateTemplateParmDecl Method Implementations 538//===----------------------------------------------------------------------===// 539 540void TemplateTemplateParmDecl::anchor() { } 541 542TemplateTemplateParmDecl * 543TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC, 544 SourceLocation L, unsigned D, unsigned P, 545 bool ParameterPack, IdentifierInfo *Id, 546 TemplateParameterList *Params) { 547 return new (C) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id, 548 Params); 549} 550 551//===----------------------------------------------------------------------===// 552// TemplateArgumentList Implementation 553//===----------------------------------------------------------------------===// 554TemplateArgumentList * 555TemplateArgumentList::CreateCopy(ASTContext &Context, 556 const TemplateArgument *Args, 557 unsigned NumArgs) { 558 std::size_t Size = sizeof(TemplateArgumentList) 559 + NumArgs * sizeof(TemplateArgument); 560 void *Mem = Context.Allocate(Size); 561 TemplateArgument *StoredArgs 562 = reinterpret_cast<TemplateArgument *>( 563 static_cast<TemplateArgumentList *>(Mem) + 1); 564 std::uninitialized_copy(Args, Args + NumArgs, StoredArgs); 565 return new (Mem) TemplateArgumentList(StoredArgs, NumArgs, true); 566} 567 568FunctionTemplateSpecializationInfo * 569FunctionTemplateSpecializationInfo::Create(ASTContext &C, FunctionDecl *FD, 570 FunctionTemplateDecl *Template, 571 TemplateSpecializationKind TSK, 572 const TemplateArgumentList *TemplateArgs, 573 const TemplateArgumentListInfo *TemplateArgsAsWritten, 574 SourceLocation POI) { 575 const ASTTemplateArgumentListInfo *ArgsAsWritten = 0; 576 if (TemplateArgsAsWritten) 577 ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C, 578 *TemplateArgsAsWritten); 579 580 return new (C) FunctionTemplateSpecializationInfo(FD, Template, TSK, 581 TemplateArgs, 582 ArgsAsWritten, 583 POI); 584} 585 586//===----------------------------------------------------------------------===// 587// TemplateDecl Implementation 588//===----------------------------------------------------------------------===// 589 590void TemplateDecl::anchor() { } 591 592//===----------------------------------------------------------------------===// 593// ClassTemplateSpecializationDecl Implementation 594//===----------------------------------------------------------------------===// 595ClassTemplateSpecializationDecl:: 596ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK, 597 DeclContext *DC, SourceLocation StartLoc, 598 SourceLocation IdLoc, 599 ClassTemplateDecl *SpecializedTemplate, 600 const TemplateArgument *Args, 601 unsigned NumArgs, 602 ClassTemplateSpecializationDecl *PrevDecl) 603 : CXXRecordDecl(DK, TK, DC, StartLoc, IdLoc, 604 SpecializedTemplate->getIdentifier(), 605 PrevDecl), 606 SpecializedTemplate(SpecializedTemplate), 607 ExplicitInfo(0), 608 TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args, NumArgs)), 609 SpecializationKind(TSK_Undeclared) { 610} 611 612ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(Kind DK) 613 : CXXRecordDecl(DK, TTK_Struct, 0, SourceLocation(), SourceLocation(), 0, 0), 614 ExplicitInfo(0), 615 SpecializationKind(TSK_Undeclared) { 616} 617 618ClassTemplateSpecializationDecl * 619ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK, 620 DeclContext *DC, 621 SourceLocation StartLoc, 622 SourceLocation IdLoc, 623 ClassTemplateDecl *SpecializedTemplate, 624 const TemplateArgument *Args, 625 unsigned NumArgs, 626 ClassTemplateSpecializationDecl *PrevDecl) { 627 ClassTemplateSpecializationDecl *Result 628 = new (Context)ClassTemplateSpecializationDecl(Context, 629 ClassTemplateSpecialization, 630 TK, DC, StartLoc, IdLoc, 631 SpecializedTemplate, 632 Args, NumArgs, 633 PrevDecl); 634 Context.getTypeDeclType(Result, PrevDecl); 635 return Result; 636} 637 638ClassTemplateSpecializationDecl * 639ClassTemplateSpecializationDecl::Create(ASTContext &Context, EmptyShell Empty) { 640 return 641 new (Context)ClassTemplateSpecializationDecl(ClassTemplateSpecialization); 642} 643 644void 645ClassTemplateSpecializationDecl::getNameForDiagnostic(std::string &S, 646 const PrintingPolicy &Policy, 647 bool Qualified) const { 648 NamedDecl::getNameForDiagnostic(S, Policy, Qualified); 649 650 const TemplateArgumentList &TemplateArgs = getTemplateArgs(); 651 S += TemplateSpecializationType::PrintTemplateArgumentList( 652 TemplateArgs.data(), 653 TemplateArgs.size(), 654 Policy); 655} 656 657ClassTemplateDecl * 658ClassTemplateSpecializationDecl::getSpecializedTemplate() const { 659 if (SpecializedPartialSpecialization *PartialSpec 660 = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>()) 661 return PartialSpec->PartialSpecialization->getSpecializedTemplate(); 662 return SpecializedTemplate.get<ClassTemplateDecl*>(); 663} 664 665SourceRange 666ClassTemplateSpecializationDecl::getSourceRange() const { 667 if (ExplicitInfo) { 668 SourceLocation Begin = getExternLoc(); 669 if (Begin.isInvalid()) 670 Begin = getTemplateKeywordLoc(); 671 SourceLocation End = getRBraceLoc(); 672 if (End.isInvalid()) 673 End = getTypeAsWritten()->getTypeLoc().getEndLoc(); 674 return SourceRange(Begin, End); 675 } 676 else { 677 // No explicit info available. 678 llvm::PointerUnion<ClassTemplateDecl *, 679 ClassTemplatePartialSpecializationDecl *> 680 inst_from = getInstantiatedFrom(); 681 if (inst_from.isNull()) 682 return getSpecializedTemplate()->getSourceRange(); 683 if (ClassTemplateDecl *ctd = inst_from.dyn_cast<ClassTemplateDecl*>()) 684 return ctd->getSourceRange(); 685 return inst_from.get<ClassTemplatePartialSpecializationDecl*>() 686 ->getSourceRange(); 687 } 688} 689 690//===----------------------------------------------------------------------===// 691// ClassTemplatePartialSpecializationDecl Implementation 692//===----------------------------------------------------------------------===// 693void ClassTemplatePartialSpecializationDecl::anchor() { } 694 695ClassTemplatePartialSpecializationDecl:: 696ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK, 697 DeclContext *DC, 698 SourceLocation StartLoc, 699 SourceLocation IdLoc, 700 TemplateParameterList *Params, 701 ClassTemplateDecl *SpecializedTemplate, 702 const TemplateArgument *Args, 703 unsigned NumArgs, 704 TemplateArgumentLoc *ArgInfos, 705 unsigned NumArgInfos, 706 ClassTemplatePartialSpecializationDecl *PrevDecl, 707 unsigned SequenceNumber) 708 : ClassTemplateSpecializationDecl(Context, 709 ClassTemplatePartialSpecialization, 710 TK, DC, StartLoc, IdLoc, 711 SpecializedTemplate, 712 Args, NumArgs, PrevDecl), 713 TemplateParams(Params), ArgsAsWritten(ArgInfos), 714 NumArgsAsWritten(NumArgInfos), SequenceNumber(SequenceNumber), 715 InstantiatedFromMember(0, false) 716{ 717 AdoptTemplateParameterList(Params, this); 718} 719 720ClassTemplatePartialSpecializationDecl * 721ClassTemplatePartialSpecializationDecl:: 722Create(ASTContext &Context, TagKind TK,DeclContext *DC, 723 SourceLocation StartLoc, SourceLocation IdLoc, 724 TemplateParameterList *Params, 725 ClassTemplateDecl *SpecializedTemplate, 726 const TemplateArgument *Args, 727 unsigned NumArgs, 728 const TemplateArgumentListInfo &ArgInfos, 729 QualType CanonInjectedType, 730 ClassTemplatePartialSpecializationDecl *PrevDecl, 731 unsigned SequenceNumber) { 732 unsigned N = ArgInfos.size(); 733 TemplateArgumentLoc *ClonedArgs = new (Context) TemplateArgumentLoc[N]; 734 for (unsigned I = 0; I != N; ++I) 735 ClonedArgs[I] = ArgInfos[I]; 736 737 ClassTemplatePartialSpecializationDecl *Result 738 = new (Context)ClassTemplatePartialSpecializationDecl(Context, TK, DC, 739 StartLoc, IdLoc, 740 Params, 741 SpecializedTemplate, 742 Args, NumArgs, 743 ClonedArgs, N, 744 PrevDecl, 745 SequenceNumber); 746 Result->setSpecializationKind(TSK_ExplicitSpecialization); 747 748 Context.getInjectedClassNameType(Result, CanonInjectedType); 749 return Result; 750} 751 752ClassTemplatePartialSpecializationDecl * 753ClassTemplatePartialSpecializationDecl::Create(ASTContext &Context, 754 EmptyShell Empty) { 755 return new (Context)ClassTemplatePartialSpecializationDecl(); 756} 757 758//===----------------------------------------------------------------------===// 759// FriendTemplateDecl Implementation 760//===----------------------------------------------------------------------===// 761 762void FriendTemplateDecl::anchor() { } 763 764FriendTemplateDecl *FriendTemplateDecl::Create(ASTContext &Context, 765 DeclContext *DC, 766 SourceLocation L, 767 unsigned NParams, 768 TemplateParameterList **Params, 769 FriendUnion Friend, 770 SourceLocation FLoc) { 771 FriendTemplateDecl *Result 772 = new (Context) FriendTemplateDecl(DC, L, NParams, Params, Friend, FLoc); 773 return Result; 774} 775 776FriendTemplateDecl *FriendTemplateDecl::Create(ASTContext &Context, 777 EmptyShell Empty) { 778 return new (Context) FriendTemplateDecl(Empty); 779} 780 781//===----------------------------------------------------------------------===// 782// TypeAliasTemplateDecl Implementation 783//===----------------------------------------------------------------------===// 784 785TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C, 786 DeclContext *DC, 787 SourceLocation L, 788 DeclarationName Name, 789 TemplateParameterList *Params, 790 NamedDecl *Decl) { 791 AdoptTemplateParameterList(Params, DC); 792 return new (C) TypeAliasTemplateDecl(DC, L, Name, Params, Decl); 793} 794 795TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C, 796 EmptyShell) { 797 return new (C) TypeAliasTemplateDecl(0, SourceLocation(), DeclarationName(), 798 0, 0); 799} 800 801void TypeAliasTemplateDecl::DeallocateCommon(void *Ptr) { 802 static_cast<Common *>(Ptr)->~Common(); 803} 804RedeclarableTemplateDecl::CommonBase * 805TypeAliasTemplateDecl::newCommon(ASTContext &C) { 806 Common *CommonPtr = new (C) Common; 807 C.AddDeallocation(DeallocateCommon, CommonPtr); 808 return CommonPtr; 809} 810 811//===----------------------------------------------------------------------===// 812// ClassScopeFunctionSpecializationDecl Implementation 813//===----------------------------------------------------------------------===// 814 815void ClassScopeFunctionSpecializationDecl::anchor() { } 816