 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
64.8% |
92 / 142 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
76.1% |
108 / 142 |
| |
|
Line Coverage: |
83.6% |
168 / 201 |
| |
 |
|
 |
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/ASTContext.h"
18 : #include "clang/AST/TypeLoc.h"
19 : #include "clang/Basic/IdentifierTable.h"
20 : #include "llvm/ADT/STLExtras.h"
21 : using namespace clang;
22 :
23 : //===----------------------------------------------------------------------===//
24 : // TemplateParameterList Implementation
25 : //===----------------------------------------------------------------------===//
26 :
27 : TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc,
28 : SourceLocation LAngleLoc,
29 : NamedDecl **Params, unsigned NumParams,
30 2122: SourceLocation RAngleLoc)
31 : : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
32 2122: NumParams(NumParams) {
4479: branch 0 taken
4479: branch 1 taken
2357: branch 2 taken
2122: branch 3 taken
33 4479: for (unsigned Idx = 0; Idx < NumParams; ++Idx)
34 2357: begin()[Idx] = Params[Idx];
35 2122: }
36 :
37 : TemplateParameterList *
38 : TemplateParameterList::Create(ASTContext &C, SourceLocation TemplateLoc,
39 : SourceLocation LAngleLoc, NamedDecl **Params,
40 2122: unsigned NumParams, SourceLocation RAngleLoc) {
41 : unsigned Size = sizeof(TemplateParameterList)
42 2122: + sizeof(NamedDecl *) * NumParams;
43 2122: unsigned Align = llvm::AlignOf<TemplateParameterList>::Alignment;
44 2122: void *Mem = C.Allocate(Size, Align);
45 : return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params,
2122: branch 1 taken
0: branch 2 not taken
46 2122: NumParams, RAngleLoc);
47 : }
48 :
49 4111: unsigned TemplateParameterList::getMinRequiredArguments() const {
50 4111: unsigned NumRequiredArgs = size();
51 4111: iterator Param = const_cast<TemplateParameterList *>(this)->end(),
52 4111: ParamBegin = const_cast<TemplateParameterList *>(this)->begin();
4326: branch 0 taken
21: branch 1 taken
53 8458: while (Param != ParamBegin) {
54 4326: --Param;
55 :
4315: branch 1 taken
11: branch 2 taken
3162: branch 4 taken
1153: branch 5 taken
2962: branch 8 taken
200: branch 9 taken
1116: branch 11 taken
2999: branch 12 taken
1099: branch 15 taken
17: branch 16 taken
37: branch 18 taken
4061: branch 19 taken
29: branch 22 taken
8: branch 23 taken
4090: branch 24 taken
236: branch 25 taken
56 4326: if (!(*Param)->isTemplateParameterPack() &&
57 : !(isa<TemplateTypeParmDecl>(*Param) &&
58 : cast<TemplateTypeParmDecl>(*Param)->hasDefaultArgument()) &&
59 : !(isa<NonTypeTemplateParmDecl>(*Param) &&
60 : cast<NonTypeTemplateParmDecl>(*Param)->hasDefaultArgument()) &&
61 : !(isa<TemplateTemplateParmDecl>(*Param) &&
62 : cast<TemplateTemplateParmDecl>(*Param)->hasDefaultArgument()))
63 4090: break;
64 :
65 236: --NumRequiredArgs;
66 : }
67 :
68 4111: return NumRequiredArgs;
69 : }
70 :
71 102: unsigned TemplateParameterList::getDepth() const {
0: branch 1 not taken
102: branch 2 taken
72 102: if (size() == 0)
73 0: return 0;
74 :
75 102: const NamedDecl *FirstParm = getParam(0);
93: branch 0 taken
9: branch 1 taken
76 102: if (const TemplateTypeParmDecl *TTP
77 102: = dyn_cast<TemplateTypeParmDecl>(FirstParm))
78 93: return TTP->getDepth();
5: branch 0 taken
4: branch 1 taken
79 9: else if (const NonTypeTemplateParmDecl *NTTP
80 9: = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
81 5: return NTTP->getDepth();
82 : else
83 4: return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
84 : }
85 :
86 : //===----------------------------------------------------------------------===//
87 : // TemplateDecl Implementation
88 : //===----------------------------------------------------------------------===//
89 :
90 0: TemplateDecl::~TemplateDecl() {
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
91 0: }
92 :
93 : //===----------------------------------------------------------------------===//
94 : // FunctionTemplateDecl Implementation
95 : //===----------------------------------------------------------------------===//
96 :
97 : FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
98 : DeclContext *DC,
99 : SourceLocation L,
100 : DeclarationName Name,
101 : TemplateParameterList *Params,
102 504: NamedDecl *Decl) {
504: branch 1 taken
0: branch 2 not taken
103 504: return new (C) FunctionTemplateDecl(DC, L, Name, Params, Decl);
104 : }
105 :
106 0: void FunctionTemplateDecl::Destroy(ASTContext &C) {
0: branch 1 not taken
0: branch 2 not taken
107 0: if (Common *CommonPtr = CommonOrPrev.dyn_cast<Common*>()) {
0: branch 2 not taken
0: branch 3 not taken
108 0: for (llvm::FoldingSet<FunctionTemplateSpecializationInfo>::iterator
109 0: Spec = CommonPtr->Specializations.begin(),
110 0: SpecEnd = CommonPtr->Specializations.end();
111 : Spec != SpecEnd; ++Spec)
112 0: C.Deallocate(&*Spec);
113 : }
114 :
115 0: Decl::Destroy(C);
116 0: }
117 :
118 5893: FunctionTemplateDecl *FunctionTemplateDecl::getCanonicalDecl() {
119 5893: FunctionTemplateDecl *FunTmpl = this;
164: branch 1 taken
5893: branch 2 taken
120 11950: while (FunTmpl->getPreviousDeclaration())
121 164: FunTmpl = FunTmpl->getPreviousDeclaration();
122 5893: return FunTmpl;
123 : }
124 :
125 2447: FunctionTemplateDecl::Common *FunctionTemplateDecl::getCommonPtr() {
126 : // Find the first declaration of this function template.
127 2447: FunctionTemplateDecl *First = this;
80: branch 1 taken
2447: branch 2 taken
128 4974: while (First->getPreviousDeclaration())
129 80: First = First->getPreviousDeclaration();
130 :
359: branch 1 taken
2088: branch 2 taken
131 2447: if (First->CommonOrPrev.isNull()) {
132 : // FIXME: Allocate with the ASTContext
133 359: First->CommonOrPrev = new Common;
134 : }
135 2447: return First->CommonOrPrev.get<Common*>();
136 : }
137 :
138 : //===----------------------------------------------------------------------===//
139 : // ClassTemplateDecl Implementation
140 : //===----------------------------------------------------------------------===//
141 :
142 3116: ClassTemplateDecl *ClassTemplateDecl::getCanonicalDecl() {
143 3116: ClassTemplateDecl *Template = this;
18: branch 1 taken
3116: branch 2 taken
144 6250: while (Template->getPreviousDeclaration())
145 18: Template = Template->getPreviousDeclaration();
146 3116: return Template;
147 : }
148 :
149 : ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
150 : DeclContext *DC,
151 : SourceLocation L,
152 : DeclarationName Name,
153 : TemplateParameterList *Params,
154 : NamedDecl *Decl,
155 1036: ClassTemplateDecl *PrevDecl) {
156 : Common *CommonPtr;
41: branch 0 taken
995: branch 1 taken
157 1036: if (PrevDecl)
158 41: CommonPtr = PrevDecl->CommonPtr;
159 : else
995: branch 1 taken
0: branch 2 not taken
160 995: CommonPtr = new (C) Common;
161 :
162 : return new (C) ClassTemplateDecl(DC, L, Name, Params, Decl, PrevDecl,
1036: branch 1 taken
0: branch 2 not taken
163 1036: CommonPtr);
164 : }
165 :
166 0: ClassTemplateDecl::~ClassTemplateDecl() {
0: branch 0 not taken
0: branch 1 not taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 6 not taken
0: branch 7 not taken
167 0: assert(CommonPtr == 0 && "ClassTemplateDecl must be explicitly destroyed");
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
168 0: }
169 :
170 0: void ClassTemplateDecl::Destroy(ASTContext& C) {
0: branch 0 not taken
0: branch 1 not taken
171 0: if (!PreviousDeclaration) {
172 0: CommonPtr->~Common();
173 0: C.Deallocate((void*)CommonPtr);
174 : }
175 0: CommonPtr = 0;
176 :
177 0: this->~ClassTemplateDecl();
178 0: C.Deallocate((void*)this);
179 0: }
180 :
181 : ClassTemplatePartialSpecializationDecl *
182 27: ClassTemplateDecl::findPartialSpecialization(QualType T) {
183 27: ASTContext &Context = getASTContext();
184 : typedef llvm::FoldingSet<ClassTemplatePartialSpecializationDecl>::iterator
185 : partial_spec_iterator;
22: branch 4 taken
6: branch 5 taken
186 55: for (partial_spec_iterator P = getPartialSpecializations().begin(),
187 27: PEnd = getPartialSpecializations().end();
188 : P != PEnd; ++P) {
21: branch 3 taken
1: branch 4 taken
189 22: if (Context.hasSameType(Context.getTypeDeclType(&*P), T))
190 21: return &*P;
191 : }
192 :
193 6: return 0;
194 : }
195 :
196 1561: QualType ClassTemplateDecl::getInjectedClassNameType(ASTContext &Context) {
1299: branch 1 taken
262: branch 2 taken
197 1561: if (!CommonPtr->InjectedClassNameType.isNull())
198 1299: return CommonPtr->InjectedClassNameType;
199 :
200 : // FIXME: n2800 14.6.1p1 should say how the template arguments
201 : // corresponding to template parameter packs should be pack
202 : // expansions. We already say that in 14.6.2.1p2, so it would be
203 : // better to fix that redundancy.
204 :
205 262: TemplateParameterList *Params = getTemplateParameters();
206 262: llvm::SmallVector<TemplateArgument, 16> TemplateArgs;
207 262: TemplateArgs.reserve(Params->size());
311: branch 1 taken
262: branch 2 taken
208 835: for (TemplateParameterList::iterator Param = Params->begin(),
209 262: ParamEnd = Params->end();
210 : Param != ParamEnd; ++Param) {
280: branch 1 taken
31: branch 2 taken
211 311: if (isa<TemplateTypeParmDecl>(*Param)) {
212 280: QualType ParamType = Context.getTypeDeclType(cast<TypeDecl>(*Param));
213 280: TemplateArgs.push_back(TemplateArgument(ParamType));
28: branch 0 taken
3: branch 1 taken
214 31: } else if (NonTypeTemplateParmDecl *NTTP =
215 31: dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
216 : Expr *E = new (Context) DeclRefExpr(NTTP,
217 : NTTP->getType().getNonReferenceType(),
28: branch 4 taken
0: branch 5 not taken
218 28: NTTP->getLocation());
219 28: TemplateArgs.push_back(TemplateArgument(E));
220 : } else {
221 3: TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param);
222 3: TemplateArgs.push_back(TemplateArgument(TemplateName(TTP)));
223 : }
224 : }
225 :
226 : CommonPtr->InjectedClassNameType
227 : = Context.getTemplateSpecializationType(TemplateName(this),
228 : &TemplateArgs[0],
229 262: TemplateArgs.size());
230 262: return CommonPtr->InjectedClassNameType;
231 : }
232 :
233 : //===----------------------------------------------------------------------===//
234 : // TemplateTypeParm Allocation/Deallocation Method Implementations
235 : //===----------------------------------------------------------------------===//
236 :
237 : TemplateTypeParmDecl *
238 : TemplateTypeParmDecl::Create(ASTContext &C, DeclContext *DC,
239 : SourceLocation L, unsigned D, unsigned P,
240 : IdentifierInfo *Id, bool Typename,
241 1868: bool ParameterPack) {
242 1868: QualType Type = C.getTemplateTypeParmType(D, P, ParameterPack, Id);
1868: branch 1 taken
0: branch 2 not taken
243 1868: return new (C) TemplateTypeParmDecl(DC, L, Id, Typename, Type, ParameterPack);
244 : }
245 :
246 100: SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
247 100: return DefaultArgument->getTypeLoc().getFullSourceRange().getBegin();
248 : }
249 :
250 93: unsigned TemplateTypeParmDecl::getDepth() const {
251 93: return TypeForDecl->getAs<TemplateTypeParmType>()->getDepth();
252 : }
253 :
254 0: unsigned TemplateTypeParmDecl::getIndex() const {
255 0: return TypeForDecl->getAs<TemplateTypeParmType>()->getIndex();
256 : }
257 :
258 : //===----------------------------------------------------------------------===//
259 : // NonTypeTemplateParmDecl Method Implementations
260 : //===----------------------------------------------------------------------===//
261 :
262 : NonTypeTemplateParmDecl *
263 : NonTypeTemplateParmDecl::Create(ASTContext &C, DeclContext *DC,
264 : SourceLocation L, unsigned D, unsigned P,
265 : IdentifierInfo *Id, QualType T,
266 436: TypeSourceInfo *TInfo) {
436: branch 1 taken
0: branch 2 not taken
267 436: return new (C) NonTypeTemplateParmDecl(DC, L, D, P, Id, T, TInfo);
268 : }
269 :
270 26: SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
271 : return DefaultArgument? DefaultArgument->getSourceRange().getBegin()
26: branch 0 taken
0: branch 1 not taken
272 26: : SourceLocation();
273 : }
274 :
275 : //===----------------------------------------------------------------------===//
276 : // TemplateTemplateParmDecl Method Implementations
277 : //===----------------------------------------------------------------------===//
278 :
279 : TemplateTemplateParmDecl *
280 : TemplateTemplateParmDecl::Create(ASTContext &C, DeclContext *DC,
281 : SourceLocation L, unsigned D, unsigned P,
282 : IdentifierInfo *Id,
283 99: TemplateParameterList *Params) {
99: branch 1 taken
0: branch 2 not taken
284 99: return new (C) TemplateTemplateParmDecl(DC, L, D, P, Id, Params);
285 : }
286 :
287 : //===----------------------------------------------------------------------===//
288 : // TemplateArgumentListBuilder Implementation
289 : //===----------------------------------------------------------------------===//
290 :
291 6866: void TemplateArgumentListBuilder::Append(const TemplateArgument& Arg) {
1924: branch 1 taken
4942: branch 2 taken
292 6866: switch (Arg.getKind()) {
293 1924: default: break;
294 : case TemplateArgument::Type:
4942: branch 2 taken
0: branch 3 not taken
295 4942: assert(Arg.getAsType().isCanonical() && "Type must be canonical!");
296 : break;
297 : }
298 :
0: branch 0 not taken
6866: branch 1 taken
299 6866: assert(NumFlatArgs < MaxFlatArgs && "Argument list builder is full!");
300 : assert(!StructuredArgs &&
0: branch 0 not taken
6866: branch 1 taken
301 6866: "Can't append arguments when an argument pack has been added!");
302 :
5250: branch 0 taken
1616: branch 1 taken
303 6866: if (!FlatArgs)
6916: branch 2 taken
5250: branch 3 taken
304 5250: FlatArgs = new TemplateArgument[MaxFlatArgs];
305 :
306 6866: FlatArgs[NumFlatArgs++] = Arg;
307 6866: }
308 :
309 9: void TemplateArgumentListBuilder::BeginPack() {
0: branch 0 not taken
9: branch 1 taken
310 9: assert(!AddingToPack && "Already adding to pack!");
0: branch 0 not taken
9: branch 1 taken
311 9: assert(!StructuredArgs && "Argument list already contains a pack!");
312 :
313 9: AddingToPack = true;
314 9: PackBeginIndex = NumFlatArgs;
315 9: }
316 :
317 9: void TemplateArgumentListBuilder::EndPack() {
0: branch 0 not taken
9: branch 1 taken
318 9: assert(AddingToPack && "Not adding to pack!");
0: branch 0 not taken
9: branch 1 taken
319 9: assert(!StructuredArgs && "Argument list already contains a pack!");
320 :
321 9: AddingToPack = false;
322 :
14: branch 2 taken
9: branch 3 taken
323 9: StructuredArgs = new TemplateArgument[MaxStructuredArgs];
324 :
325 : // First copy the flat entries over to the list (if any)
5: branch 0 taken
9: branch 1 taken
326 14: for (unsigned I = 0; I != PackBeginIndex; ++I) {
327 5: NumStructuredArgs++;
328 5: StructuredArgs[I] = FlatArgs[I];
329 : }
330 :
331 : // Next, set the pack.
332 9: TemplateArgument *PackArgs = 0;
333 9: unsigned NumPackArgs = NumFlatArgs - PackBeginIndex;
5: branch 0 taken
4: branch 1 taken
334 9: if (NumPackArgs)
335 5: PackArgs = &FlatArgs[PackBeginIndex];
336 :
337 : StructuredArgs[NumStructuredArgs++].setArgumentPack(PackArgs, NumPackArgs,
338 9: /*CopyArgs=*/false);
339 9: }
340 :
341 3156: void TemplateArgumentListBuilder::ReleaseArgs() {
342 3156: FlatArgs = 0;
343 3156: NumFlatArgs = 0;
344 3156: MaxFlatArgs = 0;
345 3156: StructuredArgs = 0;
346 3156: NumStructuredArgs = 0;
347 3156: MaxStructuredArgs = 0;
348 3156: }
349 :
350 : //===----------------------------------------------------------------------===//
351 : // TemplateArgumentList Implementation
352 : //===----------------------------------------------------------------------===//
353 : TemplateArgumentList::TemplateArgumentList(ASTContext &Context,
354 : TemplateArgumentListBuilder &Builder,
355 3298: bool TakeArgs)
356 : : FlatArguments(Builder.getFlatArguments(), TakeArgs),
357 : NumFlatArguments(Builder.flatSize()),
358 : StructuredArguments(Builder.getStructuredArguments(), TakeArgs),
359 3298: NumStructuredArguments(Builder.structuredSize()) {
360 :
142: branch 0 taken
3156: branch 1 taken
3156: branch 2 taken
3156: branch 3 taken
361 3298: if (!TakeArgs)
362 142: return;
363 :
3149: branch 2 taken
7: branch 3 taken
0: branch 6 not taken
0: branch 7 not taken
364 3156: if (Builder.getStructuredArguments() == Builder.getFlatArguments())
365 3149: StructuredArguments.setInt(0);
366 3156: Builder.ReleaseArgs();
367 : }
368 :
369 43: TemplateArgumentList::TemplateArgumentList(const TemplateArgumentList &Other)
370 : : FlatArguments(Other.FlatArguments.getPointer(), 1),
371 : NumFlatArguments(Other.flat_size()),
372 : StructuredArguments(Other.StructuredArguments.getPointer(), 1),
373 43: NumStructuredArguments(Other.NumStructuredArguments) { }
374 :
375 142: TemplateArgumentList::~TemplateArgumentList() {
376 : // FIXME: Deallocate template arguments
377 142: }
378 :
379 : //===----------------------------------------------------------------------===//
380 : // ClassTemplateSpecializationDecl Implementation
381 : //===----------------------------------------------------------------------===//
382 : ClassTemplateSpecializationDecl::
383 : ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK,
384 : DeclContext *DC, SourceLocation L,
385 : ClassTemplateDecl *SpecializedTemplate,
386 : TemplateArgumentListBuilder &Builder,
387 1695: ClassTemplateSpecializationDecl *PrevDecl)
388 : : CXXRecordDecl(DK,
389 : SpecializedTemplate->getTemplatedDecl()->getTagKind(),
390 : DC, L,
391 : // FIXME: Should we use DeclarationName for the name of
392 : // class template specializations?
393 : SpecializedTemplate->getIdentifier(),
394 : PrevDecl),
395 : SpecializedTemplate(SpecializedTemplate),
396 : TemplateArgs(Context, Builder, /*TakeArgs=*/true),
397 1695: SpecializationKind(TSK_Undeclared) {
398 1695: }
399 :
400 : ClassTemplateSpecializationDecl *
401 : ClassTemplateSpecializationDecl::Create(ASTContext &Context,
402 : DeclContext *DC, SourceLocation L,
403 : ClassTemplateDecl *SpecializedTemplate,
404 : TemplateArgumentListBuilder &Builder,
405 1600: ClassTemplateSpecializationDecl *PrevDecl) {
406 : ClassTemplateSpecializationDecl *Result
407 : = new (Context)ClassTemplateSpecializationDecl(Context,
408 : ClassTemplateSpecialization,
409 : DC, L,
410 : SpecializedTemplate,
411 : Builder,
1600: branch 1 taken
0: branch 2 not taken
412 1600: PrevDecl);
413 1600: Context.getTypeDeclType(Result, PrevDecl);
414 1600: return Result;
415 : }
416 :
417 0: void ClassTemplateSpecializationDecl::Destroy(ASTContext &C) {
0: branch 0 not taken
0: branch 1 not taken
418 0: if (SpecializedPartialSpecialization *PartialSpec
419 0: = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
420 0: C.Deallocate(PartialSpec);
421 :
422 0: CXXRecordDecl::Destroy(C);
423 0: }
424 :
425 : void
426 : ClassTemplateSpecializationDecl::getNameForDiagnostic(std::string &S,
427 : const PrintingPolicy &Policy,
428 9: bool Qualified) const {
429 9: NamedDecl::getNameForDiagnostic(S, Policy, Qualified);
430 :
431 9: const TemplateArgumentList &TemplateArgs = getTemplateArgs();
432 : S += TemplateSpecializationType::PrintTemplateArgumentList(
433 : TemplateArgs.getFlatArgumentList(),
434 : TemplateArgs.flat_size(),
435 9: Policy);
436 9: }
437 :
438 : ClassTemplateDecl *
439 8064: ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
460: branch 0 taken
7604: branch 1 taken
440 8064: if (SpecializedPartialSpecialization *PartialSpec
441 8064: = SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
442 460: return PartialSpec->PartialSpecialization->getSpecializedTemplate();
443 7604: return SpecializedTemplate.get<ClassTemplateDecl*>();
444 : }
445 :
446 : //===----------------------------------------------------------------------===//
447 : // ClassTemplatePartialSpecializationDecl Implementation
448 : //===----------------------------------------------------------------------===//
449 : ClassTemplatePartialSpecializationDecl *
450 : ClassTemplatePartialSpecializationDecl::
451 : Create(ASTContext &Context, DeclContext *DC, SourceLocation L,
452 : TemplateParameterList *Params,
453 : ClassTemplateDecl *SpecializedTemplate,
454 : TemplateArgumentListBuilder &Builder,
455 : const TemplateArgumentListInfo &ArgInfos,
456 95: ClassTemplatePartialSpecializationDecl *PrevDecl) {
457 95: unsigned N = ArgInfos.size();
95: branch 1 taken
0: branch 2 not taken
163: branch 4 taken
95: branch 5 taken
458 95: TemplateArgumentLoc *ClonedArgs = new (Context) TemplateArgumentLoc[N];
163: branch 0 taken
95: branch 1 taken
459 258: for (unsigned I = 0; I != N; ++I)
460 163: ClonedArgs[I] = ArgInfos[I];
461 :
462 : ClassTemplatePartialSpecializationDecl *Result
463 : = new (Context)ClassTemplatePartialSpecializationDecl(Context,
464 : DC, L, Params,
465 : SpecializedTemplate,
466 : Builder,
467 : ClonedArgs, N,
95: branch 1 taken
0: branch 2 not taken
468 95: PrevDecl);
469 95: Result->setSpecializationKind(TSK_ExplicitSpecialization);
470 95: Context.getTypeDeclType(Result, PrevDecl);
471 95: return Result;
472 : }
473 :
474 : //===----------------------------------------------------------------------===//
475 : // FriendTemplateDecl Implementation
476 : //===----------------------------------------------------------------------===//
477 :
478 : FriendTemplateDecl *FriendTemplateDecl::Create(ASTContext &Context,
479 : DeclContext *DC,
480 : SourceLocation L,
481 : unsigned NParams,
482 : TemplateParameterList **Params,
483 : FriendUnion Friend,
484 0: SourceLocation FLoc) {
485 : FriendTemplateDecl *Result
0: branch 1 not taken
0: branch 2 not taken
486 0: = new (Context) FriendTemplateDecl(DC, L, NParams, Params, Friend, FLoc);
487 0: return Result;
488 : }
Generated: 2010-02-10 01:31 by zcov