blob: 2755a9e23021b1cfebf1e85824afaed20bd5257b [file] [log] [blame]
Sebastian Redl06a59bb2009-10-23 22:13:42 +00001//===--- DeclTemplate.cpp - Template Declaration AST Node Implementation --===//
Douglas Gregoraaba5e32009-02-04 19:02:06 +00002//
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"
Douglas Gregor55f6b142009-02-09 18:46:07 +000016#include "clang/AST/Expr.h"
Douglas Gregorb95cc972011-01-04 02:33:52 +000017#include "clang/AST/ExprCXX.h"
Douglas Gregoraaba5e32009-02-04 19:02:06 +000018#include "clang/AST/ASTContext.h"
John McCall833ca992009-10-29 08:12:44 +000019#include "clang/AST/TypeLoc.h"
Argyrios Kyrtzidisbef1a7b2010-10-28 07:38:42 +000020#include "clang/AST/ASTMutationListener.h"
Douglas Gregoraaba5e32009-02-04 19:02:06 +000021#include "clang/Basic/IdentifierTable.h"
22#include "llvm/ADT/STLExtras.h"
Douglas Gregor910f8002010-11-07 23:05:16 +000023#include <memory>
Douglas Gregoraaba5e32009-02-04 19:02:06 +000024using namespace clang;
25
26//===----------------------------------------------------------------------===//
27// TemplateParameterList Implementation
28//===----------------------------------------------------------------------===//
29
Douglas Gregorddc29e12009-02-06 22:42:48 +000030TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc,
31 SourceLocation LAngleLoc,
Douglas Gregorbf4ea562009-09-15 16:23:51 +000032 NamedDecl **Params, unsigned NumParams,
Douglas Gregorddc29e12009-02-06 22:42:48 +000033 SourceLocation RAngleLoc)
34 : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
35 NumParams(NumParams) {
Douglas Gregoraaba5e32009-02-04 19:02:06 +000036 for (unsigned Idx = 0; Idx < NumParams; ++Idx)
37 begin()[Idx] = Params[Idx];
38}
39
40TemplateParameterList *
Douglas Gregorddc29e12009-02-06 22:42:48 +000041TemplateParameterList::Create(ASTContext &C, SourceLocation TemplateLoc,
Douglas Gregorbf4ea562009-09-15 16:23:51 +000042 SourceLocation LAngleLoc, NamedDecl **Params,
Douglas Gregorddc29e12009-02-06 22:42:48 +000043 unsigned NumParams, SourceLocation RAngleLoc) {
Douglas Gregorbf4ea562009-09-15 16:23:51 +000044 unsigned Size = sizeof(TemplateParameterList)
45 + sizeof(NamedDecl *) * NumParams;
Douglas Gregoraaba5e32009-02-04 19:02:06 +000046 unsigned Align = llvm::AlignOf<TemplateParameterList>::Alignment;
47 void *Mem = C.Allocate(Size, Align);
Mike Stump1eb44332009-09-09 15:08:12 +000048 return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params,
Douglas Gregorddc29e12009-02-06 22:42:48 +000049 NumParams, RAngleLoc);
Douglas Gregoraaba5e32009-02-04 19:02:06 +000050}
51
Douglas Gregor62cb18d2009-02-11 18:16:40 +000052unsigned TemplateParameterList::getMinRequiredArguments() const {
53 unsigned NumRequiredArgs = size();
Mike Stump1eb44332009-09-09 15:08:12 +000054 iterator Param = const_cast<TemplateParameterList *>(this)->end(),
Douglas Gregor62cb18d2009-02-11 18:16:40 +000055 ParamBegin = const_cast<TemplateParameterList *>(this)->begin();
56 while (Param != ParamBegin) {
57 --Param;
Mike Stump1eb44332009-09-09 15:08:12 +000058
Anders Carlsson0ceffb52009-06-13 02:08:00 +000059 if (!(*Param)->isTemplateParameterPack() &&
Mike Stump1eb44332009-09-09 15:08:12 +000060 !(isa<TemplateTypeParmDecl>(*Param) &&
Douglas Gregor62cb18d2009-02-11 18:16:40 +000061 cast<TemplateTypeParmDecl>(*Param)->hasDefaultArgument()) &&
62 !(isa<NonTypeTemplateParmDecl>(*Param) &&
63 cast<NonTypeTemplateParmDecl>(*Param)->hasDefaultArgument()) &&
64 !(isa<TemplateTemplateParmDecl>(*Param) &&
65 cast<TemplateTemplateParmDecl>(*Param)->hasDefaultArgument()))
66 break;
Mike Stump1eb44332009-09-09 15:08:12 +000067
Douglas Gregor62cb18d2009-02-11 18:16:40 +000068 --NumRequiredArgs;
69 }
70
71 return NumRequiredArgs;
72}
73
Douglas Gregored9c0f92009-10-29 00:04:11 +000074unsigned TemplateParameterList::getDepth() const {
75 if (size() == 0)
76 return 0;
77
78 const NamedDecl *FirstParm = getParam(0);
79 if (const TemplateTypeParmDecl *TTP
80 = dyn_cast<TemplateTypeParmDecl>(FirstParm))
81 return TTP->getDepth();
82 else if (const NonTypeTemplateParmDecl *NTTP
83 = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
84 return NTTP->getDepth();
85 else
86 return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
87}
88
Douglas Gregoraaba5e32009-02-04 19:02:06 +000089//===----------------------------------------------------------------------===//
Peter Collingbourne9eabeba2010-07-29 16:11:51 +000090// RedeclarableTemplateDecl Implementation
91//===----------------------------------------------------------------------===//
92
93RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() {
94 // Find the first declaration of this function template.
95 RedeclarableTemplateDecl *First = getCanonicalDecl();
96
97 if (First->CommonOrPrev.isNull()) {
Argyrios Kyrtzidis6b541512010-09-08 19:31:22 +000098 CommonBase *CommonPtr = First->newCommon(getASTContext());
Peter Collingbourne9eabeba2010-07-29 16:11:51 +000099 First->CommonOrPrev = CommonPtr;
Peter Collingbourne8a798a72010-07-29 16:12:01 +0000100 CommonPtr->Latest = First;
Peter Collingbourne9eabeba2010-07-29 16:11:51 +0000101 }
102 return First->CommonOrPrev.get<CommonBase*>();
103}
104
105
106RedeclarableTemplateDecl *RedeclarableTemplateDecl::getCanonicalDeclImpl() {
107 RedeclarableTemplateDecl *Tmpl = this;
108 while (Tmpl->getPreviousDeclaration())
109 Tmpl = Tmpl->getPreviousDeclaration();
110 return Tmpl;
111}
112
Peter Collingbourne8a798a72010-07-29 16:12:01 +0000113void RedeclarableTemplateDecl::setPreviousDeclarationImpl(
114 RedeclarableTemplateDecl *Prev) {
115 if (Prev) {
116 CommonBase *Common = Prev->getCommonPtr();
117 Prev = Common->Latest;
118 Common->Latest = this;
119 CommonOrPrev = Prev;
120 } else {
121 assert(CommonOrPrev.is<CommonBase*>() && "Cannot reset TemplateDecl Prev");
122 }
123}
124
Peter Collingbournef88718e2010-07-29 16:12:09 +0000125RedeclarableTemplateDecl *RedeclarableTemplateDecl::getNextRedeclaration() {
126 if (CommonOrPrev.is<RedeclarableTemplateDecl*>())
127 return CommonOrPrev.get<RedeclarableTemplateDecl*>();
128 CommonBase *Common = CommonOrPrev.get<CommonBase*>();
129 return Common ? Common->Latest : this;
130}
131
Peter Collingbourne40485902010-07-30 17:09:04 +0000132template <class EntryType>
133typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType*
134RedeclarableTemplateDecl::findSpecializationImpl(
135 llvm::FoldingSet<EntryType> &Specs,
136 const TemplateArgument *Args, unsigned NumArgs,
137 void *&InsertPos) {
138 typedef SpecEntryTraits<EntryType> SETraits;
139 llvm::FoldingSetNodeID ID;
140 EntryType::Profile(ID,Args,NumArgs, getASTContext());
141 EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos);
142 return Entry ? SETraits::getMostRecentDeclaration(Entry) : 0;
143}
144
Peter Collingbourne9eabeba2010-07-29 16:11:51 +0000145//===----------------------------------------------------------------------===//
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000146// FunctionTemplateDecl Implementation
147//===----------------------------------------------------------------------===//
148
Douglas Gregor00545312010-05-23 18:26:36 +0000149void FunctionTemplateDecl::DeallocateCommon(void *Ptr) {
150 static_cast<Common *>(Ptr)->~Common();
151}
152
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000153FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
154 DeclContext *DC,
155 SourceLocation L,
156 DeclarationName Name,
Douglas Gregor127102b2009-06-29 20:59:39 +0000157 TemplateParameterList *Params,
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000158 NamedDecl *Decl) {
159 return new (C) FunctionTemplateDecl(DC, L, Name, Params, Decl);
160}
161
Argyrios Kyrtzidis6b541512010-09-08 19:31:22 +0000162RedeclarableTemplateDecl::CommonBase *
163FunctionTemplateDecl::newCommon(ASTContext &C) {
164 Common *CommonPtr = new (C) Common;
165 C.AddDeallocation(DeallocateCommon, CommonPtr);
Peter Collingbourne9eabeba2010-07-29 16:11:51 +0000166 return CommonPtr;
167}
168
Argyrios Kyrtzidis2c853e42010-07-20 13:59:58 +0000169FunctionDecl *
170FunctionTemplateDecl::findSpecialization(const TemplateArgument *Args,
171 unsigned NumArgs, void *&InsertPos) {
Peter Collingbourne40485902010-07-30 17:09:04 +0000172 return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos);
Argyrios Kyrtzidis2c853e42010-07-20 13:59:58 +0000173}
174
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000175//===----------------------------------------------------------------------===//
176// ClassTemplateDecl Implementation
177//===----------------------------------------------------------------------===//
178
Douglas Gregor00545312010-05-23 18:26:36 +0000179void ClassTemplateDecl::DeallocateCommon(void *Ptr) {
180 static_cast<Common *>(Ptr)->~Common();
181}
182
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000183ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
184 DeclContext *DC,
185 SourceLocation L,
186 DeclarationName Name,
187 TemplateParameterList *Params,
Douglas Gregor5953d8b2009-03-19 17:26:29 +0000188 NamedDecl *Decl,
189 ClassTemplateDecl *PrevDecl) {
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +0000190 ClassTemplateDecl *New = new (C) ClassTemplateDecl(DC, L, Name, Params, Decl);
Argyrios Kyrtzidis5bf1bdc2010-06-21 10:57:41 +0000191 New->setPreviousDeclaration(PrevDecl);
Argyrios Kyrtzidis8731ca72010-06-19 19:29:09 +0000192 return New;
Douglas Gregor5953d8b2009-03-19 17:26:29 +0000193}
194
Douglas Gregorc8e5cf82010-10-27 22:21:36 +0000195void ClassTemplateDecl::LoadLazySpecializations() {
196 Common *CommonPtr = getCommonPtr();
197 if (CommonPtr->LazySpecializations) {
198 ASTContext &Context = getASTContext();
199 uint32_t *Specs = CommonPtr->LazySpecializations;
200 CommonPtr->LazySpecializations = 0;
201 for (uint32_t I = 0, N = *Specs++; I != N; ++I)
202 (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
203 }
204}
205
206llvm::FoldingSet<ClassTemplateSpecializationDecl> &
207ClassTemplateDecl::getSpecializations() {
208 LoadLazySpecializations();
209 return getCommonPtr()->Specializations;
210}
211
212llvm::FoldingSet<ClassTemplatePartialSpecializationDecl> &
213ClassTemplateDecl::getPartialSpecializations() {
214 LoadLazySpecializations();
215 return getCommonPtr()->PartialSpecializations;
216}
217
Argyrios Kyrtzidis6b541512010-09-08 19:31:22 +0000218RedeclarableTemplateDecl::CommonBase *
219ClassTemplateDecl::newCommon(ASTContext &C) {
220 Common *CommonPtr = new (C) Common;
221 C.AddDeallocation(DeallocateCommon, CommonPtr);
Peter Collingbourne9eabeba2010-07-29 16:11:51 +0000222 return CommonPtr;
223}
224
Argyrios Kyrtzidiscc0b1bc2010-07-20 13:59:28 +0000225ClassTemplateSpecializationDecl *
226ClassTemplateDecl::findSpecialization(const TemplateArgument *Args,
227 unsigned NumArgs, void *&InsertPos) {
Peter Collingbourne40485902010-07-30 17:09:04 +0000228 return findSpecializationImpl(getSpecializations(), Args, NumArgs, InsertPos);
Argyrios Kyrtzidiscc0b1bc2010-07-20 13:59:28 +0000229}
230
Argyrios Kyrtzidisbef1a7b2010-10-28 07:38:42 +0000231void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
232 void *InsertPos) {
233 getSpecializations().InsertNode(D, InsertPos);
234 if (ASTMutationListener *L = getASTMutationListener())
235 L->AddedCXXTemplateSpecialization(this, D);
236}
237
Argyrios Kyrtzidiscc0b1bc2010-07-20 13:59:28 +0000238ClassTemplatePartialSpecializationDecl *
239ClassTemplateDecl::findPartialSpecialization(const TemplateArgument *Args,
240 unsigned NumArgs,
241 void *&InsertPos) {
Peter Collingbourne40485902010-07-30 17:09:04 +0000242 return findSpecializationImpl(getPartialSpecializations(), Args, NumArgs,
243 InsertPos);
Argyrios Kyrtzidiscc0b1bc2010-07-20 13:59:28 +0000244}
245
Argyrios Kyrtzidisbef1a7b2010-10-28 07:38:42 +0000246void ClassTemplateDecl::AddPartialSpecialization(
247 ClassTemplatePartialSpecializationDecl *D,
248 void *InsertPos) {
249 getPartialSpecializations().InsertNode(D, InsertPos);
250 if (ASTMutationListener *L = getASTMutationListener())
251 L->AddedCXXTemplateSpecialization(this, D);
252}
253
Douglas Gregordc60c1e2010-04-30 05:56:50 +0000254void ClassTemplateDecl::getPartialSpecializations(
255 llvm::SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) {
256 llvm::FoldingSet<ClassTemplatePartialSpecializationDecl> &PartialSpecs
Argyrios Kyrtzidis5bf1bdc2010-06-21 10:57:41 +0000257 = getPartialSpecializations();
Douglas Gregordc60c1e2010-04-30 05:56:50 +0000258 PS.clear();
259 PS.resize(PartialSpecs.size());
260 for (llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator
261 P = PartialSpecs.begin(), PEnd = PartialSpecs.end();
262 P != PEnd; ++P) {
263 assert(!PS[P->getSequenceNumber()]);
Argyrios Kyrtzidiscc0b1bc2010-07-20 13:59:28 +0000264 PS[P->getSequenceNumber()] = P->getMostRecentDeclaration();
Douglas Gregordc60c1e2010-04-30 05:56:50 +0000265 }
266}
267
Douglas Gregorb88e8882009-07-30 17:40:51 +0000268ClassTemplatePartialSpecializationDecl *
269ClassTemplateDecl::findPartialSpecialization(QualType T) {
270 ASTContext &Context = getASTContext();
271 typedef llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator
272 partial_spec_iterator;
273 for (partial_spec_iterator P = getPartialSpecializations().begin(),
274 PEnd = getPartialSpecializations().end();
275 P != PEnd; ++P) {
John McCall31f17ec2010-04-27 00:57:59 +0000276 if (Context.hasSameType(P->getInjectedSpecializationType(), T))
Argyrios Kyrtzidiscc0b1bc2010-07-20 13:59:28 +0000277 return P->getMostRecentDeclaration();
278 }
279
280 return 0;
281}
282
283ClassTemplatePartialSpecializationDecl *
284ClassTemplateDecl::findPartialSpecInstantiatedFromMember(
285 ClassTemplatePartialSpecializationDecl *D) {
286 Decl *DCanon = D->getCanonicalDecl();
287 for (llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator
288 P = getPartialSpecializations().begin(),
289 PEnd = getPartialSpecializations().end();
290 P != PEnd; ++P) {
291 if (P->getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
292 return P->getMostRecentDeclaration();
Douglas Gregorb88e8882009-07-30 17:40:51 +0000293 }
Mike Stump1eb44332009-09-09 15:08:12 +0000294
Douglas Gregorb88e8882009-07-30 17:40:51 +0000295 return 0;
296}
297
John McCall3cb0ebd2010-03-10 03:28:59 +0000298QualType
Douglas Gregor24bae922010-07-08 18:37:38 +0000299ClassTemplateDecl::getInjectedClassNameSpecialization() {
Argyrios Kyrtzidis5bf1bdc2010-06-21 10:57:41 +0000300 Common *CommonPtr = getCommonPtr();
Douglas Gregor7da97d02009-05-10 22:57:19 +0000301 if (!CommonPtr->InjectedClassNameType.isNull())
302 return CommonPtr->InjectedClassNameType;
303
Douglas Gregorb7d09d62010-12-23 16:00:30 +0000304 // C++0x [temp.dep.type]p2:
305 // The template argument list of a primary template is a template argument
306 // list in which the nth template argument has the value of the nth template
307 // parameter of the class template. If the nth template parameter is a
308 // template parameter pack (14.5.3), the nth template argument is a pack
309 // expansion (14.5.3) whose pattern is the name of the template parameter
310 // pack.
Douglas Gregor24bae922010-07-08 18:37:38 +0000311 ASTContext &Context = getASTContext();
Douglas Gregor7da97d02009-05-10 22:57:19 +0000312 TemplateParameterList *Params = getTemplateParameters();
Douglas Gregor7da97d02009-05-10 22:57:19 +0000313 llvm::SmallVector<TemplateArgument, 16> TemplateArgs;
Douglas Gregor7da97d02009-05-10 22:57:19 +0000314 TemplateArgs.reserve(Params->size());
Mike Stump1eb44332009-09-09 15:08:12 +0000315 for (TemplateParameterList::iterator Param = Params->begin(),
316 ParamEnd = Params->end();
Douglas Gregor7da97d02009-05-10 22:57:19 +0000317 Param != ParamEnd; ++Param) {
Douglas Gregorb7d09d62010-12-23 16:00:30 +0000318 TemplateArgument Arg;
319 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
320 QualType ArgType = Context.getTypeDeclType(TTP);
321 if (TTP->isParameterPack())
322 ArgType = Context.getPackExpansionType(ArgType);
323
324 Arg = TemplateArgument(ArgType);
Mike Stump1eb44332009-09-09 15:08:12 +0000325 } else if (NonTypeTemplateParmDecl *NTTP =
Douglas Gregor7da97d02009-05-10 22:57:19 +0000326 dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
Chandler Carruthb7de1812010-01-31 07:24:03 +0000327 Expr *E = new (Context) DeclRefExpr(NTTP,
Douglas Gregor63982352010-07-13 18:40:04 +0000328 NTTP->getType().getNonLValueExprType(Context),
John McCallf89e55a2010-11-18 06:31:45 +0000329 Expr::getValueKindForType(NTTP->getType()),
Douglas Gregor0da76df2009-11-23 11:41:28 +0000330 NTTP->getLocation());
Douglas Gregorb95cc972011-01-04 02:33:52 +0000331
332 if (NTTP->isParameterPack())
333 E = new (Context) PackExpansionExpr(Context.DependentTy, E,
334 NTTP->getLocation());
Douglas Gregorb7d09d62010-12-23 16:00:30 +0000335 Arg = TemplateArgument(E);
Mike Stump1eb44332009-09-09 15:08:12 +0000336 } else {
Douglas Gregor7da97d02009-05-10 22:57:19 +0000337 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param);
Douglas Gregorb7d09d62010-12-23 16:00:30 +0000338 // FIXME: Variadic templates.
339 Arg = TemplateArgument(TemplateName(TTP));
Douglas Gregor7da97d02009-05-10 22:57:19 +0000340 }
Douglas Gregorb7d09d62010-12-23 16:00:30 +0000341
342 if ((*Param)->isTemplateParameterPack()) {
343 TemplateArgument *Pack = new (Context) TemplateArgument [1];
344 *Pack = Arg;
345 Arg = TemplateArgument(Pack, 1);
346 }
347
348 TemplateArgs.push_back(Arg);
Douglas Gregor7da97d02009-05-10 22:57:19 +0000349 }
350
Douglas Gregor7da97d02009-05-10 22:57:19 +0000351 CommonPtr->InjectedClassNameType
Douglas Gregor1275ae02009-07-28 23:00:59 +0000352 = Context.getTemplateSpecializationType(TemplateName(this),
Douglas Gregor7da97d02009-05-10 22:57:19 +0000353 &TemplateArgs[0],
Douglas Gregor1275ae02009-07-28 23:00:59 +0000354 TemplateArgs.size());
Douglas Gregor7da97d02009-05-10 22:57:19 +0000355 return CommonPtr->InjectedClassNameType;
356}
357
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000358//===----------------------------------------------------------------------===//
359// TemplateTypeParm Allocation/Deallocation Method Implementations
360//===----------------------------------------------------------------------===//
361
362TemplateTypeParmDecl *
363TemplateTypeParmDecl::Create(ASTContext &C, DeclContext *DC,
364 SourceLocation L, unsigned D, unsigned P,
Anders Carlsson6d845ae2009-06-12 22:23:22 +0000365 IdentifierInfo *Id, bool Typename,
366 bool ParameterPack) {
Douglas Gregorefed5c82010-06-16 15:23:05 +0000367 QualType Type = C.getTemplateTypeParmType(D, P, ParameterPack, Id);
368 return new (C) TemplateTypeParmDecl(DC, L, Id, Typename, Type, ParameterPack);
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000369}
370
Argyrios Kyrtzidisb8b03e62010-07-02 11:54:55 +0000371TemplateTypeParmDecl *
372TemplateTypeParmDecl::Create(ASTContext &C, EmptyShell Empty) {
373 return new (C) TemplateTypeParmDecl(0, SourceLocation(), 0, false,
374 QualType(), false);
375}
376
John McCall833ca992009-10-29 08:12:44 +0000377SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
Abramo Bagnarabd054db2010-05-20 10:00:11 +0000378 return DefaultArgument->getTypeLoc().getSourceRange().getBegin();
John McCall833ca992009-10-29 08:12:44 +0000379}
380
Douglas Gregored9c0f92009-10-29 00:04:11 +0000381unsigned TemplateTypeParmDecl::getDepth() const {
382 return TypeForDecl->getAs<TemplateTypeParmType>()->getDepth();
383}
384
385unsigned TemplateTypeParmDecl::getIndex() const {
386 return TypeForDecl->getAs<TemplateTypeParmType>()->getIndex();
387}
388
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000389//===----------------------------------------------------------------------===//
390// NonTypeTemplateParmDecl Method Implementations
391//===----------------------------------------------------------------------===//
392
393NonTypeTemplateParmDecl *
394NonTypeTemplateParmDecl::Create(ASTContext &C, DeclContext *DC,
395 SourceLocation L, unsigned D, unsigned P,
396 IdentifierInfo *Id, QualType T,
Douglas Gregor10738d32010-12-23 23:51:58 +0000397 bool ParameterPack, TypeSourceInfo *TInfo) {
398 return new (C) NonTypeTemplateParmDecl(DC, L, D, P, Id, T, ParameterPack,
399 TInfo);
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000400}
401
Douglas Gregord684b002009-02-10 19:49:53 +0000402SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
Abramo Bagnarad92f7a22010-06-09 09:26:05 +0000403 return hasDefaultArgument()
404 ? getDefaultArgument()->getSourceRange().getBegin()
405 : SourceLocation();
Douglas Gregord684b002009-02-10 19:49:53 +0000406}
407
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000408//===----------------------------------------------------------------------===//
409// TemplateTemplateParmDecl Method Implementations
410//===----------------------------------------------------------------------===//
411
412TemplateTemplateParmDecl *
413TemplateTemplateParmDecl::Create(ASTContext &C, DeclContext *DC,
414 SourceLocation L, unsigned D, unsigned P,
Douglas Gregor61c4d282011-01-05 15:48:55 +0000415 bool ParameterPack, IdentifierInfo *Id,
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000416 TemplateParameterList *Params) {
Douglas Gregor61c4d282011-01-05 15:48:55 +0000417 return new (C) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
418 Params);
Douglas Gregoraaba5e32009-02-04 19:02:06 +0000419}
420
Douglas Gregor3e00bad2009-02-17 01:05:43 +0000421//===----------------------------------------------------------------------===//
Douglas Gregor7e063902009-05-11 23:53:27 +0000422// TemplateArgumentList Implementation
423//===----------------------------------------------------------------------===//
Douglas Gregor910f8002010-11-07 23:05:16 +0000424TemplateArgumentList *
425TemplateArgumentList::CreateCopy(ASTContext &Context,
426 const TemplateArgument *Args,
427 unsigned NumArgs) {
428 std::size_t Size = sizeof(TemplateArgumentList)
429 + NumArgs * sizeof(TemplateArgument);
430 void *Mem = Context.Allocate(Size);
431 TemplateArgument *StoredArgs
432 = reinterpret_cast<TemplateArgument *>(
433 static_cast<TemplateArgumentList *>(Mem) + 1);
434 std::uninitialized_copy(Args, Args + NumArgs, StoredArgs);
435 return new (Mem) TemplateArgumentList(StoredArgs, NumArgs, true);
Argyrios Kyrtzidis94d228d2010-06-23 13:48:23 +0000436}
437
Douglas Gregor7e063902009-05-11 23:53:27 +0000438//===----------------------------------------------------------------------===//
Douglas Gregor3e00bad2009-02-17 01:05:43 +0000439// ClassTemplateSpecializationDecl Implementation
440//===----------------------------------------------------------------------===//
441ClassTemplateSpecializationDecl::
Douglas Gregor13c85772010-05-06 00:28:52 +0000442ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
Douglas Gregor7e063902009-05-11 23:53:27 +0000443 DeclContext *DC, SourceLocation L,
Douglas Gregor3e00bad2009-02-17 01:05:43 +0000444 ClassTemplateDecl *SpecializedTemplate,
Douglas Gregor910f8002010-11-07 23:05:16 +0000445 const TemplateArgument *Args,
446 unsigned NumArgs,
Douglas Gregor8e9e9ef2009-07-29 23:36:44 +0000447 ClassTemplateSpecializationDecl *PrevDecl)
Douglas Gregor13c85772010-05-06 00:28:52 +0000448 : CXXRecordDecl(DK, TK, DC, L,
Douglas Gregor8e9e9ef2009-07-29 23:36:44 +0000449 SpecializedTemplate->getIdentifier(),
450 PrevDecl),
Douglas Gregor3e00bad2009-02-17 01:05:43 +0000451 SpecializedTemplate(SpecializedTemplate),
Abramo Bagnarac98971d2010-06-12 07:44:57 +0000452 ExplicitInfo(0),
Douglas Gregor910f8002010-11-07 23:05:16 +0000453 TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args, NumArgs)),
Douglas Gregor7e063902009-05-11 23:53:27 +0000454 SpecializationKind(TSK_Undeclared) {
Douglas Gregor3e00bad2009-02-17 01:05:43 +0000455}
Mike Stump1eb44332009-09-09 15:08:12 +0000456
Argyrios Kyrtzidis94d228d2010-06-23 13:48:23 +0000457ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(Kind DK)
458 : CXXRecordDecl(DK, TTK_Struct, 0, SourceLocation(), 0, 0),
459 ExplicitInfo(0),
460 SpecializationKind(TSK_Undeclared) {
461}
462
Douglas Gregor3e00bad2009-02-17 01:05:43 +0000463ClassTemplateSpecializationDecl *
Douglas Gregor13c85772010-05-06 00:28:52 +0000464ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
Douglas Gregor3e00bad2009-02-17 01:05:43 +0000465 DeclContext *DC, SourceLocation L,
466 ClassTemplateDecl *SpecializedTemplate,
Douglas Gregor910f8002010-11-07 23:05:16 +0000467 const TemplateArgument *Args,
468 unsigned NumArgs,
Douglas Gregorcc636682009-02-17 23:15:12 +0000469 ClassTemplateSpecializationDecl *PrevDecl) {
Douglas Gregorcc636682009-02-17 23:15:12 +0000470 ClassTemplateSpecializationDecl *Result
Mike Stump1eb44332009-09-09 15:08:12 +0000471 = new (Context)ClassTemplateSpecializationDecl(Context,
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000472 ClassTemplateSpecialization,
Douglas Gregor13c85772010-05-06 00:28:52 +0000473 TK, DC, L,
Douglas Gregor7e063902009-05-11 23:53:27 +0000474 SpecializedTemplate,
Douglas Gregor910f8002010-11-07 23:05:16 +0000475 Args, NumArgs,
Douglas Gregor8e9e9ef2009-07-29 23:36:44 +0000476 PrevDecl);
Douglas Gregorcc636682009-02-17 23:15:12 +0000477 Context.getTypeDeclType(Result, PrevDecl);
478 return Result;
Douglas Gregor3e00bad2009-02-17 01:05:43 +0000479}
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000480
Argyrios Kyrtzidis94d228d2010-06-23 13:48:23 +0000481ClassTemplateSpecializationDecl *
Argyrios Kyrtzidisb8b03e62010-07-02 11:54:55 +0000482ClassTemplateSpecializationDecl::Create(ASTContext &Context, EmptyShell Empty) {
Argyrios Kyrtzidis94d228d2010-06-23 13:48:23 +0000483 return
484 new (Context)ClassTemplateSpecializationDecl(ClassTemplateSpecialization);
485}
486
John McCall136a6982009-09-11 06:45:03 +0000487void
488ClassTemplateSpecializationDecl::getNameForDiagnostic(std::string &S,
489 const PrintingPolicy &Policy,
490 bool Qualified) const {
491 NamedDecl::getNameForDiagnostic(S, Policy, Qualified);
492
493 const TemplateArgumentList &TemplateArgs = getTemplateArgs();
494 S += TemplateSpecializationType::PrintTemplateArgumentList(
Douglas Gregor910f8002010-11-07 23:05:16 +0000495 TemplateArgs.data(),
496 TemplateArgs.size(),
John McCall136a6982009-09-11 06:45:03 +0000497 Policy);
498}
499
Douglas Gregor37d93e92009-08-02 23:24:31 +0000500ClassTemplateDecl *
Mike Stump1eb44332009-09-09 15:08:12 +0000501ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
502 if (SpecializedPartialSpecialization *PartialSpec
Douglas Gregor37d93e92009-08-02 23:24:31 +0000503 = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
504 return PartialSpec->PartialSpecialization->getSpecializedTemplate();
505 return SpecializedTemplate.get<ClassTemplateDecl*>();
506}
507
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000508//===----------------------------------------------------------------------===//
509// ClassTemplatePartialSpecializationDecl Implementation
510//===----------------------------------------------------------------------===//
511ClassTemplatePartialSpecializationDecl *
512ClassTemplatePartialSpecializationDecl::
Douglas Gregor13c85772010-05-06 00:28:52 +0000513Create(ASTContext &Context, TagKind TK,DeclContext *DC, SourceLocation L,
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000514 TemplateParameterList *Params,
515 ClassTemplateDecl *SpecializedTemplate,
Douglas Gregor910f8002010-11-07 23:05:16 +0000516 const TemplateArgument *Args,
517 unsigned NumArgs,
John McCalld5532b62009-11-23 01:53:49 +0000518 const TemplateArgumentListInfo &ArgInfos,
John McCall3cb0ebd2010-03-10 03:28:59 +0000519 QualType CanonInjectedType,
Douglas Gregordc60c1e2010-04-30 05:56:50 +0000520 ClassTemplatePartialSpecializationDecl *PrevDecl,
521 unsigned SequenceNumber) {
John McCalld5532b62009-11-23 01:53:49 +0000522 unsigned N = ArgInfos.size();
John McCall833ca992009-10-29 08:12:44 +0000523 TemplateArgumentLoc *ClonedArgs = new (Context) TemplateArgumentLoc[N];
524 for (unsigned I = 0; I != N; ++I)
525 ClonedArgs[I] = ArgInfos[I];
526
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000527 ClassTemplatePartialSpecializationDecl *Result
Douglas Gregor13c85772010-05-06 00:28:52 +0000528 = new (Context)ClassTemplatePartialSpecializationDecl(Context, TK,
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000529 DC, L, Params,
530 SpecializedTemplate,
Douglas Gregor910f8002010-11-07 23:05:16 +0000531 Args, NumArgs,
John McCall833ca992009-10-29 08:12:44 +0000532 ClonedArgs, N,
Douglas Gregordc60c1e2010-04-30 05:56:50 +0000533 PrevDecl,
534 SequenceNumber);
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000535 Result->setSpecializationKind(TSK_ExplicitSpecialization);
John McCall3cb0ebd2010-03-10 03:28:59 +0000536
537 Context.getInjectedClassNameType(Result, CanonInjectedType);
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000538 return Result;
539}
John McCalldd4a3b02009-09-16 22:47:08 +0000540
Argyrios Kyrtzidis94d228d2010-06-23 13:48:23 +0000541ClassTemplatePartialSpecializationDecl *
Argyrios Kyrtzidisb8b03e62010-07-02 11:54:55 +0000542ClassTemplatePartialSpecializationDecl::Create(ASTContext &Context,
543 EmptyShell Empty) {
Argyrios Kyrtzidis94d228d2010-06-23 13:48:23 +0000544 return new (Context)ClassTemplatePartialSpecializationDecl();
545}
546
John McCalldd4a3b02009-09-16 22:47:08 +0000547//===----------------------------------------------------------------------===//
548// FriendTemplateDecl Implementation
549//===----------------------------------------------------------------------===//
550
551FriendTemplateDecl *FriendTemplateDecl::Create(ASTContext &Context,
552 DeclContext *DC,
553 SourceLocation L,
554 unsigned NParams,
555 TemplateParameterList **Params,
556 FriendUnion Friend,
557 SourceLocation FLoc) {
558 FriendTemplateDecl *Result
559 = new (Context) FriendTemplateDecl(DC, L, NParams, Params, Friend, FLoc);
560 return Result;
561}
Argyrios Kyrtzidis554e6aa2010-07-22 16:04:10 +0000562
563FriendTemplateDecl *FriendTemplateDecl::Create(ASTContext &Context,
564 EmptyShell Empty) {
565 return new (Context) FriendTemplateDecl(Empty);
566}