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"
26 #include "llvm/Support/raw_ostream.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);
53 //===----------------------------------------------------------------------===//
54 // TemplateArgument Implementation
55 //===----------------------------------------------------------------------===//
57 TemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value,
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();
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);
70 Integer.VAL = Value.getZExtValue();
73 Integer.Type = Type.getAsOpaquePtr();
76 TemplateArgument TemplateArgument::CreatePackCopy(ASTContext &Context,
77 const TemplateArgument *Args,
80 return getEmptyPack();
82 TemplateArgument *Storage = new (Context) TemplateArgument [NumArgs];
83 std::copy(Args, Args + NumArgs, Storage);
84 return TemplateArgument(Storage, NumArgs);
87 bool TemplateArgument::isDependent() const {
90 llvm_unreachable("Should not have a NULL template argument");
93 return getAsType()->isDependentType();
96 return getAsTemplate().isDependent();
98 case TemplateExpansion:
102 if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
103 return DC->isDependentContext();
104 return getAsDecl()->getDeclContext()->isDependentContext();
114 return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent());
117 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) {
118 if (P->isDependent())
125 llvm_unreachable("Invalid TemplateArgument Kind!");
128 bool TemplateArgument::isInstantiationDependent() const {
131 llvm_unreachable("Should not have a NULL template argument");
134 return getAsType()->isInstantiationDependentType();
137 return getAsTemplate().isInstantiationDependent();
139 case TemplateExpansion:
143 if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
144 return DC->isDependentContext();
145 return getAsDecl()->getDeclContext()->isDependentContext();
155 return getAsExpr()->isInstantiationDependent();
158 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) {
159 if (P->isInstantiationDependent())
166 llvm_unreachable("Invalid TemplateArgument Kind!");
169 bool TemplateArgument::isPackExpansion() const {
179 case TemplateExpansion:
183 return isa<PackExpansionType>(getAsType());
186 return isa<PackExpansionExpr>(getAsExpr());
189 llvm_unreachable("Invalid TemplateArgument Kind!");
192 bool TemplateArgument::containsUnexpandedParameterPack() const {
197 case TemplateExpansion:
202 if (getAsType()->containsUnexpandedParameterPack())
207 if (getAsTemplate().containsUnexpandedParameterPack())
212 if (getAsExpr()->containsUnexpandedParameterPack())
217 for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P)
218 if (P->containsUnexpandedParameterPack())
227 llvm::Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const {
228 assert(Kind == TemplateExpansion);
229 if (TemplateArg.NumExpansions)
230 return TemplateArg.NumExpansions - 1;
232 return llvm::Optional<unsigned>();
235 void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID,
236 const ASTContext &Context) const {
243 getAsType().Profile(ID);
247 ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : 0);
251 case TemplateExpansion: {
252 TemplateName Template = getAsTemplateOrTemplatePattern();
253 if (TemplateTemplateParmDecl *TTP
254 = dyn_cast_or_null<TemplateTemplateParmDecl>(
255 Template.getAsTemplateDecl())) {
257 ID.AddInteger(TTP->getDepth());
258 ID.AddInteger(TTP->getPosition());
259 ID.AddBoolean(TTP->isParameterPack());
261 ID.AddBoolean(false);
262 ID.AddPointer(Context.getCanonicalTemplateName(Template)
263 .getAsVoidPointer());
269 getAsIntegral().Profile(ID);
270 getIntegralType().Profile(ID);
274 getAsExpr()->Profile(ID, Context, true);
278 ID.AddInteger(Args.NumArgs);
279 for (unsigned I = 0; I != Args.NumArgs; ++I)
280 Args.Args[I].Profile(ID, Context);
284 bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const {
285 if (getKind() != Other.getKind()) return false;
292 case TemplateExpansion:
294 return TypeOrValue == Other.TypeOrValue;
297 return getAsDecl() == Other.getAsDecl() &&
298 isDeclForReferenceParam() && Other.isDeclForReferenceParam();
301 return getIntegralType() == Other.getIntegralType() &&
302 getAsIntegral() == Other.getAsIntegral();
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]))
312 llvm_unreachable("Invalid TemplateArgument Kind!");
315 TemplateArgument TemplateArgument::getPackExpansionPattern() const {
316 assert(isPackExpansion());
320 return getAsType()->getAs<PackExpansionType>()->getPattern();
323 return cast<PackExpansionExpr>(getAsExpr())->getPattern();
325 case TemplateExpansion:
326 return TemplateArgument(getAsTemplateOrTemplatePattern());
334 return TemplateArgument();
337 llvm_unreachable("Invalid TemplateArgument Kind!");
340 void TemplateArgument::print(const PrintingPolicy &Policy,
341 raw_ostream &Out) const {
348 PrintingPolicy SubPolicy(Policy);
349 SubPolicy.SuppressStrongLifetime = true;
351 getAsType().getAsStringInternal(TypeStr, SubPolicy);
357 NamedDecl *ND = cast<NamedDecl>(getAsDecl());
358 if (ND->getDeclName()) {
359 // FIXME: distinguish between pointer and reference args?
362 Out << "<anonymous>";
372 getAsTemplate().print(Out, Policy);
375 case TemplateExpansion:
376 getAsTemplateOrTemplatePattern().print(Out, Policy);
381 printIntegral(*this, Out);
386 getAsExpr()->printPretty(Out, 0, Policy);
392 for (TemplateArgument::pack_iterator P = pack_begin(), PEnd = pack_end();
399 P->print(Policy, Out);
406 //===----------------------------------------------------------------------===//
407 // TemplateArgumentLoc Implementation
408 //===----------------------------------------------------------------------===//
410 TemplateArgumentLocInfo::TemplateArgumentLocInfo() {
411 memset((void*)this, 0, sizeof(TemplateArgumentLocInfo));
414 SourceRange TemplateArgumentLoc::getSourceRange() const {
415 switch (Argument.getKind()) {
416 case TemplateArgument::Expression:
417 return getSourceExpression()->getSourceRange();
419 case TemplateArgument::Declaration:
420 return getSourceDeclExpression()->getSourceRange();
422 case TemplateArgument::NullPtr:
423 return getSourceNullPtrExpression()->getSourceRange();
425 case TemplateArgument::Type:
426 if (TypeSourceInfo *TSI = getTypeSourceInfo())
427 return TSI->getTypeLoc().getSourceRange();
429 return SourceRange();
431 case TemplateArgument::Template:
432 if (getTemplateQualifierLoc())
433 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
434 getTemplateNameLoc());
435 return SourceRange(getTemplateNameLoc());
437 case TemplateArgument::TemplateExpansion:
438 if (getTemplateQualifierLoc())
439 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
440 getTemplateEllipsisLoc());
441 return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc());
443 case TemplateArgument::Integral:
444 return getSourceIntegralExpression()->getSourceRange();
446 case TemplateArgument::Pack:
447 case TemplateArgument::Null:
448 return SourceRange();
451 llvm_unreachable("Invalid TemplateArgument Kind!");
455 TemplateArgumentLoc::getPackExpansionPattern(SourceLocation &Ellipsis,
456 llvm::Optional<unsigned> &NumExpansions,
457 ASTContext &Context) const {
458 assert(Argument.isPackExpansion());
460 switch (Argument.getKind()) {
461 case TemplateArgument::Type: {
462 // FIXME: We shouldn't ever have to worry about missing
464 TypeSourceInfo *ExpansionTSInfo = getTypeSourceInfo();
465 if (!ExpansionTSInfo)
466 ExpansionTSInfo = Context.getTrivialTypeSourceInfo(
467 getArgument().getAsType(),
469 PackExpansionTypeLoc Expansion =
470 ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>();
471 Ellipsis = Expansion.getEllipsisLoc();
473 TypeLoc Pattern = Expansion.getPatternLoc();
474 NumExpansions = Expansion.getTypePtr()->getNumExpansions();
476 // FIXME: This is horrible. We know where the source location data is for
477 // the pattern, and we have the pattern's type, but we are forced to copy
478 // them into an ASTContext because TypeSourceInfo bundles them together
479 // and TemplateArgumentLoc traffics in TypeSourceInfo pointers.
480 TypeSourceInfo *PatternTSInfo
481 = Context.CreateTypeSourceInfo(Pattern.getType(),
482 Pattern.getFullDataSize());
483 memcpy(PatternTSInfo->getTypeLoc().getOpaqueData(),
484 Pattern.getOpaqueData(), Pattern.getFullDataSize());
485 return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
489 case TemplateArgument::Expression: {
490 PackExpansionExpr *Expansion
491 = cast<PackExpansionExpr>(Argument.getAsExpr());
492 Expr *Pattern = Expansion->getPattern();
493 Ellipsis = Expansion->getEllipsisLoc();
494 NumExpansions = Expansion->getNumExpansions();
495 return TemplateArgumentLoc(Pattern, Pattern);
498 case TemplateArgument::TemplateExpansion:
499 Ellipsis = getTemplateEllipsisLoc();
500 NumExpansions = Argument.getNumTemplateExpansions();
501 return TemplateArgumentLoc(Argument.getPackExpansionPattern(),
502 getTemplateQualifierLoc(),
503 getTemplateNameLoc());
505 case TemplateArgument::Declaration:
506 case TemplateArgument::NullPtr:
507 case TemplateArgument::Template:
508 case TemplateArgument::Integral:
509 case TemplateArgument::Pack:
510 case TemplateArgument::Null:
511 return TemplateArgumentLoc();
514 llvm_unreachable("Invalid TemplateArgument Kind!");
517 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
518 const TemplateArgument &Arg) {
519 switch (Arg.getKind()) {
520 case TemplateArgument::Null:
521 // This is bad, but not as bad as crashing because of argument
523 return DB << "(null template argument)";
525 case TemplateArgument::Type:
526 return DB << Arg.getAsType();
528 case TemplateArgument::Declaration:
529 return DB << Arg.getAsDecl();
531 case TemplateArgument::NullPtr:
532 return DB << "nullptr";
534 case TemplateArgument::Integral:
535 return DB << Arg.getAsIntegral().toString(10);
537 case TemplateArgument::Template:
538 return DB << Arg.getAsTemplate();
540 case TemplateArgument::TemplateExpansion:
541 return DB << Arg.getAsTemplateOrTemplatePattern() << "...";
543 case TemplateArgument::Expression: {
544 // This shouldn't actually ever happen, so it's okay that we're
545 // regurgitating an expression here.
546 // FIXME: We're guessing at LangOptions!
548 llvm::raw_svector_ostream OS(Str);
549 LangOptions LangOpts;
550 LangOpts.CPlusPlus = true;
551 PrintingPolicy Policy(LangOpts);
552 Arg.getAsExpr()->printPretty(OS, 0, Policy);
553 return DB << OS.str();
556 case TemplateArgument::Pack: {
557 // FIXME: We're guessing at LangOptions!
559 llvm::raw_svector_ostream OS(Str);
560 LangOptions LangOpts;
561 LangOpts.CPlusPlus = true;
562 PrintingPolicy Policy(LangOpts);
563 Arg.print(Policy, OS);
564 return DB << OS.str();
568 llvm_unreachable("Invalid TemplateArgument Kind!");
571 const ASTTemplateArgumentListInfo *
572 ASTTemplateArgumentListInfo::Create(ASTContext &C,
573 const TemplateArgumentListInfo &List) {
574 std::size_t size = ASTTemplateArgumentListInfo::sizeFor(List.size());
575 void *Mem = C.Allocate(size, llvm::alignOf<ASTTemplateArgumentListInfo>());
576 ASTTemplateArgumentListInfo *TAI = new (Mem) ASTTemplateArgumentListInfo();
577 TAI->initializeFrom(List);
581 void ASTTemplateArgumentListInfo::initializeFrom(
582 const TemplateArgumentListInfo &Info) {
583 LAngleLoc = Info.getLAngleLoc();
584 RAngleLoc = Info.getRAngleLoc();
585 NumTemplateArgs = Info.size();
587 TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
588 for (unsigned i = 0; i != NumTemplateArgs; ++i)
589 new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
592 void ASTTemplateArgumentListInfo::initializeFrom(
593 const TemplateArgumentListInfo &Info,
595 bool &InstantiationDependent,
596 bool &ContainsUnexpandedParameterPack) {
597 LAngleLoc = Info.getLAngleLoc();
598 RAngleLoc = Info.getRAngleLoc();
599 NumTemplateArgs = Info.size();
601 TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
602 for (unsigned i = 0; i != NumTemplateArgs; ++i) {
603 Dependent = Dependent || Info[i].getArgument().isDependent();
604 InstantiationDependent = InstantiationDependent ||
605 Info[i].getArgument().isInstantiationDependent();
606 ContainsUnexpandedParameterPack
607 = ContainsUnexpandedParameterPack ||
608 Info[i].getArgument().containsUnexpandedParameterPack();
610 new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
614 void ASTTemplateArgumentListInfo::copyInto(
615 TemplateArgumentListInfo &Info) const {
616 Info.setLAngleLoc(LAngleLoc);
617 Info.setRAngleLoc(RAngleLoc);
618 for (unsigned I = 0; I != NumTemplateArgs; ++I)
619 Info.addArgument(getTemplateArgs()[I]);
622 std::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) {
623 return sizeof(ASTTemplateArgumentListInfo) +
624 sizeof(TemplateArgumentLoc) * NumTemplateArgs;
628 ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc,
629 const TemplateArgumentListInfo &Info) {
630 Base::initializeFrom(Info);
631 setTemplateKeywordLoc(TemplateKWLoc);
635 ASTTemplateKWAndArgsInfo
636 ::initializeFrom(SourceLocation TemplateKWLoc,
637 const TemplateArgumentListInfo &Info,
639 bool &InstantiationDependent,
640 bool &ContainsUnexpandedParameterPack) {
641 Base::initializeFrom(Info, Dependent, InstantiationDependent,
642 ContainsUnexpandedParameterPack);
643 setTemplateKeywordLoc(TemplateKWLoc);
647 ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) {
648 // No explicit template arguments, but template keyword loc is valid.
649 assert(TemplateKWLoc.isValid());
650 LAngleLoc = SourceLocation();
651 RAngleLoc = SourceLocation();
653 setTemplateKeywordLoc(TemplateKWLoc);
657 ASTTemplateKWAndArgsInfo::sizeFor(unsigned NumTemplateArgs) {
658 // Add space for the template keyword location.
659 // FIXME: There's room for this in the padding before the template args in
661 return Base::sizeFor(NumTemplateArgs) + sizeof(SourceLocation);