1 //===--- DeclTemplate.cpp - Template Declaration AST Node Implementation --===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the C++ related Decl classes for templates.
12 //===----------------------------------------------------------------------===//
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"
24 using namespace clang;
26 //===----------------------------------------------------------------------===//
27 // TemplateParameterList Implementation
28 //===----------------------------------------------------------------------===//
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];
41 if (!P->isTemplateParameterPack()) {
42 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
43 if (NTTP->getType()->containsUnexpandedParameterPack())
44 ContainsUnexpandedParameterPack = true;
46 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
47 if (TTP->getTemplateParameters()->containsUnexpandedParameterPack())
48 ContainsUnexpandedParameterPack = true;
50 // FIXME: If a default argument contains an unexpanded parameter pack, the
51 // template parameter list does too.
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);
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();
74 if ((*P)->isTemplateParameterPack()) {
75 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P))
76 if (NTTP->isExpandedParameterPack()) {
77 NumRequiredArgs += NTTP->getNumExpansionTypes();
84 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
85 if (TTP->hasDefaultArgument())
87 } else if (NonTypeTemplateParmDecl *NTTP
88 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
89 if (NTTP->hasDefaultArgument())
91 } else if (cast<TemplateTemplateParmDecl>(*P)->hasDefaultArgument())
97 return NumRequiredArgs;
100 unsigned TemplateParameterList::getDepth() const {
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();
112 return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
115 static void AdoptTemplateParameterList(TemplateParameterList *Params,
116 DeclContext *Owner) {
117 for (TemplateParameterList::iterator P = Params->begin(),
118 PEnd = Params->end();
120 (*P)->setDeclContext(Owner);
122 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(*P))
123 AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner);
127 //===----------------------------------------------------------------------===//
128 // RedeclarableTemplateDecl Implementation
129 //===----------------------------------------------------------------------===//
131 RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() const {
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()) {
139 Common = Prev->Common;
143 PrevDecls.push_back(Prev);
146 // If we never found a common pointer, allocate one now.
148 // FIXME: If any of the declarations is from an AST file, we probably
149 // need an update record to add the common data.
151 Common = newCommon(getASTContext());
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;
162 template <class EntryType>
163 typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType*
164 RedeclarableTemplateDecl::findSpecializationImpl(
165 llvm::FoldingSetVector<EntryType> &Specs,
166 const TemplateArgument *Args, unsigned NumArgs,
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;
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);
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());
197 if (NTTP->isParameterPack())
198 E = new (Context) PackExpansionExpr(Context.DependentTy, E,
199 NTTP->getLocation(), None);
200 Arg = TemplateArgument(E);
202 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param);
203 if (TTP->isParameterPack())
204 Arg = TemplateArgument(TemplateName(TTP), Optional<unsigned>());
206 Arg = TemplateArgument(TemplateName(TTP));
209 if ((*Param)->isTemplateParameterPack())
210 Arg = TemplateArgument::CreatePackCopy(Context, &Arg, 1);
216 //===----------------------------------------------------------------------===//
217 // FunctionTemplateDecl Implementation
218 //===----------------------------------------------------------------------===//
220 void FunctionTemplateDecl::DeallocateCommon(void *Ptr) {
221 static_cast<Common *>(Ptr)->~Common();
224 FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
227 DeclarationName Name,
228 TemplateParameterList *Params,
230 AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
231 return new (C) FunctionTemplateDecl(DC, L, Name, Params, Decl);
234 FunctionTemplateDecl *FunctionTemplateDecl::CreateDeserialized(ASTContext &C,
236 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FunctionTemplateDecl));
237 return new (Mem) FunctionTemplateDecl(0, SourceLocation(), DeclarationName(),
241 RedeclarableTemplateDecl::CommonBase *
242 FunctionTemplateDecl::newCommon(ASTContext &C) const {
243 Common *CommonPtr = new (C) Common;
244 C.AddDeallocation(DeallocateCommon, CommonPtr);
249 FunctionTemplateDecl::findSpecialization(const TemplateArgument *Args,
250 unsigned NumArgs, void *&InsertPos) {
251 return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos);
254 void FunctionTemplateDecl::addSpecialization(
255 FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
257 getSpecializations().InsertNode(Info, InsertPos);
259 getSpecializations().GetOrInsertNode(Info);
260 if (ASTMutationListener *L = getASTMutationListener())
261 L->AddedCXXTemplateSpecialization(this, Info->Function);
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);
275 return std::make_pair(CommonPtr->InjectedArgs, Params->size());
278 //===----------------------------------------------------------------------===//
279 // ClassTemplateDecl Implementation
280 //===----------------------------------------------------------------------===//
282 void ClassTemplateDecl::DeallocateCommon(void *Ptr) {
283 static_cast<Common *>(Ptr)->~Common();
286 ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
289 DeclarationName Name,
290 TemplateParameterList *Params,
292 ClassTemplateDecl *PrevDecl) {
293 AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
294 ClassTemplateDecl *New = new (C) ClassTemplateDecl(DC, L, Name, Params, Decl);
295 New->setPreviousDeclaration(PrevDecl);
299 ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C,
301 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ClassTemplateDecl));
302 return new (Mem) ClassTemplateDecl(EmptyShell());
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]);
316 llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
317 ClassTemplateDecl::getSpecializations() const {
318 LoadLazySpecializations();
319 return getCommonPtr()->Specializations;
322 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
323 ClassTemplateDecl::getPartialSpecializations() {
324 LoadLazySpecializations();
325 return getCommonPtr()->PartialSpecializations;
328 RedeclarableTemplateDecl::CommonBase *
329 ClassTemplateDecl::newCommon(ASTContext &C) const {
330 Common *CommonPtr = new (C) Common;
331 C.AddDeallocation(DeallocateCommon, CommonPtr);
335 ClassTemplateSpecializationDecl *
336 ClassTemplateDecl::findSpecialization(const TemplateArgument *Args,
337 unsigned NumArgs, void *&InsertPos) {
338 return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos);
341 void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
344 getSpecializations().InsertNode(D, InsertPos);
346 ClassTemplateSpecializationDecl *Existing
347 = getSpecializations().GetOrInsertNode(D);
349 assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
351 if (ASTMutationListener *L = getASTMutationListener())
352 L->AddedCXXTemplateSpecialization(this, D);
355 ClassTemplatePartialSpecializationDecl *
356 ClassTemplateDecl::findPartialSpecialization(const TemplateArgument *Args,
359 return findSpecializationImpl(getPartialSpecializations(), Args, NumArgs,
363 void ClassTemplateDecl::AddPartialSpecialization(
364 ClassTemplatePartialSpecializationDecl *D,
367 getPartialSpecializations().InsertNode(D, InsertPos);
369 ClassTemplatePartialSpecializationDecl *Existing
370 = getPartialSpecializations().GetOrInsertNode(D);
372 assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
375 if (ASTMutationListener *L = getASTMutationListener())
376 L->AddedCXXTemplateSpecialization(this, D);
379 void ClassTemplateDecl::getPartialSpecializations(
380 SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) {
381 llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
382 = getPartialSpecializations();
384 PS.resize(PartialSpecs.size());
385 for (llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>::iterator
386 P = PartialSpecs.begin(), PEnd = PartialSpecs.end();
388 assert(!PS[P->getSequenceNumber()]);
389 PS[P->getSequenceNumber()] = P->getMostRecentDecl();
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();
402 if (Context.hasSameType(P->getInjectedSpecializationType(), T))
403 return P->getMostRecentDecl();
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();
417 if (P->getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
418 return P->getMostRecentDecl();
425 ClassTemplateDecl::getInjectedClassNameSpecialization() {
426 Common *CommonPtr = getCommonPtr();
427 if (!CommonPtr->InjectedClassNameType.isNull())
428 return CommonPtr->InjectedClassNameType;
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
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),
445 TemplateArgs.size());
446 return CommonPtr->InjectedClassNameType;
449 //===----------------------------------------------------------------------===//
450 // TemplateTypeParm Allocation/Deallocation Method Implementations
451 //===----------------------------------------------------------------------===//
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();
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(),
472 SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
473 return hasDefaultArgument()
474 ? DefaultArgument->getTypeLoc().getBeginLoc()
478 SourceRange TemplateTypeParmDecl::getSourceRange() const {
479 if (hasDefaultArgument() && !defaultArgumentWasInherited())
480 return SourceRange(getLocStart(),
481 DefaultArgument->getTypeLoc().getEndLoc());
483 return TypeDecl::getSourceRange();
486 unsigned TemplateTypeParmDecl::getDepth() const {
487 return TypeForDecl->getAs<TemplateTypeParmType>()->getDepth();
490 unsigned TemplateTypeParmDecl::getIndex() const {
491 return TypeForDecl->getAs<TemplateTypeParmType>()->getIndex();
494 bool TemplateTypeParmDecl::isParameterPack() const {
495 return TypeForDecl->getAs<TemplateTypeParmType>()->isParameterPack();
498 //===----------------------------------------------------------------------===//
499 // NonTypeTemplateParmDecl Method Implementations
500 //===----------------------------------------------------------------------===//
502 NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(DeclContext *DC,
503 SourceLocation StartLoc,
504 SourceLocation IdLoc,
505 unsigned D, unsigned P,
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)
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];
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);
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,
550 ExpandedTypes, NumExpandedTypes,
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);
562 NonTypeTemplateParmDecl *
563 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
564 unsigned NumExpandedTypes) {
565 unsigned Size = sizeof(NonTypeTemplateParmDecl)
566 + NumExpandedTypes * 2 * sizeof(void*);
568 void *Mem = AllocateDeserializedDecl(C, ID, Size);
569 return new (Mem) NonTypeTemplateParmDecl(0, SourceLocation(),
570 SourceLocation(), 0, 0, 0,
571 QualType(), 0, 0, NumExpandedTypes,
575 SourceRange NonTypeTemplateParmDecl::getSourceRange() const {
576 if (hasDefaultArgument() && !defaultArgumentWasInherited())
577 return SourceRange(getOuterLocStart(),
578 getDefaultArgument()->getSourceRange().getEnd());
579 return DeclaratorDecl::getSourceRange();
582 SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
583 return hasDefaultArgument()
584 ? getDefaultArgument()->getSourceRange().getBegin()
588 //===----------------------------------------------------------------------===//
589 // TemplateTemplateParmDecl Method Implementations
590 //===----------------------------------------------------------------------===//
592 void TemplateTemplateParmDecl::anchor() { }
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) {
603 std::memcpy(reinterpret_cast<void*>(this + 1), Expansions,
604 sizeof(TemplateParameterList*) * NumExpandedParams);
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,
616 TemplateTemplateParmDecl *
617 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
618 SourceLocation L, unsigned D, unsigned P,
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,
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,
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,
646 //===----------------------------------------------------------------------===//
647 // TemplateArgumentList Implementation
648 //===----------------------------------------------------------------------===//
649 TemplateArgumentList *
650 TemplateArgumentList::CreateCopy(ASTContext &Context,
651 const TemplateArgument *Args,
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);
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);
675 return new (C) FunctionTemplateSpecializationInfo(FD, Template, TSK,
681 //===----------------------------------------------------------------------===//
682 // TemplateDecl Implementation
683 //===----------------------------------------------------------------------===//
685 void TemplateDecl::anchor() { }
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,
697 ClassTemplateSpecializationDecl *PrevDecl)
698 : CXXRecordDecl(DK, TK, DC, StartLoc, IdLoc,
699 SpecializedTemplate->getIdentifier(),
701 SpecializedTemplate(SpecializedTemplate),
703 TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args, NumArgs)),
704 SpecializationKind(TSK_Undeclared) {
707 ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(Kind DK)
708 : CXXRecordDecl(DK, TTK_Struct, 0, SourceLocation(), SourceLocation(), 0, 0),
710 SpecializationKind(TSK_Undeclared) {
713 ClassTemplateSpecializationDecl *
714 ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
716 SourceLocation StartLoc,
717 SourceLocation IdLoc,
718 ClassTemplateDecl *SpecializedTemplate,
719 const TemplateArgument *Args,
721 ClassTemplateSpecializationDecl *PrevDecl) {
722 ClassTemplateSpecializationDecl *Result
723 = new (Context)ClassTemplateSpecializationDecl(Context,
724 ClassTemplateSpecialization,
725 TK, DC, StartLoc, IdLoc,
729 Result->MayHaveOutOfDateDef = false;
731 Context.getTypeDeclType(Result, PrevDecl);
735 ClassTemplateSpecializationDecl *
736 ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
738 void *Mem = AllocateDeserializedDecl(C, ID,
739 sizeof(ClassTemplateSpecializationDecl));
740 ClassTemplateSpecializationDecl *Result =
741 new (Mem) ClassTemplateSpecializationDecl(ClassTemplateSpecialization);
742 Result->MayHaveOutOfDateDef = false;
746 void ClassTemplateSpecializationDecl::getNameForDiagnostic(
747 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
748 NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
750 const TemplateArgumentList &TemplateArgs = getTemplateArgs();
751 TemplateSpecializationType::PrintTemplateArgumentList(
752 OS, TemplateArgs.data(), TemplateArgs.size(), Policy);
756 ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
757 if (SpecializedPartialSpecialization *PartialSpec
758 = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
759 return PartialSpec->PartialSpecialization->getSpecializedTemplate();
760 return SpecializedTemplate.get<ClassTemplateDecl*>();
764 ClassTemplateSpecializationDecl::getSourceRange() const {
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();
776 End = getTypeAsWritten()->getTypeLoc().getEndLoc();
777 return SourceRange(Begin, End);
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();
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*>()
802 //===----------------------------------------------------------------------===//
803 // ClassTemplatePartialSpecializationDecl Implementation
804 //===----------------------------------------------------------------------===//
805 void ClassTemplatePartialSpecializationDecl::anchor() { }
807 ClassTemplatePartialSpecializationDecl::
808 ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
810 SourceLocation StartLoc,
811 SourceLocation IdLoc,
812 TemplateParameterList *Params,
813 ClassTemplateDecl *SpecializedTemplate,
814 const TemplateArgument *Args,
816 TemplateArgumentLoc *ArgInfos,
817 unsigned NumArgInfos,
818 ClassTemplatePartialSpecializationDecl *PrevDecl,
819 unsigned SequenceNumber)
820 : ClassTemplateSpecializationDecl(Context,
821 ClassTemplatePartialSpecialization,
822 TK, DC, StartLoc, IdLoc,
824 Args, NumArgs, PrevDecl),
825 TemplateParams(Params), ArgsAsWritten(ArgInfos),
826 NumArgsAsWritten(NumArgInfos), SequenceNumber(SequenceNumber),
827 InstantiatedFromMember(0, false)
829 AdoptTemplateParameterList(Params, this);
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,
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];
849 ClassTemplatePartialSpecializationDecl *Result
850 = new (Context)ClassTemplatePartialSpecializationDecl(Context, TK, DC,
858 Result->setSpecializationKind(TSK_ExplicitSpecialization);
859 Result->MayHaveOutOfDateDef = false;
861 Context.getInjectedClassNameType(Result, CanonInjectedType);
865 ClassTemplatePartialSpecializationDecl *
866 ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
868 void *Mem = AllocateDeserializedDecl(C, ID,
869 sizeof(ClassTemplatePartialSpecializationDecl));
870 ClassTemplatePartialSpecializationDecl *Result
871 = new (Mem) ClassTemplatePartialSpecializationDecl();
872 Result->MayHaveOutOfDateDef = false;
876 //===----------------------------------------------------------------------===//
877 // FriendTemplateDecl Implementation
878 //===----------------------------------------------------------------------===//
880 void FriendTemplateDecl::anchor() { }
882 FriendTemplateDecl *FriendTemplateDecl::Create(ASTContext &Context,
886 TemplateParameterList **Params,
888 SourceLocation FLoc) {
889 FriendTemplateDecl *Result
890 = new (Context) FriendTemplateDecl(DC, L, NParams, Params, Friend, FLoc);
894 FriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C,
896 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FriendTemplateDecl));
897 return new (Mem) FriendTemplateDecl(EmptyShell());
900 //===----------------------------------------------------------------------===//
901 // TypeAliasTemplateDecl Implementation
902 //===----------------------------------------------------------------------===//
904 TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C,
907 DeclarationName Name,
908 TemplateParameterList *Params,
910 AdoptTemplateParameterList(Params, DC);
911 return new (C) TypeAliasTemplateDecl(DC, L, Name, Params, Decl);
914 TypeAliasTemplateDecl *TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C,
916 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(TypeAliasTemplateDecl));
917 return new (Mem) TypeAliasTemplateDecl(0, SourceLocation(), DeclarationName(),
921 void TypeAliasTemplateDecl::DeallocateCommon(void *Ptr) {
922 static_cast<Common *>(Ptr)->~Common();
924 RedeclarableTemplateDecl::CommonBase *
925 TypeAliasTemplateDecl::newCommon(ASTContext &C) const {
926 Common *CommonPtr = new (C) Common;
927 C.AddDeallocation(DeallocateCommon, CommonPtr);
931 //===----------------------------------------------------------------------===//
932 // ClassScopeFunctionSpecializationDecl Implementation
933 //===----------------------------------------------------------------------===//
935 void ClassScopeFunctionSpecializationDecl::anchor() { }
937 ClassScopeFunctionSpecializationDecl *
938 ClassScopeFunctionSpecializationDecl::CreateDeserialized(ASTContext &C,
940 void *Mem = AllocateDeserializedDecl(C, ID,
941 sizeof(ClassScopeFunctionSpecializationDecl));
942 return new (Mem) ClassScopeFunctionSpecializationDecl(0, SourceLocation(), 0,
943 false, TemplateArgumentListInfo());