1 //===- TemplateBase.cpp - Common template AST class implementation --------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file implements common classes used throughout C++ template
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/TemplateBase.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Decl.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/PrettyPrinter.h"
22 #include "clang/AST/TemplateName.h"
23 #include "clang/AST/Type.h"
24 #include "clang/AST/TypeLoc.h"
25 #include "clang/Basic/Diagnostic.h"
26 #include "clang/Basic/LLVM.h"
27 #include "clang/Basic/LangOptions.h"
28 #include "clang/Basic/SourceLocation.h"
29 #include "llvm/ADT/APSInt.h"
30 #include "llvm/ADT/FoldingSet.h"
31 #include "llvm/ADT/None.h"
32 #include "llvm/ADT/SmallString.h"
33 #include "llvm/ADT/StringRef.h"
34 #include "llvm/Support/Casting.h"
35 #include "llvm/Support/Compiler.h"
36 #include "llvm/Support/ErrorHandling.h"
37 #include "llvm/Support/raw_ostream.h"
43 using namespace clang;
45 /// Print a template integral argument value.
47 /// \param TemplArg the TemplateArgument instance to print.
49 /// \param Out the raw_ostream instance to use for printing.
51 /// \param Policy the printing policy for EnumConstantDecl printing.
52 static void printIntegral(const TemplateArgument &TemplArg,
53 raw_ostream &Out, const PrintingPolicy& Policy) {
54 const Type *T = TemplArg.getIntegralType().getTypePtr();
55 const llvm::APSInt &Val = TemplArg.getAsIntegral();
57 if (const EnumType *ET = T->getAs<EnumType>()) {
58 for (const EnumConstantDecl* ECD : ET->getDecl()->enumerators()) {
59 // In Sema::CheckTemplateArugment, enum template arguments value are
60 // extended to the size of the integer underlying the enum type. This
61 // may create a size difference between the enum value and template
62 // argument value, requiring isSameValue here instead of operator==.
63 if (llvm::APSInt::isSameValue(ECD->getInitVal(), Val)) {
64 ECD->printQualifiedName(Out, Policy);
70 if (T->isBooleanType() && !Policy.MSVCFormatting) {
71 Out << (Val.getBoolValue() ? "true" : "false");
72 } else if (T->isCharType()) {
73 const char Ch = Val.getZExtValue();
74 Out << ((Ch == '\'') ? "'\\" : "'");
75 Out.write_escaped(StringRef(&Ch, 1), /*UseHexEscapes=*/ true);
82 //===----------------------------------------------------------------------===//
83 // TemplateArgument Implementation
84 //===----------------------------------------------------------------------===//
86 TemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value,
88 Integer.Kind = Integral;
89 // Copy the APSInt value into our decomposed form.
90 Integer.BitWidth = Value.getBitWidth();
91 Integer.IsUnsigned = Value.isUnsigned();
92 // If the value is large, we have to get additional memory from the ASTContext
93 unsigned NumWords = Value.getNumWords();
95 void *Mem = Ctx.Allocate(NumWords * sizeof(uint64_t));
96 std::memcpy(Mem, Value.getRawData(), NumWords * sizeof(uint64_t));
97 Integer.pVal = static_cast<uint64_t *>(Mem);
99 Integer.VAL = Value.getZExtValue();
102 Integer.Type = Type.getAsOpaquePtr();
106 TemplateArgument::CreatePackCopy(ASTContext &Context,
107 ArrayRef<TemplateArgument> Args) {
109 return getEmptyPack();
111 return TemplateArgument(Args.copy(Context));
114 bool TemplateArgument::isDependent() const {
117 llvm_unreachable("Should not have a NULL template argument");
120 return getAsType()->isDependentType() ||
121 isa<PackExpansionType>(getAsType());
124 return getAsTemplate().isDependent();
126 case TemplateExpansion:
130 if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
131 return DC->isDependentContext();
132 return getAsDecl()->getDeclContext()->isDependentContext();
142 return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent() ||
143 isa<PackExpansionExpr>(getAsExpr()));
146 for (const auto &P : pack_elements())
152 llvm_unreachable("Invalid TemplateArgument Kind!");
155 bool TemplateArgument::isInstantiationDependent() const {
158 llvm_unreachable("Should not have a NULL template argument");
161 return getAsType()->isInstantiationDependentType();
164 return getAsTemplate().isInstantiationDependent();
166 case TemplateExpansion:
170 if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
171 return DC->isDependentContext();
172 return getAsDecl()->getDeclContext()->isDependentContext();
182 return getAsExpr()->isInstantiationDependent();
185 for (const auto &P : pack_elements())
186 if (P.isInstantiationDependent())
191 llvm_unreachable("Invalid TemplateArgument Kind!");
194 bool TemplateArgument::isPackExpansion() const {
204 case TemplateExpansion:
208 return isa<PackExpansionType>(getAsType());
211 return isa<PackExpansionExpr>(getAsExpr());
214 llvm_unreachable("Invalid TemplateArgument Kind!");
217 bool TemplateArgument::containsUnexpandedParameterPack() const {
222 case TemplateExpansion:
227 if (getAsType()->containsUnexpandedParameterPack())
232 if (getAsTemplate().containsUnexpandedParameterPack())
237 if (getAsExpr()->containsUnexpandedParameterPack())
242 for (const auto &P : pack_elements())
243 if (P.containsUnexpandedParameterPack())
252 Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const {
253 assert(getKind() == TemplateExpansion);
254 if (TemplateArg.NumExpansions)
255 return TemplateArg.NumExpansions - 1;
260 QualType TemplateArgument::getNonTypeTemplateArgumentType() const {
262 case TemplateArgument::Null:
263 case TemplateArgument::Type:
264 case TemplateArgument::Template:
265 case TemplateArgument::TemplateExpansion:
266 case TemplateArgument::Pack:
269 case TemplateArgument::Integral:
270 return getIntegralType();
272 case TemplateArgument::Expression:
273 return getAsExpr()->getType();
275 case TemplateArgument::Declaration:
276 return getParamTypeForDecl();
278 case TemplateArgument::NullPtr:
279 return getNullPtrType();
282 llvm_unreachable("Invalid TemplateArgument Kind!");
285 void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID,
286 const ASTContext &Context) const {
287 ID.AddInteger(getKind());
293 getAsType().Profile(ID);
297 getNullPtrType().Profile(ID);
301 ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : nullptr);
305 case TemplateExpansion: {
306 TemplateName Template = getAsTemplateOrTemplatePattern();
307 if (TemplateTemplateParmDecl *TTP
308 = dyn_cast_or_null<TemplateTemplateParmDecl>(
309 Template.getAsTemplateDecl())) {
311 ID.AddInteger(TTP->getDepth());
312 ID.AddInteger(TTP->getPosition());
313 ID.AddBoolean(TTP->isParameterPack());
315 ID.AddBoolean(false);
316 ID.AddPointer(Context.getCanonicalTemplateName(Template)
317 .getAsVoidPointer());
323 getAsIntegral().Profile(ID);
324 getIntegralType().Profile(ID);
328 getAsExpr()->Profile(ID, Context, true);
332 ID.AddInteger(Args.NumArgs);
333 for (unsigned I = 0; I != Args.NumArgs; ++I)
334 Args.Args[I].Profile(ID, Context);
338 bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const {
339 if (getKind() != Other.getKind()) return false;
346 case TemplateExpansion:
348 return TypeOrValue.V == Other.TypeOrValue.V;
351 return getAsDecl() == Other.getAsDecl();
354 return getIntegralType() == Other.getIntegralType() &&
355 getAsIntegral() == Other.getAsIntegral();
358 if (Args.NumArgs != Other.Args.NumArgs) return false;
359 for (unsigned I = 0, E = Args.NumArgs; I != E; ++I)
360 if (!Args.Args[I].structurallyEquals(Other.Args.Args[I]))
365 llvm_unreachable("Invalid TemplateArgument Kind!");
368 TemplateArgument TemplateArgument::getPackExpansionPattern() const {
369 assert(isPackExpansion());
373 return getAsType()->castAs<PackExpansionType>()->getPattern();
376 return cast<PackExpansionExpr>(getAsExpr())->getPattern();
378 case TemplateExpansion:
379 return TemplateArgument(getAsTemplateOrTemplatePattern());
387 return TemplateArgument();
390 llvm_unreachable("Invalid TemplateArgument Kind!");
393 void TemplateArgument::print(const PrintingPolicy &Policy,
394 raw_ostream &Out) const {
401 PrintingPolicy SubPolicy(Policy);
402 SubPolicy.SuppressStrongLifetime = true;
403 getAsType().print(Out, SubPolicy);
408 NamedDecl *ND = getAsDecl();
410 if (ND->getDeclName()) {
411 // FIXME: distinguish between pointer and reference args?
412 ND->printQualifiedName(Out);
414 Out << "(anonymous)";
424 getAsTemplate().print(Out, Policy);
427 case TemplateExpansion:
428 getAsTemplateOrTemplatePattern().print(Out, Policy);
433 printIntegral(*this, Out, Policy);
437 getAsExpr()->printPretty(Out, nullptr, Policy);
443 for (const auto &P : pack_elements()) {
449 P.print(Policy, Out);
456 void TemplateArgument::dump(raw_ostream &Out) const {
457 LangOptions LO; // FIXME! see also TemplateName::dump().
460 print(PrintingPolicy(LO), Out);
463 LLVM_DUMP_METHOD void TemplateArgument::dump() const { dump(llvm::errs()); }
465 //===----------------------------------------------------------------------===//
466 // TemplateArgumentLoc Implementation
467 //===----------------------------------------------------------------------===//
469 SourceRange TemplateArgumentLoc::getSourceRange() const {
470 switch (Argument.getKind()) {
471 case TemplateArgument::Expression:
472 return getSourceExpression()->getSourceRange();
474 case TemplateArgument::Declaration:
475 return getSourceDeclExpression()->getSourceRange();
477 case TemplateArgument::NullPtr:
478 return getSourceNullPtrExpression()->getSourceRange();
480 case TemplateArgument::Type:
481 if (TypeSourceInfo *TSI = getTypeSourceInfo())
482 return TSI->getTypeLoc().getSourceRange();
484 return SourceRange();
486 case TemplateArgument::Template:
487 if (getTemplateQualifierLoc())
488 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
489 getTemplateNameLoc());
490 return SourceRange(getTemplateNameLoc());
492 case TemplateArgument::TemplateExpansion:
493 if (getTemplateQualifierLoc())
494 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
495 getTemplateEllipsisLoc());
496 return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc());
498 case TemplateArgument::Integral:
499 return getSourceIntegralExpression()->getSourceRange();
501 case TemplateArgument::Pack:
502 case TemplateArgument::Null:
503 return SourceRange();
506 llvm_unreachable("Invalid TemplateArgument Kind!");
509 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
510 const TemplateArgument &Arg) {
511 switch (Arg.getKind()) {
512 case TemplateArgument::Null:
513 // This is bad, but not as bad as crashing because of argument
515 return DB << "(null template argument)";
517 case TemplateArgument::Type:
518 return DB << Arg.getAsType();
520 case TemplateArgument::Declaration:
521 return DB << Arg.getAsDecl();
523 case TemplateArgument::NullPtr:
524 return DB << "nullptr";
526 case TemplateArgument::Integral:
527 return DB << Arg.getAsIntegral().toString(10);
529 case TemplateArgument::Template:
530 return DB << Arg.getAsTemplate();
532 case TemplateArgument::TemplateExpansion:
533 return DB << Arg.getAsTemplateOrTemplatePattern() << "...";
535 case TemplateArgument::Expression: {
536 // This shouldn't actually ever happen, so it's okay that we're
537 // regurgitating an expression here.
538 // FIXME: We're guessing at LangOptions!
540 llvm::raw_svector_ostream OS(Str);
541 LangOptions LangOpts;
542 LangOpts.CPlusPlus = true;
543 PrintingPolicy Policy(LangOpts);
544 Arg.getAsExpr()->printPretty(OS, nullptr, Policy);
545 return DB << OS.str();
548 case TemplateArgument::Pack: {
549 // FIXME: We're guessing at LangOptions!
551 llvm::raw_svector_ostream OS(Str);
552 LangOptions LangOpts;
553 LangOpts.CPlusPlus = true;
554 PrintingPolicy Policy(LangOpts);
555 Arg.print(Policy, OS);
556 return DB << OS.str();
560 llvm_unreachable("Invalid TemplateArgument Kind!");
563 const ASTTemplateArgumentListInfo *
564 ASTTemplateArgumentListInfo::Create(const ASTContext &C,
565 const TemplateArgumentListInfo &List) {
566 std::size_t size = totalSizeToAlloc<TemplateArgumentLoc>(List.size());
567 void *Mem = C.Allocate(size, alignof(ASTTemplateArgumentListInfo));
568 return new (Mem) ASTTemplateArgumentListInfo(List);
571 ASTTemplateArgumentListInfo::ASTTemplateArgumentListInfo(
572 const TemplateArgumentListInfo &Info) {
573 LAngleLoc = Info.getLAngleLoc();
574 RAngleLoc = Info.getRAngleLoc();
575 NumTemplateArgs = Info.size();
577 TemplateArgumentLoc *ArgBuffer = getTrailingObjects<TemplateArgumentLoc>();
578 for (unsigned i = 0; i != NumTemplateArgs; ++i)
579 new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
582 void ASTTemplateKWAndArgsInfo::initializeFrom(
583 SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info,
584 TemplateArgumentLoc *OutArgArray) {
585 this->TemplateKWLoc = TemplateKWLoc;
586 LAngleLoc = Info.getLAngleLoc();
587 RAngleLoc = Info.getRAngleLoc();
588 NumTemplateArgs = Info.size();
590 for (unsigned i = 0; i != NumTemplateArgs; ++i)
591 new (&OutArgArray[i]) TemplateArgumentLoc(Info[i]);
594 void ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) {
595 assert(TemplateKWLoc.isValid());
596 LAngleLoc = SourceLocation();
597 RAngleLoc = SourceLocation();
598 this->TemplateKWLoc = TemplateKWLoc;
602 void ASTTemplateKWAndArgsInfo::initializeFrom(
603 SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info,
604 TemplateArgumentLoc *OutArgArray, bool &Dependent,
605 bool &InstantiationDependent, bool &ContainsUnexpandedParameterPack) {
606 this->TemplateKWLoc = TemplateKWLoc;
607 LAngleLoc = Info.getLAngleLoc();
608 RAngleLoc = Info.getRAngleLoc();
609 NumTemplateArgs = Info.size();
611 for (unsigned i = 0; i != NumTemplateArgs; ++i) {
612 Dependent = Dependent || Info[i].getArgument().isDependent();
613 InstantiationDependent = InstantiationDependent ||
614 Info[i].getArgument().isInstantiationDependent();
615 ContainsUnexpandedParameterPack =
616 ContainsUnexpandedParameterPack ||
617 Info[i].getArgument().containsUnexpandedParameterPack();
619 new (&OutArgArray[i]) TemplateArgumentLoc(Info[i]);
623 void ASTTemplateKWAndArgsInfo::copyInto(const TemplateArgumentLoc *ArgArray,
624 TemplateArgumentListInfo &Info) const {
625 Info.setLAngleLoc(LAngleLoc);
626 Info.setRAngleLoc(RAngleLoc);
627 for (unsigned I = 0; I != NumTemplateArgs; ++I)
628 Info.addArgument(ArgArray[I]);