1 //===--- TemplateBase.cpp - Common template AST class 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 common classes used throughout C++ template
11 // representations.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "clang/AST/TemplateBase.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclBase.h"
18 #include "clang/AST/DeclTemplate.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/ExprCXX.h"
21 #include "clang/AST/Type.h"
22 #include "clang/AST/TypeLoc.h"
23 #include "clang/Basic/Diagnostic.h"
24 #include "llvm/ADT/FoldingSet.h"
25 #include "llvm/ADT/SmallString.h"
26 #include "llvm/Support/raw_ostream.h"
27 #include <algorithm>
28
29 using namespace clang;
30
31 /// \brief Print a template integral argument value.
32 ///
33 /// \param TemplArg the TemplateArgument instance to print.
34 ///
35 /// \param Out the raw_ostream instance to use for printing.
printIntegral(const TemplateArgument & TemplArg,raw_ostream & Out)36 static void printIntegral(const TemplateArgument &TemplArg,
37 raw_ostream &Out) {
38 const ::clang::Type *T = TemplArg.getIntegralType().getTypePtr();
39 const llvm::APSInt &Val = TemplArg.getAsIntegral();
40
41 if (T->isBooleanType()) {
42 Out << (Val.getBoolValue() ? "true" : "false");
43 } else if (T->isCharType()) {
44 const char Ch = Val.getZExtValue();
45 Out << ((Ch == '\'') ? "'\\" : "'");
46 Out.write_escaped(StringRef(&Ch, 1), /*UseHexEscapes=*/ true);
47 Out << "'";
48 } else {
49 Out << Val;
50 }
51 }
52
53 //===----------------------------------------------------------------------===//
54 // TemplateArgument Implementation
55 //===----------------------------------------------------------------------===//
56
TemplateArgument(ASTContext & Ctx,const llvm::APSInt & Value,QualType Type)57 TemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value,
58 QualType Type)
59 : Kind(Integral) {
60 // Copy the APSInt value into our decomposed form.
61 Integer.BitWidth = Value.getBitWidth();
62 Integer.IsUnsigned = Value.isUnsigned();
63 // If the value is large, we have to get additional memory from the ASTContext
64 unsigned NumWords = Value.getNumWords();
65 if (NumWords > 1) {
66 void *Mem = Ctx.Allocate(NumWords * sizeof(uint64_t));
67 std::memcpy(Mem, Value.getRawData(), NumWords * sizeof(uint64_t));
68 Integer.pVal = static_cast<uint64_t *>(Mem);
69 } else {
70 Integer.VAL = Value.getZExtValue();
71 }
72
73 Integer.Type = Type.getAsOpaquePtr();
74 }
75
CreatePackCopy(ASTContext & Context,const TemplateArgument * Args,unsigned NumArgs)76 TemplateArgument TemplateArgument::CreatePackCopy(ASTContext &Context,
77 const TemplateArgument *Args,
78 unsigned NumArgs) {
79 if (NumArgs == 0)
80 return getEmptyPack();
81
82 TemplateArgument *Storage = new (Context) TemplateArgument [NumArgs];
83 std::copy(Args, Args + NumArgs, Storage);
84 return TemplateArgument(Storage, NumArgs);
85 }
86
isDependent() const87 bool TemplateArgument::isDependent() const {
88 switch (getKind()) {
89 case Null:
90 llvm_unreachable("Should not have a NULL template argument");
91
92 case Type:
93 return getAsType()->isDependentType();
94
95 case Template:
96 return getAsTemplate().isDependent();
97
98 case TemplateExpansion:
99 return true;
100
101 case Declaration:
102 if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
103 return DC->isDependentContext();
104 return getAsDecl()->getDeclContext()->isDependentContext();
105
106 case NullPtr:
107 return false;
108
109 case Integral:
110 // Never dependent
111 return false;
112
113 case Expression:
114 return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent());
115
116 case Pack:
117 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) {
118 if (P->isDependent())
119 return true;
120 }
121
122 return false;
123 }
124
125 llvm_unreachable("Invalid TemplateArgument Kind!");
126 }
127
isInstantiationDependent() const128 bool TemplateArgument::isInstantiationDependent() const {
129 switch (getKind()) {
130 case Null:
131 llvm_unreachable("Should not have a NULL template argument");
132
133 case Type:
134 return getAsType()->isInstantiationDependentType();
135
136 case Template:
137 return getAsTemplate().isInstantiationDependent();
138
139 case TemplateExpansion:
140 return true;
141
142 case Declaration:
143 if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
144 return DC->isDependentContext();
145 return getAsDecl()->getDeclContext()->isDependentContext();
146
147 case NullPtr:
148 return false;
149
150 case Integral:
151 // Never dependent
152 return false;
153
154 case Expression:
155 return getAsExpr()->isInstantiationDependent();
156
157 case Pack:
158 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) {
159 if (P->isInstantiationDependent())
160 return true;
161 }
162
163 return false;
164 }
165
166 llvm_unreachable("Invalid TemplateArgument Kind!");
167 }
168
isPackExpansion() const169 bool TemplateArgument::isPackExpansion() const {
170 switch (getKind()) {
171 case Null:
172 case Declaration:
173 case Integral:
174 case Pack:
175 case Template:
176 case NullPtr:
177 return false;
178
179 case TemplateExpansion:
180 return true;
181
182 case Type:
183 return isa<PackExpansionType>(getAsType());
184
185 case Expression:
186 return isa<PackExpansionExpr>(getAsExpr());
187 }
188
189 llvm_unreachable("Invalid TemplateArgument Kind!");
190 }
191
containsUnexpandedParameterPack() const192 bool TemplateArgument::containsUnexpandedParameterPack() const {
193 switch (getKind()) {
194 case Null:
195 case Declaration:
196 case Integral:
197 case TemplateExpansion:
198 case NullPtr:
199 break;
200
201 case Type:
202 if (getAsType()->containsUnexpandedParameterPack())
203 return true;
204 break;
205
206 case Template:
207 if (getAsTemplate().containsUnexpandedParameterPack())
208 return true;
209 break;
210
211 case Expression:
212 if (getAsExpr()->containsUnexpandedParameterPack())
213 return true;
214 break;
215
216 case Pack:
217 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P)
218 if (P->containsUnexpandedParameterPack())
219 return true;
220
221 break;
222 }
223
224 return false;
225 }
226
getNumTemplateExpansions() const227 Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const {
228 assert(Kind == TemplateExpansion);
229 if (TemplateArg.NumExpansions)
230 return TemplateArg.NumExpansions - 1;
231
232 return None;
233 }
234
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context) const235 void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID,
236 const ASTContext &Context) const {
237 ID.AddInteger(Kind);
238 switch (Kind) {
239 case Null:
240 break;
241
242 case Type:
243 getAsType().Profile(ID);
244 break;
245
246 case Declaration:
247 ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : 0);
248 break;
249
250 case Template:
251 case TemplateExpansion: {
252 TemplateName Template = getAsTemplateOrTemplatePattern();
253 if (TemplateTemplateParmDecl *TTP
254 = dyn_cast_or_null<TemplateTemplateParmDecl>(
255 Template.getAsTemplateDecl())) {
256 ID.AddBoolean(true);
257 ID.AddInteger(TTP->getDepth());
258 ID.AddInteger(TTP->getPosition());
259 ID.AddBoolean(TTP->isParameterPack());
260 } else {
261 ID.AddBoolean(false);
262 ID.AddPointer(Context.getCanonicalTemplateName(Template)
263 .getAsVoidPointer());
264 }
265 break;
266 }
267
268 case Integral:
269 getAsIntegral().Profile(ID);
270 getIntegralType().Profile(ID);
271 break;
272
273 case Expression:
274 getAsExpr()->Profile(ID, Context, true);
275 break;
276
277 case Pack:
278 ID.AddInteger(Args.NumArgs);
279 for (unsigned I = 0; I != Args.NumArgs; ++I)
280 Args.Args[I].Profile(ID, Context);
281 }
282 }
283
structurallyEquals(const TemplateArgument & Other) const284 bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const {
285 if (getKind() != Other.getKind()) return false;
286
287 switch (getKind()) {
288 case Null:
289 case Type:
290 case Expression:
291 case Template:
292 case TemplateExpansion:
293 case NullPtr:
294 return TypeOrValue == Other.TypeOrValue;
295
296 case Declaration:
297 return getAsDecl() == Other.getAsDecl() &&
298 isDeclForReferenceParam() && Other.isDeclForReferenceParam();
299
300 case Integral:
301 return getIntegralType() == Other.getIntegralType() &&
302 getAsIntegral() == Other.getAsIntegral();
303
304 case Pack:
305 if (Args.NumArgs != Other.Args.NumArgs) return false;
306 for (unsigned I = 0, E = Args.NumArgs; I != E; ++I)
307 if (!Args.Args[I].structurallyEquals(Other.Args.Args[I]))
308 return false;
309 return true;
310 }
311
312 llvm_unreachable("Invalid TemplateArgument Kind!");
313 }
314
getPackExpansionPattern() const315 TemplateArgument TemplateArgument::getPackExpansionPattern() const {
316 assert(isPackExpansion());
317
318 switch (getKind()) {
319 case Type:
320 return getAsType()->getAs<PackExpansionType>()->getPattern();
321
322 case Expression:
323 return cast<PackExpansionExpr>(getAsExpr())->getPattern();
324
325 case TemplateExpansion:
326 return TemplateArgument(getAsTemplateOrTemplatePattern());
327
328 case Declaration:
329 case Integral:
330 case Pack:
331 case Null:
332 case Template:
333 case NullPtr:
334 return TemplateArgument();
335 }
336
337 llvm_unreachable("Invalid TemplateArgument Kind!");
338 }
339
print(const PrintingPolicy & Policy,raw_ostream & Out) const340 void TemplateArgument::print(const PrintingPolicy &Policy,
341 raw_ostream &Out) const {
342 switch (getKind()) {
343 case Null:
344 Out << "<no value>";
345 break;
346
347 case Type: {
348 PrintingPolicy SubPolicy(Policy);
349 SubPolicy.SuppressStrongLifetime = true;
350 getAsType().print(Out, SubPolicy);
351 break;
352 }
353
354 case Declaration: {
355 NamedDecl *ND = cast<NamedDecl>(getAsDecl());
356 if (ND->getDeclName()) {
357 // FIXME: distinguish between pointer and reference args?
358 Out << *ND;
359 } else {
360 Out << "<anonymous>";
361 }
362 break;
363 }
364
365 case NullPtr:
366 Out << "nullptr";
367 break;
368
369 case Template:
370 getAsTemplate().print(Out, Policy);
371 break;
372
373 case TemplateExpansion:
374 getAsTemplateOrTemplatePattern().print(Out, Policy);
375 Out << "...";
376 break;
377
378 case Integral: {
379 printIntegral(*this, Out);
380 break;
381 }
382
383 case Expression:
384 getAsExpr()->printPretty(Out, 0, Policy);
385 break;
386
387 case Pack:
388 Out << "<";
389 bool First = true;
390 for (TemplateArgument::pack_iterator P = pack_begin(), PEnd = pack_end();
391 P != PEnd; ++P) {
392 if (First)
393 First = false;
394 else
395 Out << ", ";
396
397 P->print(Policy, Out);
398 }
399 Out << ">";
400 break;
401 }
402 }
403
404 //===----------------------------------------------------------------------===//
405 // TemplateArgumentLoc Implementation
406 //===----------------------------------------------------------------------===//
407
TemplateArgumentLocInfo()408 TemplateArgumentLocInfo::TemplateArgumentLocInfo() {
409 memset((void*)this, 0, sizeof(TemplateArgumentLocInfo));
410 }
411
getSourceRange() const412 SourceRange TemplateArgumentLoc::getSourceRange() const {
413 switch (Argument.getKind()) {
414 case TemplateArgument::Expression:
415 return getSourceExpression()->getSourceRange();
416
417 case TemplateArgument::Declaration:
418 return getSourceDeclExpression()->getSourceRange();
419
420 case TemplateArgument::NullPtr:
421 return getSourceNullPtrExpression()->getSourceRange();
422
423 case TemplateArgument::Type:
424 if (TypeSourceInfo *TSI = getTypeSourceInfo())
425 return TSI->getTypeLoc().getSourceRange();
426 else
427 return SourceRange();
428
429 case TemplateArgument::Template:
430 if (getTemplateQualifierLoc())
431 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
432 getTemplateNameLoc());
433 return SourceRange(getTemplateNameLoc());
434
435 case TemplateArgument::TemplateExpansion:
436 if (getTemplateQualifierLoc())
437 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
438 getTemplateEllipsisLoc());
439 return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc());
440
441 case TemplateArgument::Integral:
442 return getSourceIntegralExpression()->getSourceRange();
443
444 case TemplateArgument::Pack:
445 case TemplateArgument::Null:
446 return SourceRange();
447 }
448
449 llvm_unreachable("Invalid TemplateArgument Kind!");
450 }
451
getPackExpansionPattern(SourceLocation & Ellipsis,Optional<unsigned> & NumExpansions,ASTContext & Context) const452 TemplateArgumentLoc TemplateArgumentLoc::getPackExpansionPattern(
453 SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions,
454 ASTContext &Context) const {
455 assert(Argument.isPackExpansion());
456
457 switch (Argument.getKind()) {
458 case TemplateArgument::Type: {
459 // FIXME: We shouldn't ever have to worry about missing
460 // type-source info!
461 TypeSourceInfo *ExpansionTSInfo = getTypeSourceInfo();
462 if (!ExpansionTSInfo)
463 ExpansionTSInfo = Context.getTrivialTypeSourceInfo(
464 getArgument().getAsType(),
465 Ellipsis);
466 PackExpansionTypeLoc Expansion =
467 ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>();
468 Ellipsis = Expansion.getEllipsisLoc();
469
470 TypeLoc Pattern = Expansion.getPatternLoc();
471 NumExpansions = Expansion.getTypePtr()->getNumExpansions();
472
473 // FIXME: This is horrible. We know where the source location data is for
474 // the pattern, and we have the pattern's type, but we are forced to copy
475 // them into an ASTContext because TypeSourceInfo bundles them together
476 // and TemplateArgumentLoc traffics in TypeSourceInfo pointers.
477 TypeSourceInfo *PatternTSInfo
478 = Context.CreateTypeSourceInfo(Pattern.getType(),
479 Pattern.getFullDataSize());
480 memcpy(PatternTSInfo->getTypeLoc().getOpaqueData(),
481 Pattern.getOpaqueData(), Pattern.getFullDataSize());
482 return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
483 PatternTSInfo);
484 }
485
486 case TemplateArgument::Expression: {
487 PackExpansionExpr *Expansion
488 = cast<PackExpansionExpr>(Argument.getAsExpr());
489 Expr *Pattern = Expansion->getPattern();
490 Ellipsis = Expansion->getEllipsisLoc();
491 NumExpansions = Expansion->getNumExpansions();
492 return TemplateArgumentLoc(Pattern, Pattern);
493 }
494
495 case TemplateArgument::TemplateExpansion:
496 Ellipsis = getTemplateEllipsisLoc();
497 NumExpansions = Argument.getNumTemplateExpansions();
498 return TemplateArgumentLoc(Argument.getPackExpansionPattern(),
499 getTemplateQualifierLoc(),
500 getTemplateNameLoc());
501
502 case TemplateArgument::Declaration:
503 case TemplateArgument::NullPtr:
504 case TemplateArgument::Template:
505 case TemplateArgument::Integral:
506 case TemplateArgument::Pack:
507 case TemplateArgument::Null:
508 return TemplateArgumentLoc();
509 }
510
511 llvm_unreachable("Invalid TemplateArgument Kind!");
512 }
513
operator <<(const DiagnosticBuilder & DB,const TemplateArgument & Arg)514 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
515 const TemplateArgument &Arg) {
516 switch (Arg.getKind()) {
517 case TemplateArgument::Null:
518 // This is bad, but not as bad as crashing because of argument
519 // count mismatches.
520 return DB << "(null template argument)";
521
522 case TemplateArgument::Type:
523 return DB << Arg.getAsType();
524
525 case TemplateArgument::Declaration:
526 return DB << Arg.getAsDecl();
527
528 case TemplateArgument::NullPtr:
529 return DB << "nullptr";
530
531 case TemplateArgument::Integral:
532 return DB << Arg.getAsIntegral().toString(10);
533
534 case TemplateArgument::Template:
535 return DB << Arg.getAsTemplate();
536
537 case TemplateArgument::TemplateExpansion:
538 return DB << Arg.getAsTemplateOrTemplatePattern() << "...";
539
540 case TemplateArgument::Expression: {
541 // This shouldn't actually ever happen, so it's okay that we're
542 // regurgitating an expression here.
543 // FIXME: We're guessing at LangOptions!
544 SmallString<32> Str;
545 llvm::raw_svector_ostream OS(Str);
546 LangOptions LangOpts;
547 LangOpts.CPlusPlus = true;
548 PrintingPolicy Policy(LangOpts);
549 Arg.getAsExpr()->printPretty(OS, 0, Policy);
550 return DB << OS.str();
551 }
552
553 case TemplateArgument::Pack: {
554 // FIXME: We're guessing at LangOptions!
555 SmallString<32> Str;
556 llvm::raw_svector_ostream OS(Str);
557 LangOptions LangOpts;
558 LangOpts.CPlusPlus = true;
559 PrintingPolicy Policy(LangOpts);
560 Arg.print(Policy, OS);
561 return DB << OS.str();
562 }
563 }
564
565 llvm_unreachable("Invalid TemplateArgument Kind!");
566 }
567
568 const ASTTemplateArgumentListInfo *
Create(ASTContext & C,const TemplateArgumentListInfo & List)569 ASTTemplateArgumentListInfo::Create(ASTContext &C,
570 const TemplateArgumentListInfo &List) {
571 std::size_t size = ASTTemplateArgumentListInfo::sizeFor(List.size());
572 void *Mem = C.Allocate(size, llvm::alignOf<ASTTemplateArgumentListInfo>());
573 ASTTemplateArgumentListInfo *TAI = new (Mem) ASTTemplateArgumentListInfo();
574 TAI->initializeFrom(List);
575 return TAI;
576 }
577
initializeFrom(const TemplateArgumentListInfo & Info)578 void ASTTemplateArgumentListInfo::initializeFrom(
579 const TemplateArgumentListInfo &Info) {
580 LAngleLoc = Info.getLAngleLoc();
581 RAngleLoc = Info.getRAngleLoc();
582 NumTemplateArgs = Info.size();
583
584 TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
585 for (unsigned i = 0; i != NumTemplateArgs; ++i)
586 new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
587 }
588
initializeFrom(const TemplateArgumentListInfo & Info,bool & Dependent,bool & InstantiationDependent,bool & ContainsUnexpandedParameterPack)589 void ASTTemplateArgumentListInfo::initializeFrom(
590 const TemplateArgumentListInfo &Info,
591 bool &Dependent,
592 bool &InstantiationDependent,
593 bool &ContainsUnexpandedParameterPack) {
594 LAngleLoc = Info.getLAngleLoc();
595 RAngleLoc = Info.getRAngleLoc();
596 NumTemplateArgs = Info.size();
597
598 TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
599 for (unsigned i = 0; i != NumTemplateArgs; ++i) {
600 Dependent = Dependent || Info[i].getArgument().isDependent();
601 InstantiationDependent = InstantiationDependent ||
602 Info[i].getArgument().isInstantiationDependent();
603 ContainsUnexpandedParameterPack
604 = ContainsUnexpandedParameterPack ||
605 Info[i].getArgument().containsUnexpandedParameterPack();
606
607 new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
608 }
609 }
610
copyInto(TemplateArgumentListInfo & Info) const611 void ASTTemplateArgumentListInfo::copyInto(
612 TemplateArgumentListInfo &Info) const {
613 Info.setLAngleLoc(LAngleLoc);
614 Info.setRAngleLoc(RAngleLoc);
615 for (unsigned I = 0; I != NumTemplateArgs; ++I)
616 Info.addArgument(getTemplateArgs()[I]);
617 }
618
sizeFor(unsigned NumTemplateArgs)619 std::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) {
620 return sizeof(ASTTemplateArgumentListInfo) +
621 sizeof(TemplateArgumentLoc) * NumTemplateArgs;
622 }
623
624 void
initializeFrom(SourceLocation TemplateKWLoc,const TemplateArgumentListInfo & Info)625 ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc,
626 const TemplateArgumentListInfo &Info) {
627 Base::initializeFrom(Info);
628 setTemplateKeywordLoc(TemplateKWLoc);
629 }
630
631 void
632 ASTTemplateKWAndArgsInfo
initializeFrom(SourceLocation TemplateKWLoc,const TemplateArgumentListInfo & Info,bool & Dependent,bool & InstantiationDependent,bool & ContainsUnexpandedParameterPack)633 ::initializeFrom(SourceLocation TemplateKWLoc,
634 const TemplateArgumentListInfo &Info,
635 bool &Dependent,
636 bool &InstantiationDependent,
637 bool &ContainsUnexpandedParameterPack) {
638 Base::initializeFrom(Info, Dependent, InstantiationDependent,
639 ContainsUnexpandedParameterPack);
640 setTemplateKeywordLoc(TemplateKWLoc);
641 }
642
643 void
initializeFrom(SourceLocation TemplateKWLoc)644 ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) {
645 // No explicit template arguments, but template keyword loc is valid.
646 assert(TemplateKWLoc.isValid());
647 LAngleLoc = SourceLocation();
648 RAngleLoc = SourceLocation();
649 NumTemplateArgs = 0;
650 setTemplateKeywordLoc(TemplateKWLoc);
651 }
652
653 std::size_t
sizeFor(unsigned NumTemplateArgs)654 ASTTemplateKWAndArgsInfo::sizeFor(unsigned NumTemplateArgs) {
655 // Add space for the template keyword location.
656 // FIXME: There's room for this in the padding before the template args in
657 // 64-bit builds.
658 return Base::sizeFor(NumTemplateArgs) + sizeof(SourceLocation);
659 }
660