1 //===--- TemplateBase.cpp - Common template AST class implementation ------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements common classes used throughout C++ template
13 //===----------------------------------------------------------------------===//
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"
28 using namespace clang;
30 /// \brief Print a template integral argument value.
32 /// \param TemplArg the TemplateArgument instance to print.
34 /// \param Out the raw_ostream instance to use for printing.
35 static void printIntegral(const TemplateArgument &TemplArg,
37 const ::clang::Type *T = TemplArg.getIntegralType().getTypePtr();
38 const llvm::APSInt *Val = TemplArg.getAsIntegral();
40 if (T->isBooleanType()) {
41 Out << (Val->getBoolValue() ? "true" : "false");
42 } else if (T->isCharType()) {
43 const unsigned char Ch = Val->getZExtValue();
44 const std::string Str(1, Ch);
45 Out << ((Ch == '\'') ? "'\\" : "'");
46 Out.write_escaped(Str, /*UseHexEscapes=*/ true);
49 Out << Val->toString(10);
53 //===----------------------------------------------------------------------===//
54 // TemplateArgument Implementation
55 //===----------------------------------------------------------------------===//
57 TemplateArgument TemplateArgument::CreatePackCopy(ASTContext &Context,
58 const TemplateArgument *Args,
61 return TemplateArgument(0, 0);
63 TemplateArgument *Storage = new (Context) TemplateArgument [NumArgs];
64 std::copy(Args, Args + NumArgs, Storage);
65 return TemplateArgument(Storage, NumArgs);
68 bool TemplateArgument::isDependent() const {
71 llvm_unreachable("Should not have a NULL template argument");
74 return getAsType()->isDependentType();
77 return getAsTemplate().isDependent();
79 case TemplateExpansion:
83 if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
84 return DC->isDependentContext();
85 return getAsDecl()->getDeclContext()->isDependentContext();
92 return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent());
95 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) {
103 llvm_unreachable("Invalid TemplateArgument Kind!");
106 bool TemplateArgument::isInstantiationDependent() const {
109 llvm_unreachable("Should not have a NULL template argument");
112 return getAsType()->isInstantiationDependentType();
115 return getAsTemplate().isInstantiationDependent();
117 case TemplateExpansion:
121 if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
122 return DC->isDependentContext();
123 return getAsDecl()->getDeclContext()->isDependentContext();
130 return getAsExpr()->isInstantiationDependent();
133 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) {
134 if (P->isInstantiationDependent())
141 llvm_unreachable("Invalid TemplateArgument Kind!");
144 bool TemplateArgument::isPackExpansion() const {
153 case TemplateExpansion:
157 return isa<PackExpansionType>(getAsType());
160 return isa<PackExpansionExpr>(getAsExpr());
163 llvm_unreachable("Invalid TemplateArgument Kind!");
166 bool TemplateArgument::containsUnexpandedParameterPack() const {
171 case TemplateExpansion:
175 if (getAsType()->containsUnexpandedParameterPack())
180 if (getAsTemplate().containsUnexpandedParameterPack())
185 if (getAsExpr()->containsUnexpandedParameterPack())
190 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P)
191 if (P->containsUnexpandedParameterPack())
200 llvm::Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const {
201 assert(Kind == TemplateExpansion);
202 if (TemplateArg.NumExpansions)
203 return TemplateArg.NumExpansions - 1;
205 return llvm::Optional<unsigned>();
208 void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID,
209 const ASTContext &Context) const {
216 getAsType().Profile(ID);
220 ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : 0);
224 case TemplateExpansion: {
225 TemplateName Template = getAsTemplateOrTemplatePattern();
226 if (TemplateTemplateParmDecl *TTP
227 = dyn_cast_or_null<TemplateTemplateParmDecl>(
228 Template.getAsTemplateDecl())) {
230 ID.AddInteger(TTP->getDepth());
231 ID.AddInteger(TTP->getPosition());
232 ID.AddBoolean(TTP->isParameterPack());
234 ID.AddBoolean(false);
235 ID.AddPointer(Context.getCanonicalTemplateName(Template)
236 .getAsVoidPointer());
242 getAsIntegral()->Profile(ID);
243 getIntegralType().Profile(ID);
247 getAsExpr()->Profile(ID, Context, true);
251 ID.AddInteger(Args.NumArgs);
252 for (unsigned I = 0; I != Args.NumArgs; ++I)
253 Args.Args[I].Profile(ID, Context);
257 bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const {
258 if (getKind() != Other.getKind()) return false;
266 case TemplateExpansion:
267 return TypeOrValue == Other.TypeOrValue;
270 return getIntegralType() == Other.getIntegralType() &&
271 *getAsIntegral() == *Other.getAsIntegral();
274 if (Args.NumArgs != Other.Args.NumArgs) return false;
275 for (unsigned I = 0, E = Args.NumArgs; I != E; ++I)
276 if (!Args.Args[I].structurallyEquals(Other.Args.Args[I]))
281 llvm_unreachable("Invalid TemplateArgument Kind!");
284 TemplateArgument TemplateArgument::getPackExpansionPattern() const {
285 assert(isPackExpansion());
289 return getAsType()->getAs<PackExpansionType>()->getPattern();
292 return cast<PackExpansionExpr>(getAsExpr())->getPattern();
294 case TemplateExpansion:
295 return TemplateArgument(getAsTemplateOrTemplatePattern());
302 return TemplateArgument();
305 llvm_unreachable("Invalid TemplateArgument Kind!");
308 void TemplateArgument::print(const PrintingPolicy &Policy,
309 raw_ostream &Out) const {
316 PrintingPolicy SubPolicy(Policy);
317 SubPolicy.SuppressStrongLifetime = true;
319 getAsType().getAsStringInternal(TypeStr, SubPolicy);
326 if (NamedDecl *ND = dyn_cast_or_null<NamedDecl>(getAsDecl())) {
327 if (ND->getDeclName()) {
329 Out << ND->getNameAsString();
334 Out << "<anonymous>";
340 getAsTemplate().print(Out, Policy);
343 case TemplateExpansion:
344 getAsTemplateOrTemplatePattern().print(Out, Policy);
349 printIntegral(*this, Out);
354 getAsExpr()->printPretty(Out, 0, Policy);
360 for (TemplateArgument::pack_iterator P = pack_begin(), PEnd = pack_end();
367 P->print(Policy, Out);
374 //===----------------------------------------------------------------------===//
375 // TemplateArgumentLoc Implementation
376 //===----------------------------------------------------------------------===//
378 TemplateArgumentLocInfo::TemplateArgumentLocInfo() {
379 memset((void*)this, 0, sizeof(TemplateArgumentLocInfo));
382 SourceRange TemplateArgumentLoc::getSourceRange() const {
383 switch (Argument.getKind()) {
384 case TemplateArgument::Expression:
385 return getSourceExpression()->getSourceRange();
387 case TemplateArgument::Declaration:
388 return getSourceDeclExpression()->getSourceRange();
390 case TemplateArgument::Type:
391 if (TypeSourceInfo *TSI = getTypeSourceInfo())
392 return TSI->getTypeLoc().getSourceRange();
394 return SourceRange();
396 case TemplateArgument::Template:
397 if (getTemplateQualifierLoc())
398 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
399 getTemplateNameLoc());
400 return SourceRange(getTemplateNameLoc());
402 case TemplateArgument::TemplateExpansion:
403 if (getTemplateQualifierLoc())
404 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
405 getTemplateEllipsisLoc());
406 return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc());
408 case TemplateArgument::Integral:
409 case TemplateArgument::Pack:
410 case TemplateArgument::Null:
411 return SourceRange();
414 llvm_unreachable("Invalid TemplateArgument Kind!");
418 TemplateArgumentLoc::getPackExpansionPattern(SourceLocation &Ellipsis,
419 llvm::Optional<unsigned> &NumExpansions,
420 ASTContext &Context) const {
421 assert(Argument.isPackExpansion());
423 switch (Argument.getKind()) {
424 case TemplateArgument::Type: {
425 // FIXME: We shouldn't ever have to worry about missing
427 TypeSourceInfo *ExpansionTSInfo = getTypeSourceInfo();
428 if (!ExpansionTSInfo)
429 ExpansionTSInfo = Context.getTrivialTypeSourceInfo(
430 getArgument().getAsType(),
432 PackExpansionTypeLoc Expansion
433 = cast<PackExpansionTypeLoc>(ExpansionTSInfo->getTypeLoc());
434 Ellipsis = Expansion.getEllipsisLoc();
436 TypeLoc Pattern = Expansion.getPatternLoc();
437 NumExpansions = Expansion.getTypePtr()->getNumExpansions();
439 // FIXME: This is horrible. We know where the source location data is for
440 // the pattern, and we have the pattern's type, but we are forced to copy
441 // them into an ASTContext because TypeSourceInfo bundles them together
442 // and TemplateArgumentLoc traffics in TypeSourceInfo pointers.
443 TypeSourceInfo *PatternTSInfo
444 = Context.CreateTypeSourceInfo(Pattern.getType(),
445 Pattern.getFullDataSize());
446 memcpy(PatternTSInfo->getTypeLoc().getOpaqueData(),
447 Pattern.getOpaqueData(), Pattern.getFullDataSize());
448 return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
452 case TemplateArgument::Expression: {
453 PackExpansionExpr *Expansion
454 = cast<PackExpansionExpr>(Argument.getAsExpr());
455 Expr *Pattern = Expansion->getPattern();
456 Ellipsis = Expansion->getEllipsisLoc();
457 NumExpansions = Expansion->getNumExpansions();
458 return TemplateArgumentLoc(Pattern, Pattern);
461 case TemplateArgument::TemplateExpansion:
462 Ellipsis = getTemplateEllipsisLoc();
463 NumExpansions = Argument.getNumTemplateExpansions();
464 return TemplateArgumentLoc(Argument.getPackExpansionPattern(),
465 getTemplateQualifierLoc(),
466 getTemplateNameLoc());
468 case TemplateArgument::Declaration:
469 case TemplateArgument::Template:
470 case TemplateArgument::Integral:
471 case TemplateArgument::Pack:
472 case TemplateArgument::Null:
473 return TemplateArgumentLoc();
476 llvm_unreachable("Invalid TemplateArgument Kind!");
479 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
480 const TemplateArgument &Arg) {
481 switch (Arg.getKind()) {
482 case TemplateArgument::Null:
483 // This is bad, but not as bad as crashing because of argument
485 return DB << "(null template argument)";
487 case TemplateArgument::Type:
488 return DB << Arg.getAsType();
490 case TemplateArgument::Declaration:
491 return DB << Arg.getAsDecl();
493 case TemplateArgument::Integral:
494 return DB << Arg.getAsIntegral()->toString(10);
496 case TemplateArgument::Template:
497 return DB << Arg.getAsTemplate();
499 case TemplateArgument::TemplateExpansion:
500 return DB << Arg.getAsTemplateOrTemplatePattern() << "...";
502 case TemplateArgument::Expression: {
503 // This shouldn't actually ever happen, so it's okay that we're
504 // regurgitating an expression here.
505 // FIXME: We're guessing at LangOptions!
506 llvm::SmallString<32> Str;
507 llvm::raw_svector_ostream OS(Str);
508 LangOptions LangOpts;
509 LangOpts.CPlusPlus = true;
510 PrintingPolicy Policy(LangOpts);
511 Arg.getAsExpr()->printPretty(OS, 0, Policy);
512 return DB << OS.str();
515 case TemplateArgument::Pack: {
516 // FIXME: We're guessing at LangOptions!
517 llvm::SmallString<32> Str;
518 llvm::raw_svector_ostream OS(Str);
519 LangOptions LangOpts;
520 LangOpts.CPlusPlus = true;
521 PrintingPolicy Policy(LangOpts);
522 Arg.print(Policy, OS);
523 return DB << OS.str();
527 llvm_unreachable("Invalid TemplateArgument Kind!");
530 const ASTTemplateArgumentListInfo *
531 ASTTemplateArgumentListInfo::Create(ASTContext &C,
532 const TemplateArgumentListInfo &List) {
533 std::size_t size = sizeof(CXXDependentScopeMemberExpr) +
534 ASTTemplateArgumentListInfo::sizeFor(List);
535 void *Mem = C.Allocate(size, llvm::alignOf<ASTTemplateArgumentListInfo>());
536 ASTTemplateArgumentListInfo *TAI = new (Mem) ASTTemplateArgumentListInfo();
537 TAI->initializeFrom(List);
541 void ASTTemplateArgumentListInfo::initializeFrom(
542 const TemplateArgumentListInfo &Info) {
543 LAngleLoc = Info.getLAngleLoc();
544 RAngleLoc = Info.getRAngleLoc();
545 NumTemplateArgs = Info.size();
547 TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
548 for (unsigned i = 0; i != NumTemplateArgs; ++i)
549 new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
552 void ASTTemplateArgumentListInfo::initializeFrom(
553 const TemplateArgumentListInfo &Info,
555 bool &InstantiationDependent,
556 bool &ContainsUnexpandedParameterPack) {
557 LAngleLoc = Info.getLAngleLoc();
558 RAngleLoc = Info.getRAngleLoc();
559 NumTemplateArgs = Info.size();
561 TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
562 for (unsigned i = 0; i != NumTemplateArgs; ++i) {
563 Dependent = Dependent || Info[i].getArgument().isDependent();
564 InstantiationDependent = InstantiationDependent ||
565 Info[i].getArgument().isInstantiationDependent();
566 ContainsUnexpandedParameterPack
567 = ContainsUnexpandedParameterPack ||
568 Info[i].getArgument().containsUnexpandedParameterPack();
570 new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
574 void ASTTemplateArgumentListInfo::copyInto(
575 TemplateArgumentListInfo &Info) const {
576 Info.setLAngleLoc(LAngleLoc);
577 Info.setRAngleLoc(RAngleLoc);
578 for (unsigned I = 0; I != NumTemplateArgs; ++I)
579 Info.addArgument(getTemplateArgs()[I]);
582 std::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) {
583 return sizeof(ASTTemplateArgumentListInfo) +
584 sizeof(TemplateArgumentLoc) * NumTemplateArgs;
587 std::size_t ASTTemplateArgumentListInfo::sizeFor(
588 const TemplateArgumentListInfo &Info) {
589 return sizeFor(Info.size());