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"
25 #include "llvm/ADT/SmallString.h"
29 using namespace clang;
31 /// \brief Print a template integral argument value.
33 /// \param TemplArg the TemplateArgument instance to print.
35 /// \param Out the raw_ostream instance to use for printing.
36 static void printIntegral(const TemplateArgument &TemplArg,
38 const ::clang::Type *T = TemplArg.getIntegralType().getTypePtr();
39 const llvm::APSInt *Val = TemplArg.getAsIntegral();
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);
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 (Decl *D = getAsDecl()) {
84 if (DeclContext *DC = dyn_cast<DeclContext>(D))
85 return DC->isDependentContext();
86 return D->getDeclContext()->isDependentContext();
96 return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent());
99 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) {
100 if (P->isDependent())
107 llvm_unreachable("Invalid TemplateArgument Kind!");
110 bool TemplateArgument::isInstantiationDependent() const {
113 llvm_unreachable("Should not have a NULL template argument");
116 return getAsType()->isInstantiationDependentType();
119 return getAsTemplate().isInstantiationDependent();
121 case TemplateExpansion:
125 if (Decl *D = getAsDecl()) {
126 if (DeclContext *DC = dyn_cast<DeclContext>(D))
127 return DC->isDependentContext();
128 return D->getDeclContext()->isDependentContext();
137 return getAsExpr()->isInstantiationDependent();
140 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) {
141 if (P->isInstantiationDependent())
148 llvm_unreachable("Invalid TemplateArgument Kind!");
151 bool TemplateArgument::isPackExpansion() const {
160 case TemplateExpansion:
164 return isa<PackExpansionType>(getAsType());
167 return isa<PackExpansionExpr>(getAsExpr());
170 llvm_unreachable("Invalid TemplateArgument Kind!");
173 bool TemplateArgument::containsUnexpandedParameterPack() const {
178 case TemplateExpansion:
182 if (getAsType()->containsUnexpandedParameterPack())
187 if (getAsTemplate().containsUnexpandedParameterPack())
192 if (getAsExpr()->containsUnexpandedParameterPack())
197 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P)
198 if (P->containsUnexpandedParameterPack())
207 llvm::Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const {
208 assert(Kind == TemplateExpansion);
209 if (TemplateArg.NumExpansions)
210 return TemplateArg.NumExpansions - 1;
212 return llvm::Optional<unsigned>();
215 void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID,
216 const ASTContext &Context) const {
223 getAsType().Profile(ID);
227 ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : 0);
231 case TemplateExpansion: {
232 TemplateName Template = getAsTemplateOrTemplatePattern();
233 if (TemplateTemplateParmDecl *TTP
234 = dyn_cast_or_null<TemplateTemplateParmDecl>(
235 Template.getAsTemplateDecl())) {
237 ID.AddInteger(TTP->getDepth());
238 ID.AddInteger(TTP->getPosition());
239 ID.AddBoolean(TTP->isParameterPack());
241 ID.AddBoolean(false);
242 ID.AddPointer(Context.getCanonicalTemplateName(Template)
243 .getAsVoidPointer());
249 getAsIntegral()->Profile(ID);
250 getIntegralType().Profile(ID);
254 getAsExpr()->Profile(ID, Context, true);
258 ID.AddInteger(Args.NumArgs);
259 for (unsigned I = 0; I != Args.NumArgs; ++I)
260 Args.Args[I].Profile(ID, Context);
264 bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const {
265 if (getKind() != Other.getKind()) return false;
273 case TemplateExpansion:
274 return TypeOrValue == Other.TypeOrValue;
277 return getIntegralType() == Other.getIntegralType() &&
278 *getAsIntegral() == *Other.getAsIntegral();
281 if (Args.NumArgs != Other.Args.NumArgs) return false;
282 for (unsigned I = 0, E = Args.NumArgs; I != E; ++I)
283 if (!Args.Args[I].structurallyEquals(Other.Args.Args[I]))
288 llvm_unreachable("Invalid TemplateArgument Kind!");
291 TemplateArgument TemplateArgument::getPackExpansionPattern() const {
292 assert(isPackExpansion());
296 return getAsType()->getAs<PackExpansionType>()->getPattern();
299 return cast<PackExpansionExpr>(getAsExpr())->getPattern();
301 case TemplateExpansion:
302 return TemplateArgument(getAsTemplateOrTemplatePattern());
309 return TemplateArgument();
312 llvm_unreachable("Invalid TemplateArgument Kind!");
315 void TemplateArgument::print(const PrintingPolicy &Policy,
316 raw_ostream &Out) const {
323 PrintingPolicy SubPolicy(Policy);
324 SubPolicy.SuppressStrongLifetime = true;
326 getAsType().getAsStringInternal(TypeStr, SubPolicy);
332 if (NamedDecl *ND = dyn_cast_or_null<NamedDecl>(getAsDecl())) {
333 if (ND->getDeclName()) {
336 Out << "<anonymous>";
345 getAsTemplate().print(Out, Policy);
348 case TemplateExpansion:
349 getAsTemplateOrTemplatePattern().print(Out, Policy);
354 printIntegral(*this, Out);
359 getAsExpr()->printPretty(Out, 0, Policy);
365 for (TemplateArgument::pack_iterator P = pack_begin(), PEnd = pack_end();
372 P->print(Policy, Out);
379 //===----------------------------------------------------------------------===//
380 // TemplateArgumentLoc Implementation
381 //===----------------------------------------------------------------------===//
383 TemplateArgumentLocInfo::TemplateArgumentLocInfo() {
384 memset((void*)this, 0, sizeof(TemplateArgumentLocInfo));
387 SourceRange TemplateArgumentLoc::getSourceRange() const {
388 switch (Argument.getKind()) {
389 case TemplateArgument::Expression:
390 return getSourceExpression()->getSourceRange();
392 case TemplateArgument::Declaration:
393 return getSourceDeclExpression()->getSourceRange();
395 case TemplateArgument::Type:
396 if (TypeSourceInfo *TSI = getTypeSourceInfo())
397 return TSI->getTypeLoc().getSourceRange();
399 return SourceRange();
401 case TemplateArgument::Template:
402 if (getTemplateQualifierLoc())
403 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
404 getTemplateNameLoc());
405 return SourceRange(getTemplateNameLoc());
407 case TemplateArgument::TemplateExpansion:
408 if (getTemplateQualifierLoc())
409 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
410 getTemplateEllipsisLoc());
411 return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc());
413 case TemplateArgument::Integral:
414 case TemplateArgument::Pack:
415 case TemplateArgument::Null:
416 return SourceRange();
419 llvm_unreachable("Invalid TemplateArgument Kind!");
423 TemplateArgumentLoc::getPackExpansionPattern(SourceLocation &Ellipsis,
424 llvm::Optional<unsigned> &NumExpansions,
425 ASTContext &Context) const {
426 assert(Argument.isPackExpansion());
428 switch (Argument.getKind()) {
429 case TemplateArgument::Type: {
430 // FIXME: We shouldn't ever have to worry about missing
432 TypeSourceInfo *ExpansionTSInfo = getTypeSourceInfo();
433 if (!ExpansionTSInfo)
434 ExpansionTSInfo = Context.getTrivialTypeSourceInfo(
435 getArgument().getAsType(),
437 PackExpansionTypeLoc Expansion
438 = cast<PackExpansionTypeLoc>(ExpansionTSInfo->getTypeLoc());
439 Ellipsis = Expansion.getEllipsisLoc();
441 TypeLoc Pattern = Expansion.getPatternLoc();
442 NumExpansions = Expansion.getTypePtr()->getNumExpansions();
444 // FIXME: This is horrible. We know where the source location data is for
445 // the pattern, and we have the pattern's type, but we are forced to copy
446 // them into an ASTContext because TypeSourceInfo bundles them together
447 // and TemplateArgumentLoc traffics in TypeSourceInfo pointers.
448 TypeSourceInfo *PatternTSInfo
449 = Context.CreateTypeSourceInfo(Pattern.getType(),
450 Pattern.getFullDataSize());
451 memcpy(PatternTSInfo->getTypeLoc().getOpaqueData(),
452 Pattern.getOpaqueData(), Pattern.getFullDataSize());
453 return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
457 case TemplateArgument::Expression: {
458 PackExpansionExpr *Expansion
459 = cast<PackExpansionExpr>(Argument.getAsExpr());
460 Expr *Pattern = Expansion->getPattern();
461 Ellipsis = Expansion->getEllipsisLoc();
462 NumExpansions = Expansion->getNumExpansions();
463 return TemplateArgumentLoc(Pattern, Pattern);
466 case TemplateArgument::TemplateExpansion:
467 Ellipsis = getTemplateEllipsisLoc();
468 NumExpansions = Argument.getNumTemplateExpansions();
469 return TemplateArgumentLoc(Argument.getPackExpansionPattern(),
470 getTemplateQualifierLoc(),
471 getTemplateNameLoc());
473 case TemplateArgument::Declaration:
474 case TemplateArgument::Template:
475 case TemplateArgument::Integral:
476 case TemplateArgument::Pack:
477 case TemplateArgument::Null:
478 return TemplateArgumentLoc();
481 llvm_unreachable("Invalid TemplateArgument Kind!");
484 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
485 const TemplateArgument &Arg) {
486 switch (Arg.getKind()) {
487 case TemplateArgument::Null:
488 // This is bad, but not as bad as crashing because of argument
490 return DB << "(null template argument)";
492 case TemplateArgument::Type:
493 return DB << Arg.getAsType();
495 case TemplateArgument::Declaration:
496 if (Decl *D = Arg.getAsDecl())
498 return DB << "nullptr";
500 case TemplateArgument::Integral:
501 return DB << Arg.getAsIntegral()->toString(10);
503 case TemplateArgument::Template:
504 return DB << Arg.getAsTemplate();
506 case TemplateArgument::TemplateExpansion:
507 return DB << Arg.getAsTemplateOrTemplatePattern() << "...";
509 case TemplateArgument::Expression: {
510 // This shouldn't actually ever happen, so it's okay that we're
511 // regurgitating an expression here.
512 // FIXME: We're guessing at LangOptions!
514 llvm::raw_svector_ostream OS(Str);
515 LangOptions LangOpts;
516 LangOpts.CPlusPlus = true;
517 PrintingPolicy Policy(LangOpts);
518 Arg.getAsExpr()->printPretty(OS, 0, Policy);
519 return DB << OS.str();
522 case TemplateArgument::Pack: {
523 // FIXME: We're guessing at LangOptions!
525 llvm::raw_svector_ostream OS(Str);
526 LangOptions LangOpts;
527 LangOpts.CPlusPlus = true;
528 PrintingPolicy Policy(LangOpts);
529 Arg.print(Policy, OS);
530 return DB << OS.str();
534 llvm_unreachable("Invalid TemplateArgument Kind!");
537 const ASTTemplateArgumentListInfo *
538 ASTTemplateArgumentListInfo::Create(ASTContext &C,
539 const TemplateArgumentListInfo &List) {
540 std::size_t size = sizeof(CXXDependentScopeMemberExpr) +
541 ASTTemplateArgumentListInfo::sizeFor(List.size());
542 void *Mem = C.Allocate(size, llvm::alignOf<ASTTemplateArgumentListInfo>());
543 ASTTemplateArgumentListInfo *TAI = new (Mem) ASTTemplateArgumentListInfo();
544 TAI->initializeFrom(List);
548 void ASTTemplateArgumentListInfo::initializeFrom(
549 const TemplateArgumentListInfo &Info) {
550 LAngleLoc = Info.getLAngleLoc();
551 RAngleLoc = Info.getRAngleLoc();
552 NumTemplateArgs = Info.size();
554 TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
555 for (unsigned i = 0; i != NumTemplateArgs; ++i)
556 new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
559 void ASTTemplateArgumentListInfo::initializeFrom(
560 const TemplateArgumentListInfo &Info,
562 bool &InstantiationDependent,
563 bool &ContainsUnexpandedParameterPack) {
564 LAngleLoc = Info.getLAngleLoc();
565 RAngleLoc = Info.getRAngleLoc();
566 NumTemplateArgs = Info.size();
568 TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
569 for (unsigned i = 0; i != NumTemplateArgs; ++i) {
570 Dependent = Dependent || Info[i].getArgument().isDependent();
571 InstantiationDependent = InstantiationDependent ||
572 Info[i].getArgument().isInstantiationDependent();
573 ContainsUnexpandedParameterPack
574 = ContainsUnexpandedParameterPack ||
575 Info[i].getArgument().containsUnexpandedParameterPack();
577 new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
581 void ASTTemplateArgumentListInfo::copyInto(
582 TemplateArgumentListInfo &Info) const {
583 Info.setLAngleLoc(LAngleLoc);
584 Info.setRAngleLoc(RAngleLoc);
585 for (unsigned I = 0; I != NumTemplateArgs; ++I)
586 Info.addArgument(getTemplateArgs()[I]);
589 std::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) {
590 return sizeof(ASTTemplateArgumentListInfo) +
591 sizeof(TemplateArgumentLoc) * NumTemplateArgs;
595 ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc,
596 const TemplateArgumentListInfo &Info) {
597 Base::initializeFrom(Info);
598 setTemplateKeywordLoc(TemplateKWLoc);
602 ASTTemplateKWAndArgsInfo
603 ::initializeFrom(SourceLocation TemplateKWLoc,
604 const TemplateArgumentListInfo &Info,
606 bool &InstantiationDependent,
607 bool &ContainsUnexpandedParameterPack) {
608 Base::initializeFrom(Info, Dependent, InstantiationDependent,
609 ContainsUnexpandedParameterPack);
610 setTemplateKeywordLoc(TemplateKWLoc);
614 ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) {
615 // No explicit template arguments, but template keyword loc is valid.
616 assert(TemplateKWLoc.isValid());
617 LAngleLoc = SourceLocation();
618 RAngleLoc = SourceLocation();
620 setTemplateKeywordLoc(TemplateKWLoc);
624 ASTTemplateKWAndArgsInfo::sizeFor(unsigned NumTemplateArgs) {
625 // Add space for the template keyword location.
626 return Base::sizeFor(NumTemplateArgs) + sizeof(SourceLocation);