1//===--- DeclCXX.cpp - C++ 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/ASTContext.h"
18#include "clang/Basic/IdentifierTable.h"
19#include "llvm/ADT/STLExtras.h"
20using namespace clang;
21
22//===----------------------------------------------------------------------===//
23// TemplateParameterList Implementation
24//===----------------------------------------------------------------------===//
25
26TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc,
27 SourceLocation LAngleLoc,
28 Decl **Params, unsigned NumParams,
29 SourceLocation RAngleLoc)
30 : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
31 NumParams(NumParams) {
32 for (unsigned Idx = 0; Idx < NumParams; ++Idx)
33 begin()[Idx] = Params[Idx];
34}
35
36TemplateParameterList *
37TemplateParameterList::Create(ASTContext &C, SourceLocation TemplateLoc,
38 SourceLocation LAngleLoc, Decl **Params,
39 unsigned NumParams, SourceLocation RAngleLoc) {
40 unsigned Size = sizeof(TemplateParameterList) + sizeof(Decl *) * NumParams;
41 unsigned Align = llvm::AlignOf<TemplateParameterList>::Alignment;
42 void *Mem = C.Allocate(Size, Align);
43 return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params,
44 NumParams, RAngleLoc);
45}
46
47unsigned TemplateParameterList::getMinRequiredArguments() const {
48 unsigned NumRequiredArgs = size();
49 iterator Param = const_cast<TemplateParameterList *>(this)->end(),
50 ParamBegin = const_cast<TemplateParameterList *>(this)->begin();
51 while (Param != ParamBegin) {
52 --Param;
| 1//===--- DeclCXX.cpp - C++ 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/ASTContext.h"
18#include "clang/Basic/IdentifierTable.h"
19#include "llvm/ADT/STLExtras.h"
20using namespace clang;
21
22//===----------------------------------------------------------------------===//
23// TemplateParameterList Implementation
24//===----------------------------------------------------------------------===//
25
26TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc,
27 SourceLocation LAngleLoc,
28 Decl **Params, unsigned NumParams,
29 SourceLocation RAngleLoc)
30 : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
31 NumParams(NumParams) {
32 for (unsigned Idx = 0; Idx < NumParams; ++Idx)
33 begin()[Idx] = Params[Idx];
34}
35
36TemplateParameterList *
37TemplateParameterList::Create(ASTContext &C, SourceLocation TemplateLoc,
38 SourceLocation LAngleLoc, Decl **Params,
39 unsigned NumParams, SourceLocation RAngleLoc) {
40 unsigned Size = sizeof(TemplateParameterList) + sizeof(Decl *) * NumParams;
41 unsigned Align = llvm::AlignOf<TemplateParameterList>::Alignment;
42 void *Mem = C.Allocate(Size, Align);
43 return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params,
44 NumParams, RAngleLoc);
45}
46
47unsigned TemplateParameterList::getMinRequiredArguments() const {
48 unsigned NumRequiredArgs = size();
49 iterator Param = const_cast<TemplateParameterList *>(this)->end(),
50 ParamBegin = const_cast<TemplateParameterList *>(this)->begin();
51 while (Param != ParamBegin) {
52 --Param;
|
53 if (!(isa<TemplateTypeParmDecl>(*Param) &&
| 53
54 if (!(*Param)->isTemplateParameterPack() &&
55 !(isa<TemplateTypeParmDecl>(*Param) &&
|
54 cast<TemplateTypeParmDecl>(*Param)->hasDefaultArgument()) &&
55 !(isa<NonTypeTemplateParmDecl>(*Param) &&
56 cast<NonTypeTemplateParmDecl>(*Param)->hasDefaultArgument()) &&
57 !(isa<TemplateTemplateParmDecl>(*Param) &&
58 cast<TemplateTemplateParmDecl>(*Param)->hasDefaultArgument()))
59 break;
60
61 --NumRequiredArgs;
62 }
63
64 return NumRequiredArgs;
65}
66
67//===----------------------------------------------------------------------===//
68// TemplateDecl Implementation
69//===----------------------------------------------------------------------===//
70
71TemplateDecl::~TemplateDecl() {
72}
73
74//===----------------------------------------------------------------------===//
75// FunctionTemplateDecl Implementation
76//===----------------------------------------------------------------------===//
77
78FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
79 DeclContext *DC,
80 SourceLocation L,
81 DeclarationName Name,
82 TemplateParameterList *Params,
83 NamedDecl *Decl) {
84 return new (C) FunctionTemplateDecl(DC, L, Name, Params, Decl);
85}
86
87//===----------------------------------------------------------------------===//
88// ClassTemplateDecl Implementation
89//===----------------------------------------------------------------------===//
90
91ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
92 DeclContext *DC,
93 SourceLocation L,
94 DeclarationName Name,
95 TemplateParameterList *Params,
96 NamedDecl *Decl,
97 ClassTemplateDecl *PrevDecl) {
98 Common *CommonPtr;
99 if (PrevDecl)
100 CommonPtr = PrevDecl->CommonPtr;
101 else
102 CommonPtr = new (C) Common;
103
104 return new (C) ClassTemplateDecl(DC, L, Name, Params, Decl, PrevDecl,
105 CommonPtr);
106}
107
108ClassTemplateDecl::~ClassTemplateDecl() {
109 assert(CommonPtr == 0 && "ClassTemplateDecl must be explicitly destroyed");
110}
111
112void ClassTemplateDecl::Destroy(ASTContext& C) {
113 if (!PreviousDeclaration) {
114 CommonPtr->~Common();
115 C.Deallocate((void*)CommonPtr);
116 }
117 CommonPtr = 0;
118
119 this->~ClassTemplateDecl();
120 C.Deallocate((void*)this);
121}
122
123QualType ClassTemplateDecl::getInjectedClassNameType(ASTContext &Context) {
124 if (!CommonPtr->InjectedClassNameType.isNull())
125 return CommonPtr->InjectedClassNameType;
126
127 // FIXME: n2800 14.6.1p1 should say how the template arguments
128 // corresponding to template parameter packs should be pack
129 // expansions. We already say that in 14.6.2.1p2, so it would be
130 // better to fix that redundancy.
131
132 TemplateParameterList *Params = getTemplateParameters();
133
134 llvm::SmallVector<TemplateArgument, 16> TemplateArgs;
135 llvm::SmallVector<TemplateArgument, 16> CanonTemplateArgs;
136 TemplateArgs.reserve(Params->size());
137 CanonTemplateArgs.reserve(Params->size());
138
139 for (TemplateParameterList::iterator
140 Param = Params->begin(), ParamEnd = Params->end();
141 Param != ParamEnd; ++Param) {
142 if (isa<TemplateTypeParmDecl>(*Param)) {
143 QualType ParamType = Context.getTypeDeclType(cast<TypeDecl>(*Param));
144 TemplateArgs.push_back(TemplateArgument((*Param)->getLocation(),
145 ParamType));
146 CanonTemplateArgs.push_back(
147 TemplateArgument((*Param)->getLocation(),
148 Context.getCanonicalType(ParamType)));
149 } else if (NonTypeTemplateParmDecl *NTTP =
150 dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
151 // FIXME: Build canonical expression, too!
152 Expr *E = new (Context) DeclRefExpr(NTTP, NTTP->getType(),
153 NTTP->getLocation(),
154 NTTP->getType()->isDependentType(),
155 /*Value-dependent=*/true);
156 TemplateArgs.push_back(TemplateArgument(E));
157 CanonTemplateArgs.push_back(TemplateArgument(E));
158 } else {
159 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param);
160 TemplateArgs.push_back(TemplateArgument(TTP->getLocation(), TTP));
161 CanonTemplateArgs.push_back(TemplateArgument(TTP->getLocation(),
162 Context.getCanonicalDecl(TTP)));
163 }
164 }
165
166 // FIXME: I should really move the "build-the-canonical-type" logic
167 // into ASTContext::getTemplateSpecializationType.
168 TemplateName Name = TemplateName(this);
169 QualType CanonType = Context.getTemplateSpecializationType(
170 Context.getCanonicalTemplateName(Name),
171 &CanonTemplateArgs[0],
172 CanonTemplateArgs.size());
173
174 CommonPtr->InjectedClassNameType
175 = Context.getTemplateSpecializationType(Name,
176 &TemplateArgs[0],
177 TemplateArgs.size(),
178 CanonType);
179 return CommonPtr->InjectedClassNameType;
180}
181
182//===----------------------------------------------------------------------===//
183// TemplateTypeParm Allocation/Deallocation Method Implementations
184//===----------------------------------------------------------------------===//
185
186TemplateTypeParmDecl *
187TemplateTypeParmDecl::Create(ASTContext &C, DeclContext *DC,
188 SourceLocation L, unsigned D, unsigned P,
| 56 cast<TemplateTypeParmDecl>(*Param)->hasDefaultArgument()) &&
57 !(isa<NonTypeTemplateParmDecl>(*Param) &&
58 cast<NonTypeTemplateParmDecl>(*Param)->hasDefaultArgument()) &&
59 !(isa<TemplateTemplateParmDecl>(*Param) &&
60 cast<TemplateTemplateParmDecl>(*Param)->hasDefaultArgument()))
61 break;
62
63 --NumRequiredArgs;
64 }
65
66 return NumRequiredArgs;
67}
68
69//===----------------------------------------------------------------------===//
70// TemplateDecl Implementation
71//===----------------------------------------------------------------------===//
72
73TemplateDecl::~TemplateDecl() {
74}
75
76//===----------------------------------------------------------------------===//
77// FunctionTemplateDecl Implementation
78//===----------------------------------------------------------------------===//
79
80FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
81 DeclContext *DC,
82 SourceLocation L,
83 DeclarationName Name,
84 TemplateParameterList *Params,
85 NamedDecl *Decl) {
86 return new (C) FunctionTemplateDecl(DC, L, Name, Params, Decl);
87}
88
89//===----------------------------------------------------------------------===//
90// ClassTemplateDecl Implementation
91//===----------------------------------------------------------------------===//
92
93ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
94 DeclContext *DC,
95 SourceLocation L,
96 DeclarationName Name,
97 TemplateParameterList *Params,
98 NamedDecl *Decl,
99 ClassTemplateDecl *PrevDecl) {
100 Common *CommonPtr;
101 if (PrevDecl)
102 CommonPtr = PrevDecl->CommonPtr;
103 else
104 CommonPtr = new (C) Common;
105
106 return new (C) ClassTemplateDecl(DC, L, Name, Params, Decl, PrevDecl,
107 CommonPtr);
108}
109
110ClassTemplateDecl::~ClassTemplateDecl() {
111 assert(CommonPtr == 0 && "ClassTemplateDecl must be explicitly destroyed");
112}
113
114void ClassTemplateDecl::Destroy(ASTContext& C) {
115 if (!PreviousDeclaration) {
116 CommonPtr->~Common();
117 C.Deallocate((void*)CommonPtr);
118 }
119 CommonPtr = 0;
120
121 this->~ClassTemplateDecl();
122 C.Deallocate((void*)this);
123}
124
125QualType ClassTemplateDecl::getInjectedClassNameType(ASTContext &Context) {
126 if (!CommonPtr->InjectedClassNameType.isNull())
127 return CommonPtr->InjectedClassNameType;
128
129 // FIXME: n2800 14.6.1p1 should say how the template arguments
130 // corresponding to template parameter packs should be pack
131 // expansions. We already say that in 14.6.2.1p2, so it would be
132 // better to fix that redundancy.
133
134 TemplateParameterList *Params = getTemplateParameters();
135
136 llvm::SmallVector<TemplateArgument, 16> TemplateArgs;
137 llvm::SmallVector<TemplateArgument, 16> CanonTemplateArgs;
138 TemplateArgs.reserve(Params->size());
139 CanonTemplateArgs.reserve(Params->size());
140
141 for (TemplateParameterList::iterator
142 Param = Params->begin(), ParamEnd = Params->end();
143 Param != ParamEnd; ++Param) {
144 if (isa<TemplateTypeParmDecl>(*Param)) {
145 QualType ParamType = Context.getTypeDeclType(cast<TypeDecl>(*Param));
146 TemplateArgs.push_back(TemplateArgument((*Param)->getLocation(),
147 ParamType));
148 CanonTemplateArgs.push_back(
149 TemplateArgument((*Param)->getLocation(),
150 Context.getCanonicalType(ParamType)));
151 } else if (NonTypeTemplateParmDecl *NTTP =
152 dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
153 // FIXME: Build canonical expression, too!
154 Expr *E = new (Context) DeclRefExpr(NTTP, NTTP->getType(),
155 NTTP->getLocation(),
156 NTTP->getType()->isDependentType(),
157 /*Value-dependent=*/true);
158 TemplateArgs.push_back(TemplateArgument(E));
159 CanonTemplateArgs.push_back(TemplateArgument(E));
160 } else {
161 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param);
162 TemplateArgs.push_back(TemplateArgument(TTP->getLocation(), TTP));
163 CanonTemplateArgs.push_back(TemplateArgument(TTP->getLocation(),
164 Context.getCanonicalDecl(TTP)));
165 }
166 }
167
168 // FIXME: I should really move the "build-the-canonical-type" logic
169 // into ASTContext::getTemplateSpecializationType.
170 TemplateName Name = TemplateName(this);
171 QualType CanonType = Context.getTemplateSpecializationType(
172 Context.getCanonicalTemplateName(Name),
173 &CanonTemplateArgs[0],
174 CanonTemplateArgs.size());
175
176 CommonPtr->InjectedClassNameType
177 = Context.getTemplateSpecializationType(Name,
178 &TemplateArgs[0],
179 TemplateArgs.size(),
180 CanonType);
181 return CommonPtr->InjectedClassNameType;
182}
183
184//===----------------------------------------------------------------------===//
185// TemplateTypeParm Allocation/Deallocation Method Implementations
186//===----------------------------------------------------------------------===//
187
188TemplateTypeParmDecl *
189TemplateTypeParmDecl::Create(ASTContext &C, DeclContext *DC,
190 SourceLocation L, unsigned D, unsigned P,
|
189 IdentifierInfo *Id, bool Typename) {
| 191 IdentifierInfo *Id, bool Typename,
192 bool ParameterPack) {
|
190 QualType Type = C.getTemplateTypeParmType(D, P, Id);
| 193 QualType Type = C.getTemplateTypeParmType(D, P, Id);
|
191 return new (C) TemplateTypeParmDecl(DC, L, Id, Typename, Type);
| 194 return new (C) TemplateTypeParmDecl(DC, L, Id, Typename, Type, ParameterPack);
|
192}
193
194//===----------------------------------------------------------------------===//
195// NonTypeTemplateParmDecl Method Implementations
196//===----------------------------------------------------------------------===//
197
198NonTypeTemplateParmDecl *
199NonTypeTemplateParmDecl::Create(ASTContext &C, DeclContext *DC,
200 SourceLocation L, unsigned D, unsigned P,
201 IdentifierInfo *Id, QualType T,
202 SourceLocation TypeSpecStartLoc) {
203 return new (C) NonTypeTemplateParmDecl(DC, L, D, P, Id, T,
204 TypeSpecStartLoc);
205}
206
207SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
208 return DefaultArgument? DefaultArgument->getSourceRange().getBegin()
209 : SourceLocation();
210}
211
212//===----------------------------------------------------------------------===//
213// TemplateTemplateParmDecl Method Implementations
214//===----------------------------------------------------------------------===//
215
216TemplateTemplateParmDecl *
217TemplateTemplateParmDecl::Create(ASTContext &C, DeclContext *DC,
218 SourceLocation L, unsigned D, unsigned P,
219 IdentifierInfo *Id,
220 TemplateParameterList *Params) {
221 return new (C) TemplateTemplateParmDecl(DC, L, D, P, Id, Params);
222}
223
224SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const {
225 return DefaultArgument? DefaultArgument->getSourceRange().getBegin()
226 : SourceLocation();
227}
228
229//===----------------------------------------------------------------------===//
230// TemplateArgument Implementation
231//===----------------------------------------------------------------------===//
232
233TemplateArgument::TemplateArgument(Expr *E) : Kind(Expression) {
234 TypeOrValue = reinterpret_cast<uintptr_t>(E);
235 StartLoc = E->getSourceRange().getBegin();
236}
237
238//===----------------------------------------------------------------------===//
239// TemplateArgumentListBuilder Implementation
240//===----------------------------------------------------------------------===//
241void TemplateArgumentListBuilder::push_back(const TemplateArgument& Arg) {
242 switch (Arg.getKind()) {
243 default: break;
244 case TemplateArgument::Type:
245 assert(Arg.getAsType()->isCanonical() && "Type must be canonical!");
246 break;
247 }
248
| 195}
196
197//===----------------------------------------------------------------------===//
198// NonTypeTemplateParmDecl Method Implementations
199//===----------------------------------------------------------------------===//
200
201NonTypeTemplateParmDecl *
202NonTypeTemplateParmDecl::Create(ASTContext &C, DeclContext *DC,
203 SourceLocation L, unsigned D, unsigned P,
204 IdentifierInfo *Id, QualType T,
205 SourceLocation TypeSpecStartLoc) {
206 return new (C) NonTypeTemplateParmDecl(DC, L, D, P, Id, T,
207 TypeSpecStartLoc);
208}
209
210SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
211 return DefaultArgument? DefaultArgument->getSourceRange().getBegin()
212 : SourceLocation();
213}
214
215//===----------------------------------------------------------------------===//
216// TemplateTemplateParmDecl Method Implementations
217//===----------------------------------------------------------------------===//
218
219TemplateTemplateParmDecl *
220TemplateTemplateParmDecl::Create(ASTContext &C, DeclContext *DC,
221 SourceLocation L, unsigned D, unsigned P,
222 IdentifierInfo *Id,
223 TemplateParameterList *Params) {
224 return new (C) TemplateTemplateParmDecl(DC, L, D, P, Id, Params);
225}
226
227SourceLocation TemplateTemplateParmDecl::getDefaultArgumentLoc() const {
228 return DefaultArgument? DefaultArgument->getSourceRange().getBegin()
229 : SourceLocation();
230}
231
232//===----------------------------------------------------------------------===//
233// TemplateArgument Implementation
234//===----------------------------------------------------------------------===//
235
236TemplateArgument::TemplateArgument(Expr *E) : Kind(Expression) {
237 TypeOrValue = reinterpret_cast<uintptr_t>(E);
238 StartLoc = E->getSourceRange().getBegin();
239}
240
241//===----------------------------------------------------------------------===//
242// TemplateArgumentListBuilder Implementation
243//===----------------------------------------------------------------------===//
244void TemplateArgumentListBuilder::push_back(const TemplateArgument& Arg) {
245 switch (Arg.getKind()) {
246 default: break;
247 case TemplateArgument::Type:
248 assert(Arg.getAsType()->isCanonical() && "Type must be canonical!");
249 break;
250 }
251
|
| 252 if (!isAddingFromParameterPack()) {
253 // Add begin and end indicies.
254 Indices.push_back(Args.size());
255 Indices.push_back(Args.size());
256 }
257
|
249 Args.push_back(Arg);
250}
251
| 258 Args.push_back(Arg);
259}
260
|
| 261void TemplateArgumentListBuilder::BeginParameterPack() {
262 assert(!isAddingFromParameterPack() && "Already adding to parameter pack!");
263
264 Indices.push_back(Args.size());
265}
266
267void TemplateArgumentListBuilder::EndParameterPack() {
268 assert(isAddingFromParameterPack() && "Not adding to parameter pack!");
269
270 Indices.push_back(Args.size());
271}
272
|
252//===----------------------------------------------------------------------===//
253// TemplateArgumentList Implementation
254//===----------------------------------------------------------------------===//
255TemplateArgumentList::TemplateArgumentList(ASTContext &Context,
256 TemplateArgumentListBuilder &Builder,
257 bool CopyArgs, bool FlattenArgs)
258 : NumArguments(Builder.flatSize()) {
259 if (!CopyArgs) {
260 Arguments.setPointer(Builder.getFlatArgumentList());
261 Arguments.setInt(1);
262 return;
263 }
264
265
266 unsigned Size = sizeof(TemplateArgument) * Builder.flatSize();
267 unsigned Align = llvm::AlignOf<TemplateArgument>::Alignment;
268 void *Mem = Context.Allocate(Size, Align);
269 Arguments.setPointer((TemplateArgument *)Mem);
270 Arguments.setInt(0);
271
272 TemplateArgument *Args = (TemplateArgument *)Mem;
273 for (unsigned I = 0; I != NumArguments; ++I)
274 new (Args + I) TemplateArgument(Builder.getFlatArgumentList()[I]);
275}
276
277TemplateArgumentList::~TemplateArgumentList() {
278 // FIXME: Deallocate template arguments
279}
280
281//===----------------------------------------------------------------------===//
282// ClassTemplateSpecializationDecl Implementation
283//===----------------------------------------------------------------------===//
284ClassTemplateSpecializationDecl::
285ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK,
286 DeclContext *DC, SourceLocation L,
287 ClassTemplateDecl *SpecializedTemplate,
288 TemplateArgumentListBuilder &Builder)
289 : CXXRecordDecl(DK,
290 SpecializedTemplate->getTemplatedDecl()->getTagKind(),
291 DC, L,
292 // FIXME: Should we use DeclarationName for the name of
293 // class template specializations?
294 SpecializedTemplate->getIdentifier()),
295 SpecializedTemplate(SpecializedTemplate),
296 TemplateArgs(Context, Builder, /*CopyArgs=*/true, /*FlattenArgs=*/true),
297 SpecializationKind(TSK_Undeclared) {
298}
299
300ClassTemplateSpecializationDecl *
301ClassTemplateSpecializationDecl::Create(ASTContext &Context,
302 DeclContext *DC, SourceLocation L,
303 ClassTemplateDecl *SpecializedTemplate,
304 TemplateArgumentListBuilder &Builder,
305 ClassTemplateSpecializationDecl *PrevDecl) {
306 ClassTemplateSpecializationDecl *Result
307 = new (Context)ClassTemplateSpecializationDecl(Context,
308 ClassTemplateSpecialization,
309 DC, L,
310 SpecializedTemplate,
311 Builder);
312 Context.getTypeDeclType(Result, PrevDecl);
313 return Result;
314}
315
316//===----------------------------------------------------------------------===//
317// ClassTemplatePartialSpecializationDecl Implementation
318//===----------------------------------------------------------------------===//
319ClassTemplatePartialSpecializationDecl *
320ClassTemplatePartialSpecializationDecl::
321Create(ASTContext &Context, DeclContext *DC, SourceLocation L,
322 TemplateParameterList *Params,
323 ClassTemplateDecl *SpecializedTemplate,
324 TemplateArgumentListBuilder &Builder,
325 ClassTemplatePartialSpecializationDecl *PrevDecl) {
326 ClassTemplatePartialSpecializationDecl *Result
327 = new (Context)ClassTemplatePartialSpecializationDecl(Context,
328 DC, L, Params,
329 SpecializedTemplate,
330 Builder);
331 Result->setSpecializationKind(TSK_ExplicitSpecialization);
332 Context.getTypeDeclType(Result, PrevDecl);
333 return Result;
334}
| 273//===----------------------------------------------------------------------===//
274// TemplateArgumentList Implementation
275//===----------------------------------------------------------------------===//
276TemplateArgumentList::TemplateArgumentList(ASTContext &Context,
277 TemplateArgumentListBuilder &Builder,
278 bool CopyArgs, bool FlattenArgs)
279 : NumArguments(Builder.flatSize()) {
280 if (!CopyArgs) {
281 Arguments.setPointer(Builder.getFlatArgumentList());
282 Arguments.setInt(1);
283 return;
284 }
285
286
287 unsigned Size = sizeof(TemplateArgument) * Builder.flatSize();
288 unsigned Align = llvm::AlignOf<TemplateArgument>::Alignment;
289 void *Mem = Context.Allocate(Size, Align);
290 Arguments.setPointer((TemplateArgument *)Mem);
291 Arguments.setInt(0);
292
293 TemplateArgument *Args = (TemplateArgument *)Mem;
294 for (unsigned I = 0; I != NumArguments; ++I)
295 new (Args + I) TemplateArgument(Builder.getFlatArgumentList()[I]);
296}
297
298TemplateArgumentList::~TemplateArgumentList() {
299 // FIXME: Deallocate template arguments
300}
301
302//===----------------------------------------------------------------------===//
303// ClassTemplateSpecializationDecl Implementation
304//===----------------------------------------------------------------------===//
305ClassTemplateSpecializationDecl::
306ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK,
307 DeclContext *DC, SourceLocation L,
308 ClassTemplateDecl *SpecializedTemplate,
309 TemplateArgumentListBuilder &Builder)
310 : CXXRecordDecl(DK,
311 SpecializedTemplate->getTemplatedDecl()->getTagKind(),
312 DC, L,
313 // FIXME: Should we use DeclarationName for the name of
314 // class template specializations?
315 SpecializedTemplate->getIdentifier()),
316 SpecializedTemplate(SpecializedTemplate),
317 TemplateArgs(Context, Builder, /*CopyArgs=*/true, /*FlattenArgs=*/true),
318 SpecializationKind(TSK_Undeclared) {
319}
320
321ClassTemplateSpecializationDecl *
322ClassTemplateSpecializationDecl::Create(ASTContext &Context,
323 DeclContext *DC, SourceLocation L,
324 ClassTemplateDecl *SpecializedTemplate,
325 TemplateArgumentListBuilder &Builder,
326 ClassTemplateSpecializationDecl *PrevDecl) {
327 ClassTemplateSpecializationDecl *Result
328 = new (Context)ClassTemplateSpecializationDecl(Context,
329 ClassTemplateSpecialization,
330 DC, L,
331 SpecializedTemplate,
332 Builder);
333 Context.getTypeDeclType(Result, PrevDecl);
334 return Result;
335}
336
337//===----------------------------------------------------------------------===//
338// ClassTemplatePartialSpecializationDecl Implementation
339//===----------------------------------------------------------------------===//
340ClassTemplatePartialSpecializationDecl *
341ClassTemplatePartialSpecializationDecl::
342Create(ASTContext &Context, DeclContext *DC, SourceLocation L,
343 TemplateParameterList *Params,
344 ClassTemplateDecl *SpecializedTemplate,
345 TemplateArgumentListBuilder &Builder,
346 ClassTemplatePartialSpecializationDecl *PrevDecl) {
347 ClassTemplatePartialSpecializationDecl *Result
348 = new (Context)ClassTemplatePartialSpecializationDecl(Context,
349 DC, L, Params,
350 SpecializedTemplate,
351 Builder);
352 Result->setSpecializationKind(TSK_ExplicitSpecialization);
353 Context.getTypeDeclType(Result, PrevDecl);
354 return Result;
355}
|