1 //===- TemplateBase.cpp - Common template AST class implementation --------===//
2 //
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
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements common classes used throughout C++ template
10 // representations.
11 //
12 //===----------------------------------------------------------------------===//
13
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/DependenceFlags.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/ExprCXX.h"
22 #include "clang/AST/PrettyPrinter.h"
23 #include "clang/AST/TemplateName.h"
24 #include "clang/AST/Type.h"
25 #include "clang/AST/TypeLoc.h"
26 #include "clang/Basic/Diagnostic.h"
27 #include "clang/Basic/LLVM.h"
28 #include "clang/Basic/LangOptions.h"
29 #include "clang/Basic/SourceLocation.h"
30 #include "llvm/ADT/APSInt.h"
31 #include "llvm/ADT/FoldingSet.h"
32 #include "llvm/ADT/None.h"
33 #include "llvm/ADT/SmallString.h"
34 #include "llvm/ADT/StringRef.h"
35 #include "llvm/Support/Casting.h"
36 #include "llvm/Support/Compiler.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/raw_ostream.h"
39 #include <cassert>
40 #include <cstddef>
41 #include <cstdint>
42 #include <cstring>
43
44 using namespace clang;
45
46 /// Print a template integral argument value.
47 ///
48 /// \param TemplArg the TemplateArgument instance to print.
49 ///
50 /// \param Out the raw_ostream instance to use for printing.
51 ///
52 /// \param Policy the printing policy for EnumConstantDecl printing.
printIntegral(const TemplateArgument & TemplArg,raw_ostream & Out,const PrintingPolicy & Policy)53 static void printIntegral(const TemplateArgument &TemplArg,
54 raw_ostream &Out, const PrintingPolicy& Policy) {
55 const Type *T = TemplArg.getIntegralType().getTypePtr();
56 const llvm::APSInt &Val = TemplArg.getAsIntegral();
57
58 if (const EnumType *ET = T->getAs<EnumType>()) {
59 for (const EnumConstantDecl* ECD : ET->getDecl()->enumerators()) {
60 // In Sema::CheckTemplateArugment, enum template arguments value are
61 // extended to the size of the integer underlying the enum type. This
62 // may create a size difference between the enum value and template
63 // argument value, requiring isSameValue here instead of operator==.
64 if (llvm::APSInt::isSameValue(ECD->getInitVal(), Val)) {
65 ECD->printQualifiedName(Out, Policy);
66 return;
67 }
68 }
69 }
70
71 if (T->isBooleanType() && !Policy.MSVCFormatting) {
72 Out << (Val.getBoolValue() ? "true" : "false");
73 } else if (T->isCharType()) {
74 const char Ch = Val.getZExtValue();
75 Out << ((Ch == '\'') ? "'\\" : "'");
76 Out.write_escaped(StringRef(&Ch, 1), /*UseHexEscapes=*/ true);
77 Out << "'";
78 } else {
79 Out << Val;
80 }
81 }
82
83 //===----------------------------------------------------------------------===//
84 // TemplateArgument Implementation
85 //===----------------------------------------------------------------------===//
86
TemplateArgument(ASTContext & Ctx,const llvm::APSInt & Value,QualType Type)87 TemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value,
88 QualType Type) {
89 Integer.Kind = Integral;
90 // Copy the APSInt value into our decomposed form.
91 Integer.BitWidth = Value.getBitWidth();
92 Integer.IsUnsigned = Value.isUnsigned();
93 // If the value is large, we have to get additional memory from the ASTContext
94 unsigned NumWords = Value.getNumWords();
95 if (NumWords > 1) {
96 void *Mem = Ctx.Allocate(NumWords * sizeof(uint64_t));
97 std::memcpy(Mem, Value.getRawData(), NumWords * sizeof(uint64_t));
98 Integer.pVal = static_cast<uint64_t *>(Mem);
99 } else {
100 Integer.VAL = Value.getZExtValue();
101 }
102
103 Integer.Type = Type.getAsOpaquePtr();
104 }
105
106 TemplateArgument
CreatePackCopy(ASTContext & Context,ArrayRef<TemplateArgument> Args)107 TemplateArgument::CreatePackCopy(ASTContext &Context,
108 ArrayRef<TemplateArgument> Args) {
109 if (Args.empty())
110 return getEmptyPack();
111
112 return TemplateArgument(Args.copy(Context));
113 }
114
getDependence() const115 TemplateArgumentDependence TemplateArgument::getDependence() const {
116 auto Deps = TemplateArgumentDependence::None;
117 switch (getKind()) {
118 case Null:
119 llvm_unreachable("Should not have a NULL template argument");
120
121 case Type:
122 Deps = toTemplateArgumentDependence(getAsType()->getDependence());
123 if (isa<PackExpansionType>(getAsType()))
124 Deps |= TemplateArgumentDependence::Dependent;
125 return Deps;
126
127 case Template:
128 return toTemplateArgumentDependence(getAsTemplate().getDependence());
129
130 case TemplateExpansion:
131 return TemplateArgumentDependence::Dependent |
132 TemplateArgumentDependence::Instantiation;
133
134 case Declaration: {
135 auto *DC = dyn_cast<DeclContext>(getAsDecl());
136 if (!DC)
137 DC = getAsDecl()->getDeclContext();
138 if (DC->isDependentContext())
139 Deps = TemplateArgumentDependence::Dependent |
140 TemplateArgumentDependence::Instantiation;
141 return Deps;
142 }
143
144 case NullPtr:
145 case Integral:
146 return TemplateArgumentDependence::None;
147
148 case Expression:
149 Deps = toTemplateArgumentDependence(getAsExpr()->getDependence());
150 if (isa<PackExpansionExpr>(getAsExpr()))
151 Deps |= TemplateArgumentDependence::Dependent |
152 TemplateArgumentDependence::Instantiation;
153 return Deps;
154
155 case Pack:
156 for (const auto &P : pack_elements())
157 Deps |= P.getDependence();
158 return Deps;
159 }
160 llvm_unreachable("unhandled ArgKind");
161 }
162
isDependent() const163 bool TemplateArgument::isDependent() const {
164 return getDependence() & TemplateArgumentDependence::Dependent;
165 }
166
isInstantiationDependent() const167 bool TemplateArgument::isInstantiationDependent() const {
168 return getDependence() & TemplateArgumentDependence::Instantiation;
169 }
170
isPackExpansion() const171 bool TemplateArgument::isPackExpansion() const {
172 switch (getKind()) {
173 case Null:
174 case Declaration:
175 case Integral:
176 case Pack:
177 case Template:
178 case NullPtr:
179 return false;
180
181 case TemplateExpansion:
182 return true;
183
184 case Type:
185 return isa<PackExpansionType>(getAsType());
186
187 case Expression:
188 return isa<PackExpansionExpr>(getAsExpr());
189 }
190
191 llvm_unreachable("Invalid TemplateArgument Kind!");
192 }
193
containsUnexpandedParameterPack() const194 bool TemplateArgument::containsUnexpandedParameterPack() const {
195 return getDependence() & TemplateArgumentDependence::UnexpandedPack;
196 }
197
getNumTemplateExpansions() const198 Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const {
199 assert(getKind() == TemplateExpansion);
200 if (TemplateArg.NumExpansions)
201 return TemplateArg.NumExpansions - 1;
202
203 return None;
204 }
205
getNonTypeTemplateArgumentType() const206 QualType TemplateArgument::getNonTypeTemplateArgumentType() const {
207 switch (getKind()) {
208 case TemplateArgument::Null:
209 case TemplateArgument::Type:
210 case TemplateArgument::Template:
211 case TemplateArgument::TemplateExpansion:
212 case TemplateArgument::Pack:
213 return QualType();
214
215 case TemplateArgument::Integral:
216 return getIntegralType();
217
218 case TemplateArgument::Expression:
219 return getAsExpr()->getType();
220
221 case TemplateArgument::Declaration:
222 return getParamTypeForDecl();
223
224 case TemplateArgument::NullPtr:
225 return getNullPtrType();
226 }
227
228 llvm_unreachable("Invalid TemplateArgument Kind!");
229 }
230
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context) const231 void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID,
232 const ASTContext &Context) const {
233 ID.AddInteger(getKind());
234 switch (getKind()) {
235 case Null:
236 break;
237
238 case Type:
239 getAsType().Profile(ID);
240 break;
241
242 case NullPtr:
243 getNullPtrType().Profile(ID);
244 break;
245
246 case Declaration:
247 ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : nullptr);
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.V == Other.TypeOrValue.V;
295
296 case Declaration:
297 return getAsDecl() == Other.getAsDecl();
298
299 case Integral:
300 return getIntegralType() == Other.getIntegralType() &&
301 getAsIntegral() == Other.getAsIntegral();
302
303 case Pack:
304 if (Args.NumArgs != Other.Args.NumArgs) return false;
305 for (unsigned I = 0, E = Args.NumArgs; I != E; ++I)
306 if (!Args.Args[I].structurallyEquals(Other.Args.Args[I]))
307 return false;
308 return true;
309 }
310
311 llvm_unreachable("Invalid TemplateArgument Kind!");
312 }
313
getPackExpansionPattern() const314 TemplateArgument TemplateArgument::getPackExpansionPattern() const {
315 assert(isPackExpansion());
316
317 switch (getKind()) {
318 case Type:
319 return getAsType()->castAs<PackExpansionType>()->getPattern();
320
321 case Expression:
322 return cast<PackExpansionExpr>(getAsExpr())->getPattern();
323
324 case TemplateExpansion:
325 return TemplateArgument(getAsTemplateOrTemplatePattern());
326
327 case Declaration:
328 case Integral:
329 case Pack:
330 case Null:
331 case Template:
332 case NullPtr:
333 return TemplateArgument();
334 }
335
336 llvm_unreachable("Invalid TemplateArgument Kind!");
337 }
338
print(const PrintingPolicy & Policy,raw_ostream & Out) const339 void TemplateArgument::print(const PrintingPolicy &Policy,
340 raw_ostream &Out) const {
341 switch (getKind()) {
342 case Null:
343 Out << "(no value)";
344 break;
345
346 case Type: {
347 PrintingPolicy SubPolicy(Policy);
348 SubPolicy.SuppressStrongLifetime = true;
349 getAsType().print(Out, SubPolicy);
350 break;
351 }
352
353 case Declaration: {
354 NamedDecl *ND = getAsDecl();
355 if (getParamTypeForDecl()->isRecordType()) {
356 if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
357 // FIXME: Include the type if it's not obvious from the context.
358 TPO->printAsInit(Out);
359 break;
360 }
361 }
362 if (!getParamTypeForDecl()->isReferenceType())
363 Out << '&';
364 ND->printQualifiedName(Out);
365 break;
366 }
367
368 case NullPtr:
369 Out << "nullptr";
370 break;
371
372 case Template:
373 getAsTemplate().print(Out, Policy);
374 break;
375
376 case TemplateExpansion:
377 getAsTemplateOrTemplatePattern().print(Out, Policy);
378 Out << "...";
379 break;
380
381 case Integral:
382 printIntegral(*this, Out, Policy);
383 break;
384
385 case Expression:
386 getAsExpr()->printPretty(Out, nullptr, Policy);
387 break;
388
389 case Pack:
390 Out << "<";
391 bool First = true;
392 for (const auto &P : pack_elements()) {
393 if (First)
394 First = false;
395 else
396 Out << ", ";
397
398 P.print(Policy, Out);
399 }
400 Out << ">";
401 break;
402 }
403 }
404
dump(raw_ostream & Out) const405 void TemplateArgument::dump(raw_ostream &Out) const {
406 LangOptions LO; // FIXME! see also TemplateName::dump().
407 LO.CPlusPlus = true;
408 LO.Bool = true;
409 print(PrintingPolicy(LO), Out);
410 }
411
dump() const412 LLVM_DUMP_METHOD void TemplateArgument::dump() const { dump(llvm::errs()); }
413
414 //===----------------------------------------------------------------------===//
415 // TemplateArgumentLoc Implementation
416 //===----------------------------------------------------------------------===//
417
getSourceRange() const418 SourceRange TemplateArgumentLoc::getSourceRange() const {
419 switch (Argument.getKind()) {
420 case TemplateArgument::Expression:
421 return getSourceExpression()->getSourceRange();
422
423 case TemplateArgument::Declaration:
424 return getSourceDeclExpression()->getSourceRange();
425
426 case TemplateArgument::NullPtr:
427 return getSourceNullPtrExpression()->getSourceRange();
428
429 case TemplateArgument::Type:
430 if (TypeSourceInfo *TSI = getTypeSourceInfo())
431 return TSI->getTypeLoc().getSourceRange();
432 else
433 return SourceRange();
434
435 case TemplateArgument::Template:
436 if (getTemplateQualifierLoc())
437 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
438 getTemplateNameLoc());
439 return SourceRange(getTemplateNameLoc());
440
441 case TemplateArgument::TemplateExpansion:
442 if (getTemplateQualifierLoc())
443 return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
444 getTemplateEllipsisLoc());
445 return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc());
446
447 case TemplateArgument::Integral:
448 return getSourceIntegralExpression()->getSourceRange();
449
450 case TemplateArgument::Pack:
451 case TemplateArgument::Null:
452 return SourceRange();
453 }
454
455 llvm_unreachable("Invalid TemplateArgument Kind!");
456 }
457
458 template <typename T>
DiagTemplateArg(const T & DB,const TemplateArgument & Arg)459 static const T &DiagTemplateArg(const T &DB, const TemplateArgument &Arg) {
460 switch (Arg.getKind()) {
461 case TemplateArgument::Null:
462 // This is bad, but not as bad as crashing because of argument
463 // count mismatches.
464 return DB << "(null template argument)";
465
466 case TemplateArgument::Type:
467 return DB << Arg.getAsType();
468
469 case TemplateArgument::Declaration:
470 return DB << Arg.getAsDecl();
471
472 case TemplateArgument::NullPtr:
473 return DB << "nullptr";
474
475 case TemplateArgument::Integral:
476 return DB << Arg.getAsIntegral().toString(10);
477
478 case TemplateArgument::Template:
479 return DB << Arg.getAsTemplate();
480
481 case TemplateArgument::TemplateExpansion:
482 return DB << Arg.getAsTemplateOrTemplatePattern() << "...";
483
484 case TemplateArgument::Expression: {
485 // This shouldn't actually ever happen, so it's okay that we're
486 // regurgitating an expression here.
487 // FIXME: We're guessing at LangOptions!
488 SmallString<32> Str;
489 llvm::raw_svector_ostream OS(Str);
490 LangOptions LangOpts;
491 LangOpts.CPlusPlus = true;
492 PrintingPolicy Policy(LangOpts);
493 Arg.getAsExpr()->printPretty(OS, nullptr, Policy);
494 return DB << OS.str();
495 }
496
497 case TemplateArgument::Pack: {
498 // FIXME: We're guessing at LangOptions!
499 SmallString<32> Str;
500 llvm::raw_svector_ostream OS(Str);
501 LangOptions LangOpts;
502 LangOpts.CPlusPlus = true;
503 PrintingPolicy Policy(LangOpts);
504 Arg.print(Policy, OS);
505 return DB << OS.str();
506 }
507 }
508
509 llvm_unreachable("Invalid TemplateArgument Kind!");
510 }
511
operator <<(const StreamingDiagnostic & DB,const TemplateArgument & Arg)512 const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
513 const TemplateArgument &Arg) {
514 return DiagTemplateArg(DB, Arg);
515 }
516
TemplateArgumentLocInfo(ASTContext & Ctx,NestedNameSpecifierLoc QualifierLoc,SourceLocation TemplateNameLoc,SourceLocation EllipsisLoc)517 clang::TemplateArgumentLocInfo::TemplateArgumentLocInfo(
518 ASTContext &Ctx, NestedNameSpecifierLoc QualifierLoc,
519 SourceLocation TemplateNameLoc, SourceLocation EllipsisLoc) {
520 TemplateTemplateArgLocInfo *Template = new (Ctx) TemplateTemplateArgLocInfo;
521 Template->Qualifier = QualifierLoc.getNestedNameSpecifier();
522 Template->QualifierLocData = QualifierLoc.getOpaqueData();
523 Template->TemplateNameLoc = TemplateNameLoc.getRawEncoding();
524 Template->EllipsisLoc = EllipsisLoc.getRawEncoding();
525 Pointer = Template;
526 }
527
528 const ASTTemplateArgumentListInfo *
Create(const ASTContext & C,const TemplateArgumentListInfo & List)529 ASTTemplateArgumentListInfo::Create(const ASTContext &C,
530 const TemplateArgumentListInfo &List) {
531 std::size_t size = totalSizeToAlloc<TemplateArgumentLoc>(List.size());
532 void *Mem = C.Allocate(size, alignof(ASTTemplateArgumentListInfo));
533 return new (Mem) ASTTemplateArgumentListInfo(List);
534 }
535
ASTTemplateArgumentListInfo(const TemplateArgumentListInfo & Info)536 ASTTemplateArgumentListInfo::ASTTemplateArgumentListInfo(
537 const TemplateArgumentListInfo &Info) {
538 LAngleLoc = Info.getLAngleLoc();
539 RAngleLoc = Info.getRAngleLoc();
540 NumTemplateArgs = Info.size();
541
542 TemplateArgumentLoc *ArgBuffer = getTrailingObjects<TemplateArgumentLoc>();
543 for (unsigned i = 0; i != NumTemplateArgs; ++i)
544 new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
545 }
546
initializeFrom(SourceLocation TemplateKWLoc,const TemplateArgumentListInfo & Info,TemplateArgumentLoc * OutArgArray)547 void ASTTemplateKWAndArgsInfo::initializeFrom(
548 SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info,
549 TemplateArgumentLoc *OutArgArray) {
550 this->TemplateKWLoc = TemplateKWLoc;
551 LAngleLoc = Info.getLAngleLoc();
552 RAngleLoc = Info.getRAngleLoc();
553 NumTemplateArgs = Info.size();
554
555 for (unsigned i = 0; i != NumTemplateArgs; ++i)
556 new (&OutArgArray[i]) TemplateArgumentLoc(Info[i]);
557 }
558
initializeFrom(SourceLocation TemplateKWLoc)559 void ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) {
560 assert(TemplateKWLoc.isValid());
561 LAngleLoc = SourceLocation();
562 RAngleLoc = SourceLocation();
563 this->TemplateKWLoc = TemplateKWLoc;
564 NumTemplateArgs = 0;
565 }
566
initializeFrom(SourceLocation TemplateKWLoc,const TemplateArgumentListInfo & Info,TemplateArgumentLoc * OutArgArray,TemplateArgumentDependence & Deps)567 void ASTTemplateKWAndArgsInfo::initializeFrom(
568 SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info,
569 TemplateArgumentLoc *OutArgArray, TemplateArgumentDependence &Deps) {
570 this->TemplateKWLoc = TemplateKWLoc;
571 LAngleLoc = Info.getLAngleLoc();
572 RAngleLoc = Info.getRAngleLoc();
573 NumTemplateArgs = Info.size();
574
575 for (unsigned i = 0; i != NumTemplateArgs; ++i) {
576 Deps |= Info[i].getArgument().getDependence();
577
578 new (&OutArgArray[i]) TemplateArgumentLoc(Info[i]);
579 }
580 }
581
copyInto(const TemplateArgumentLoc * ArgArray,TemplateArgumentListInfo & Info) const582 void ASTTemplateKWAndArgsInfo::copyInto(const TemplateArgumentLoc *ArgArray,
583 TemplateArgumentListInfo &Info) const {
584 Info.setLAngleLoc(LAngleLoc);
585 Info.setRAngleLoc(RAngleLoc);
586 for (unsigned I = 0; I != NumTemplateArgs; ++I)
587 Info.addArgument(ArgArray[I]);
588 }
589