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> 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) { 36 for (unsigned Idx = 0; Idx < NumParams; ++Idx) 37 begin()[Idx] = Params[Idx]; 38 } 39 40 TemplateParameterList * 41 TemplateParameterList::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 52 unsigned 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 83 unsigned 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 98 static 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 114 RedeclarableTemplateDecl::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 127 RedeclarableTemplateDecl *RedeclarableTemplateDecl::getCanonicalDeclImpl() { 128 RedeclarableTemplateDecl *Tmpl = this; 129 while (Tmpl->getPreviousDeclaration()) 130 Tmpl = Tmpl->getPreviousDeclaration(); 131 return Tmpl; 132 } 133 134 void 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 146 RedeclarableTemplateDecl *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 153 template <class EntryType> 154 typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType* 155 RedeclarableTemplateDecl::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. 168 static 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 213 void FunctionTemplateDecl::DeallocateCommon(void *Ptr) { 214 static_cast<Common *>(Ptr)->~Common(); 215 } 216 217 FunctionTemplateDecl *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 227 FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C, EmptyShell) { 228 return new (C) FunctionTemplateDecl(0, SourceLocation(), DeclarationName(), 229 0, 0); 230 } 231 232 RedeclarableTemplateDecl::CommonBase * 233 FunctionTemplateDecl::newCommon(ASTContext &C) { 234 Common *CommonPtr = new (C) Common; 235 C.AddDeallocation(DeallocateCommon, CommonPtr); 236 return CommonPtr; 237 } 238 239 FunctionDecl * 240 FunctionTemplateDecl::findSpecialization(const TemplateArgument *Args, 241 unsigned NumArgs, void *&InsertPos) { 242 return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos); 243 } 244 245 void 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 252 std::pair<const TemplateArgument *, unsigned> 253 FunctionTemplateDecl::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 270 void ClassTemplateDecl::DeallocateCommon(void *Ptr) { 271 static_cast<Common *>(Ptr)->~Common(); 272 } 273 274 ClassTemplateDecl *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 287 ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C, EmptyShell Empty) { 288 return new (C) ClassTemplateDecl(Empty); 289 } 290 291 void 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 302 llvm::FoldingSet<ClassTemplateSpecializationDecl> & 303 ClassTemplateDecl::getSpecializations() { 304 LoadLazySpecializations(); 305 return getCommonPtr()->Specializations; 306 } 307 308 llvm::FoldingSet<ClassTemplatePartialSpecializationDecl> & 309 ClassTemplateDecl::getPartialSpecializations() { 310 LoadLazySpecializations(); 311 return getCommonPtr()->PartialSpecializations; 312 } 313 314 RedeclarableTemplateDecl::CommonBase * 315 ClassTemplateDecl::newCommon(ASTContext &C) { 316 Common *CommonPtr = new (C) Common; 317 C.AddDeallocation(DeallocateCommon, CommonPtr); 318 return CommonPtr; 319 } 320 321 ClassTemplateSpecializationDecl * 322 ClassTemplateDecl::findSpecialization(const TemplateArgument *Args, 323 unsigned NumArgs, void *&InsertPos) { 324 return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos); 325 } 326 327 void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D, 328 void *InsertPos) { 329 getSpecializations().InsertNode(D, InsertPos); 330 if (ASTMutationListener *L = getASTMutationListener()) 331 L->AddedCXXTemplateSpecialization(this, D); 332 } 333 334 ClassTemplatePartialSpecializationDecl * 335 ClassTemplateDecl::findPartialSpecialization(const TemplateArgument *Args, 336 unsigned NumArgs, 337 void *&InsertPos) { 338 return findSpecializationImpl(getPartialSpecializations(), Args, NumArgs, 339 InsertPos); 340 } 341 342 void 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 350 void 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 364 ClassTemplatePartialSpecializationDecl * 365 ClassTemplateDecl::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 379 ClassTemplatePartialSpecializationDecl * 380 ClassTemplateDecl::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 394 QualType 395 ClassTemplateDecl::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 423 TemplateTypeParmDecl * 424 TemplateTypeParmDecl::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 435 TemplateTypeParmDecl * 436 TemplateTypeParmDecl::Create(const ASTContext &C, EmptyShell Empty) { 437 return new (C) TemplateTypeParmDecl(0, SourceLocation(), SourceLocation(), 438 0, false); 439 } 440 441 SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const { 442 return hasDefaultArgument() 443 ? DefaultArgument->getTypeLoc().getBeginLoc() 444 : SourceLocation(); 445 } 446 447 SourceRange TemplateTypeParmDecl::getSourceRange() const { 448 if (hasDefaultArgument() && !defaultArgumentWasInherited()) 449 return SourceRange(getLocStart(), 450 DefaultArgument->getTypeLoc().getEndLoc()); 451 else 452 return TypeDecl::getSourceRange(); 453 } 454 455 unsigned TemplateTypeParmDecl::getDepth() const { 456 return TypeForDecl->getAs<TemplateTypeParmType>()->getDepth(); 457 } 458 459 unsigned TemplateTypeParmDecl::getIndex() const { 460 return TypeForDecl->getAs<TemplateTypeParmType>()->getIndex(); 461 } 462 463 bool TemplateTypeParmDecl::isParameterPack() const { 464 return TypeForDecl->getAs<TemplateTypeParmType>()->isParameterPack(); 465 } 466 467 //===----------------------------------------------------------------------===// 468 // NonTypeTemplateParmDecl Method Implementations 469 //===----------------------------------------------------------------------===// 470 471 NonTypeTemplateParmDecl::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 495 NonTypeTemplateParmDecl * 496 NonTypeTemplateParmDecl::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 505 NonTypeTemplateParmDecl * 506 NonTypeTemplateParmDecl::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 523 SourceRange NonTypeTemplateParmDecl::getSourceRange() const { 524 if (hasDefaultArgument() && !defaultArgumentWasInherited()) 525 return SourceRange(getOuterLocStart(), 526 getDefaultArgument()->getSourceRange().getEnd()); 527 return DeclaratorDecl::getSourceRange(); 528 } 529 530 SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const { 531 return hasDefaultArgument() 532 ? getDefaultArgument()->getSourceRange().getBegin() 533 : SourceLocation(); 534 } 535 536 //===----------------------------------------------------------------------===// 537 // TemplateTemplateParmDecl Method Implementations 538 //===----------------------------------------------------------------------===// 539 540 TemplateTemplateParmDecl * 541 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC, 542 SourceLocation L, unsigned D, unsigned P, 543 bool ParameterPack, IdentifierInfo *Id, 544 TemplateParameterList *Params) { 545 return new (C) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id, 546 Params); 547 } 548 549 //===----------------------------------------------------------------------===// 550 // TemplateArgumentList Implementation 551 //===----------------------------------------------------------------------===// 552 TemplateArgumentList * 553 TemplateArgumentList::CreateCopy(ASTContext &Context, 554 const TemplateArgument *Args, 555 unsigned NumArgs) { 556 std::size_t Size = sizeof(TemplateArgumentList) 557 + NumArgs * sizeof(TemplateArgument); 558 void *Mem = Context.Allocate(Size); 559 TemplateArgument *StoredArgs 560 = reinterpret_cast<TemplateArgument *>( 561 static_cast<TemplateArgumentList *>(Mem) + 1); 562 std::uninitialized_copy(Args, Args + NumArgs, StoredArgs); 563 return new (Mem) TemplateArgumentList(StoredArgs, NumArgs, true); 564 } 565 566 FunctionTemplateSpecializationInfo * 567 FunctionTemplateSpecializationInfo::Create(ASTContext &C, FunctionDecl *FD, 568 FunctionTemplateDecl *Template, 569 TemplateSpecializationKind TSK, 570 const TemplateArgumentList *TemplateArgs, 571 const TemplateArgumentListInfo *TemplateArgsAsWritten, 572 SourceLocation POI) { 573 const ASTTemplateArgumentListInfo *ArgsAsWritten = 0; 574 if (TemplateArgsAsWritten) 575 ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C, 576 *TemplateArgsAsWritten); 577 578 return new (C) FunctionTemplateSpecializationInfo(FD, Template, TSK, 579 TemplateArgs, 580 ArgsAsWritten, 581 POI); 582 } 583 584 //===----------------------------------------------------------------------===// 585 // ClassTemplateSpecializationDecl Implementation 586 //===----------------------------------------------------------------------===// 587 ClassTemplateSpecializationDecl:: 588 ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK, 589 DeclContext *DC, SourceLocation StartLoc, 590 SourceLocation IdLoc, 591 ClassTemplateDecl *SpecializedTemplate, 592 const TemplateArgument *Args, 593 unsigned NumArgs, 594 ClassTemplateSpecializationDecl *PrevDecl) 595 : CXXRecordDecl(DK, TK, DC, StartLoc, IdLoc, 596 SpecializedTemplate->getIdentifier(), 597 PrevDecl), 598 SpecializedTemplate(SpecializedTemplate), 599 ExplicitInfo(0), 600 TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args, NumArgs)), 601 SpecializationKind(TSK_Undeclared) { 602 } 603 604 ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(Kind DK) 605 : CXXRecordDecl(DK, TTK_Struct, 0, SourceLocation(), SourceLocation(), 0, 0), 606 ExplicitInfo(0), 607 SpecializationKind(TSK_Undeclared) { 608 } 609 610 ClassTemplateSpecializationDecl * 611 ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK, 612 DeclContext *DC, 613 SourceLocation StartLoc, 614 SourceLocation IdLoc, 615 ClassTemplateDecl *SpecializedTemplate, 616 const TemplateArgument *Args, 617 unsigned NumArgs, 618 ClassTemplateSpecializationDecl *PrevDecl) { 619 ClassTemplateSpecializationDecl *Result 620 = new (Context)ClassTemplateSpecializationDecl(Context, 621 ClassTemplateSpecialization, 622 TK, DC, StartLoc, IdLoc, 623 SpecializedTemplate, 624 Args, NumArgs, 625 PrevDecl); 626 Context.getTypeDeclType(Result, PrevDecl); 627 return Result; 628 } 629 630 ClassTemplateSpecializationDecl * 631 ClassTemplateSpecializationDecl::Create(ASTContext &Context, EmptyShell Empty) { 632 return 633 new (Context)ClassTemplateSpecializationDecl(ClassTemplateSpecialization); 634 } 635 636 void 637 ClassTemplateSpecializationDecl::getNameForDiagnostic(std::string &S, 638 const PrintingPolicy &Policy, 639 bool Qualified) const { 640 NamedDecl::getNameForDiagnostic(S, Policy, Qualified); 641 642 const TemplateArgumentList &TemplateArgs = getTemplateArgs(); 643 S += TemplateSpecializationType::PrintTemplateArgumentList( 644 TemplateArgs.data(), 645 TemplateArgs.size(), 646 Policy); 647 } 648 649 ClassTemplateDecl * 650 ClassTemplateSpecializationDecl::getSpecializedTemplate() const { 651 if (SpecializedPartialSpecialization *PartialSpec 652 = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>()) 653 return PartialSpec->PartialSpecialization->getSpecializedTemplate(); 654 return SpecializedTemplate.get<ClassTemplateDecl*>(); 655 } 656 657 SourceRange 658 ClassTemplateSpecializationDecl::getSourceRange() const { 659 if (ExplicitInfo) { 660 SourceLocation Begin = getExternLoc(); 661 if (Begin.isInvalid()) 662 Begin = getTemplateKeywordLoc(); 663 SourceLocation End = getRBraceLoc(); 664 if (End.isInvalid()) 665 End = getTypeAsWritten()->getTypeLoc().getEndLoc(); 666 return SourceRange(Begin, End); 667 } 668 else { 669 // No explicit info available. 670 llvm::PointerUnion<ClassTemplateDecl *, 671 ClassTemplatePartialSpecializationDecl *> 672 inst_from = getInstantiatedFrom(); 673 if (inst_from.isNull()) 674 return getSpecializedTemplate()->getSourceRange(); 675 if (ClassTemplateDecl *ctd = inst_from.dyn_cast<ClassTemplateDecl*>()) 676 return ctd->getSourceRange(); 677 return inst_from.get<ClassTemplatePartialSpecializationDecl*>() 678 ->getSourceRange(); 679 } 680 } 681 682 //===----------------------------------------------------------------------===// 683 // ClassTemplatePartialSpecializationDecl Implementation 684 //===----------------------------------------------------------------------===// 685 ClassTemplatePartialSpecializationDecl:: 686 ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK, 687 DeclContext *DC, 688 SourceLocation StartLoc, 689 SourceLocation IdLoc, 690 TemplateParameterList *Params, 691 ClassTemplateDecl *SpecializedTemplate, 692 const TemplateArgument *Args, 693 unsigned NumArgs, 694 TemplateArgumentLoc *ArgInfos, 695 unsigned NumArgInfos, 696 ClassTemplatePartialSpecializationDecl *PrevDecl, 697 unsigned SequenceNumber) 698 : ClassTemplateSpecializationDecl(Context, 699 ClassTemplatePartialSpecialization, 700 TK, DC, StartLoc, IdLoc, 701 SpecializedTemplate, 702 Args, NumArgs, PrevDecl), 703 TemplateParams(Params), ArgsAsWritten(ArgInfos), 704 NumArgsAsWritten(NumArgInfos), SequenceNumber(SequenceNumber), 705 InstantiatedFromMember(0, false) 706 { 707 AdoptTemplateParameterList(Params, this); 708 } 709 710 ClassTemplatePartialSpecializationDecl * 711 ClassTemplatePartialSpecializationDecl:: 712 Create(ASTContext &Context, TagKind TK,DeclContext *DC, 713 SourceLocation StartLoc, SourceLocation IdLoc, 714 TemplateParameterList *Params, 715 ClassTemplateDecl *SpecializedTemplate, 716 const TemplateArgument *Args, 717 unsigned NumArgs, 718 const TemplateArgumentListInfo &ArgInfos, 719 QualType CanonInjectedType, 720 ClassTemplatePartialSpecializationDecl *PrevDecl, 721 unsigned SequenceNumber) { 722 unsigned N = ArgInfos.size(); 723 TemplateArgumentLoc *ClonedArgs = new (Context) TemplateArgumentLoc[N]; 724 for (unsigned I = 0; I != N; ++I) 725 ClonedArgs[I] = ArgInfos[I]; 726 727 ClassTemplatePartialSpecializationDecl *Result 728 = new (Context)ClassTemplatePartialSpecializationDecl(Context, TK, DC, 729 StartLoc, IdLoc, 730 Params, 731 SpecializedTemplate, 732 Args, NumArgs, 733 ClonedArgs, N, 734 PrevDecl, 735 SequenceNumber); 736 Result->setSpecializationKind(TSK_ExplicitSpecialization); 737 738 Context.getInjectedClassNameType(Result, CanonInjectedType); 739 return Result; 740 } 741 742 ClassTemplatePartialSpecializationDecl * 743 ClassTemplatePartialSpecializationDecl::Create(ASTContext &Context, 744 EmptyShell Empty) { 745 return new (Context)ClassTemplatePartialSpecializationDecl(); 746 } 747 748 //===----------------------------------------------------------------------===// 749 // FriendTemplateDecl Implementation 750 //===----------------------------------------------------------------------===// 751 752 FriendTemplateDecl *FriendTemplateDecl::Create(ASTContext &Context, 753 DeclContext *DC, 754 SourceLocation L, 755 unsigned NParams, 756 TemplateParameterList **Params, 757 FriendUnion Friend, 758 SourceLocation FLoc) { 759 FriendTemplateDecl *Result 760 = new (Context) FriendTemplateDecl(DC, L, NParams, Params, Friend, FLoc); 761 return Result; 762 } 763 764 FriendTemplateDecl *FriendTemplateDecl::Create(ASTContext &Context, 765 EmptyShell Empty) { 766 return new (Context) FriendTemplateDecl(Empty); 767 } 768 769 //===----------------------------------------------------------------------===// 770 // TypeAliasTemplateDecl Implementation 771 //===----------------------------------------------------------------------===// 772 773 TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C, 774 DeclContext *DC, 775 SourceLocation L, 776 DeclarationName Name, 777 TemplateParameterList *Params, 778 NamedDecl *Decl) { 779 AdoptTemplateParameterList(Params, DC); 780 return new (C) TypeAliasTemplateDecl(DC, L, Name, Params, Decl); 781 } 782 783 TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C, 784 EmptyShell) { 785 return new (C) TypeAliasTemplateDecl(0, SourceLocation(), DeclarationName(), 786 0, 0); 787 } 788 789 void TypeAliasTemplateDecl::DeallocateCommon(void *Ptr) { 790 static_cast<Common *>(Ptr)->~Common(); 791 } 792 RedeclarableTemplateDecl::CommonBase * 793 TypeAliasTemplateDecl::newCommon(ASTContext &C) { 794 Common *CommonPtr = new (C) Common; 795 C.AddDeallocation(DeallocateCommon, CommonPtr); 796 return CommonPtr; 797 } 798 799
