TemplateBase.cpp revision abd5fa28199bab926ae983afa511e5a195ac131a 
1//===--- TemplateBase.cpp - Common template AST class implementation ------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements common classes used throughout C++ template
11// representations.
12//
13//===----------------------------------------------------------------------===//
14
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 <algorithm>
27#include <cctype>
28
29using namespace clang;
30
31/// \brief Print a template integral argument value.
32///
33/// \param TemplArg the TemplateArgument instance to print.
34///
35/// \param Out the raw_ostream instance to use for printing.
36static void printIntegral(const TemplateArgument &TemplArg,
37                          raw_ostream &Out) {
38  const ::clang::Type *T = TemplArg.getIntegralType().getTypePtr();
39  const llvm::APSInt &Val = TemplArg.getAsIntegral();
40
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);
47    Out << "'";
48  } else {
49    Out << Val;
50  }
51}
52
53//===----------------------------------------------------------------------===//
54// TemplateArgument Implementation
55//===----------------------------------------------------------------------===//
56
57TemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value,
58                                   QualType Type)
59  : Kind(Integral) {
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();
65  if (NumWords > 1) {
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);
69  } else {
70    Integer.VAL = Value.getZExtValue();
71  }
72
73  Integer.Type = Type.getAsOpaquePtr();
74}
75
76TemplateArgument TemplateArgument::CreatePackCopy(ASTContext &Context,
77                                                  const TemplateArgument *Args,
78                                                  unsigned NumArgs) {
79  if (NumArgs == 0)
80    return getEmptyPack();
81
82  TemplateArgument *Storage = new (Context) TemplateArgument [NumArgs];
83  std::copy(Args, Args + NumArgs, Storage);
84  return TemplateArgument(Storage, NumArgs);
85}
86
87bool TemplateArgument::isDependent() const {
88  switch (getKind()) {
89  case Null:
90    llvm_unreachable("Should not have a NULL template argument");
91
92  case Type:
93    return getAsType()->isDependentType();
94
95  case Template:
96    return getAsTemplate().isDependent();
97
98  case TemplateExpansion:
99    return true;
100
101  case Declaration:
102    if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
103      return DC->isDependentContext();
104    return getAsDecl()->getDeclContext()->isDependentContext();
105
106  case NullPtr:
107    return false;
108
109  case Integral:
110    // Never dependent
111    return false;
112
113  case Expression:
114    return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent());
115
116  case Pack:
117    for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) {
118      if (P->isDependent())
119        return true;
120    }
121
122    return false;
123  }
124
125  llvm_unreachable("Invalid TemplateArgument Kind!");
126}
127
128bool TemplateArgument::isInstantiationDependent() const {
129  switch (getKind()) {
130  case Null:
131    llvm_unreachable("Should not have a NULL template argument");
132
133  case Type:
134    return getAsType()->isInstantiationDependentType();
135
136  case Template:
137    return getAsTemplate().isInstantiationDependent();
138
139  case TemplateExpansion:
140    return true;
141
142  case Declaration:
143    if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
144      return DC->isDependentContext();
145    return getAsDecl()->getDeclContext()->isDependentContext();
146
147  case NullPtr:
148    return false;
149
150  case Integral:
151    // Never dependent
152    return false;
153
154  case Expression:
155    return getAsExpr()->isInstantiationDependent();
156
157  case Pack:
158    for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P) {
159      if (P->isInstantiationDependent())
160        return true;
161    }
162
163    return false;
164  }
165
166  llvm_unreachable("Invalid TemplateArgument Kind!");
167}
168
169bool TemplateArgument::isPackExpansion() const {
170  switch (getKind()) {
171  case Null:
172  case Declaration:
173  case Integral:
174  case Pack:
175  case Template:
176  case NullPtr:
177    return false;
178
179  case TemplateExpansion:
180    return true;
181
182  case Type:
183    return isa<PackExpansionType>(getAsType());
184
185  case Expression:
186    return isa<PackExpansionExpr>(getAsExpr());
187  }
188
189  llvm_unreachable("Invalid TemplateArgument Kind!");
190}
191
192bool TemplateArgument::containsUnexpandedParameterPack() const {
193  switch (getKind()) {
194  case Null:
195  case Declaration:
196  case Integral:
197  case TemplateExpansion:
198  case NullPtr:
199    break;
200
201  case Type:
202    if (getAsType()->containsUnexpandedParameterPack())
203      return true;
204    break;
205
206  case Template:
207    if (getAsTemplate().containsUnexpandedParameterPack())
208      return true;
209    break;
210
211  case Expression:
212    if (getAsExpr()->containsUnexpandedParameterPack())
213      return true;
214    break;
215
216  case Pack:
217    for (pack_iterator P = pack_begin(), PEnd = pack_end(); P != PEnd; ++P)
218      if (P->containsUnexpandedParameterPack())
219        return true;
220
221    break;
222  }
223
224  return false;
225}
226
227llvm::Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const {
228  assert(Kind == TemplateExpansion);
229  if (TemplateArg.NumExpansions)
230    return TemplateArg.NumExpansions - 1;
231
232  return llvm::Optional<unsigned>();
233}
234
235void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID,
236                               const ASTContext &Context) const {
237  ID.AddInteger(Kind);
238  switch (Kind) {
239  case Null:
240    break;
241
242  case Type:
243    getAsType().Profile(ID);
244    break;
245
246  case Declaration:
247    ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : 0);
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
284bool 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 == Other.TypeOrValue;
295
296  case Declaration:
297    return getAsDecl() == Other.getAsDecl() &&
298           isDeclForReferenceParam() && Other.isDeclForReferenceParam();
299
300  case Integral:
301    return getIntegralType() == Other.getIntegralType() &&
302           getAsIntegral() == Other.getAsIntegral();
303
304  case Pack:
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]))
308        return false;
309    return true;
310  }
311
312  llvm_unreachable("Invalid TemplateArgument Kind!");
313}
314
315TemplateArgument TemplateArgument::getPackExpansionPattern() const {
316  assert(isPackExpansion());
317
318  switch (getKind()) {
319  case Type:
320    return getAsType()->getAs<PackExpansionType>()->getPattern();
321
322  case Expression:
323    return cast<PackExpansionExpr>(getAsExpr())->getPattern();
324
325  case TemplateExpansion:
326    return TemplateArgument(getAsTemplateOrTemplatePattern());
327
328  case Declaration:
329  case Integral:
330  case Pack:
331  case Null:
332  case Template:
333  case NullPtr:
334    return TemplateArgument();
335  }
336
337  llvm_unreachable("Invalid TemplateArgument Kind!");
338}
339
340void TemplateArgument::print(const PrintingPolicy &Policy,
341                             raw_ostream &Out) const {
342  switch (getKind()) {
343  case Null:
344    Out << "<no value>";
345    break;
346
347  case Type: {
348    PrintingPolicy SubPolicy(Policy);
349    SubPolicy.SuppressStrongLifetime = true;
350    std::string TypeStr;
351    getAsType().getAsStringInternal(TypeStr, SubPolicy);
352    Out << TypeStr;
353    break;
354  }
355
356  case Declaration: {
357    NamedDecl *ND = cast<NamedDecl>(getAsDecl());
358    if (ND->getDeclName()) {
359      // FIXME: distinguish between pointer and reference args?
360      Out << *ND;
361    } else {
362      Out << "<anonymous>";
363    }
364    break;
365  }
366
367  case NullPtr:
368    Out << "nullptr";
369    break;
370
371  case Template:
372    getAsTemplate().print(Out, Policy);
373    break;
374
375  case TemplateExpansion:
376    getAsTemplateOrTemplatePattern().print(Out, Policy);
377    Out << "...";
378    break;
379
380  case Integral: {
381    printIntegral(*this, Out);
382    break;
383  }
384
385  case Expression:
386    getAsExpr()->printPretty(Out, 0, Policy);
387    break;
388
389  case Pack:
390    Out << "<";
391    bool First = true;
392    for (TemplateArgument::pack_iterator P = pack_begin(), PEnd = pack_end();
393         P != PEnd; ++P) {
394      if (First)
395        First = false;
396      else
397        Out << ", ";
398
399      P->print(Policy, Out);
400    }
401    Out << ">";
402    break;
403  }
404}
405
406//===----------------------------------------------------------------------===//
407// TemplateArgumentLoc Implementation
408//===----------------------------------------------------------------------===//
409
410TemplateArgumentLocInfo::TemplateArgumentLocInfo() {
411  memset((void*)this, 0, sizeof(TemplateArgumentLocInfo));
412}
413
414SourceRange TemplateArgumentLoc::getSourceRange() const {
415  switch (Argument.getKind()) {
416  case TemplateArgument::Expression:
417    return getSourceExpression()->getSourceRange();
418
419  case TemplateArgument::Declaration:
420    return getSourceDeclExpression()->getSourceRange();
421
422  case TemplateArgument::NullPtr:
423    return getSourceNullPtrExpression()->getSourceRange();
424
425  case TemplateArgument::Type:
426    if (TypeSourceInfo *TSI = getTypeSourceInfo())
427      return TSI->getTypeLoc().getSourceRange();
428    else
429      return SourceRange();
430
431  case TemplateArgument::Template:
432    if (getTemplateQualifierLoc())
433      return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
434                         getTemplateNameLoc());
435    return SourceRange(getTemplateNameLoc());
436
437  case TemplateArgument::TemplateExpansion:
438    if (getTemplateQualifierLoc())
439      return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
440                         getTemplateEllipsisLoc());
441    return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc());
442
443  case TemplateArgument::Integral:
444    return getSourceIntegralExpression()->getSourceRange();
445
446  case TemplateArgument::Pack:
447  case TemplateArgument::Null:
448    return SourceRange();
449  }
450
451  llvm_unreachable("Invalid TemplateArgument Kind!");
452}
453
454TemplateArgumentLoc
455TemplateArgumentLoc::getPackExpansionPattern(SourceLocation &Ellipsis,
456                                       llvm::Optional<unsigned> &NumExpansions,
457                                             ASTContext &Context) const {
458  assert(Argument.isPackExpansion());
459
460  switch (Argument.getKind()) {
461  case TemplateArgument::Type: {
462    // FIXME: We shouldn't ever have to worry about missing
463    // type-source info!
464    TypeSourceInfo *ExpansionTSInfo = getTypeSourceInfo();
465    if (!ExpansionTSInfo)
466      ExpansionTSInfo = Context.getTrivialTypeSourceInfo(
467                                                     getArgument().getAsType(),
468                                                         Ellipsis);
469    PackExpansionTypeLoc Expansion
470      = cast<PackExpansionTypeLoc>(ExpansionTSInfo->getTypeLoc());
471    Ellipsis = Expansion.getEllipsisLoc();
472
473    TypeLoc Pattern = Expansion.getPatternLoc();
474    NumExpansions = Expansion.getTypePtr()->getNumExpansions();
475
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()),
486                               PatternTSInfo);
487  }
488
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);
496  }
497
498  case TemplateArgument::TemplateExpansion:
499    Ellipsis = getTemplateEllipsisLoc();
500    NumExpansions = Argument.getNumTemplateExpansions();
501    return TemplateArgumentLoc(Argument.getPackExpansionPattern(),
502                               getTemplateQualifierLoc(),
503                               getTemplateNameLoc());
504
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();
512  }
513
514  llvm_unreachable("Invalid TemplateArgument Kind!");
515}
516
517const 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
522    // count mismatches.
523    return DB << "(null template argument)";
524
525  case TemplateArgument::Type:
526    return DB << Arg.getAsType();
527
528  case TemplateArgument::Declaration:
529    return DB << Arg.getAsDecl();
530
531  case TemplateArgument::NullPtr:
532    return DB << "nullptr";
533
534  case TemplateArgument::Integral:
535    return DB << Arg.getAsIntegral().toString(10);
536
537  case TemplateArgument::Template:
538    return DB << Arg.getAsTemplate();
539
540  case TemplateArgument::TemplateExpansion:
541    return DB << Arg.getAsTemplateOrTemplatePattern() << "...";
542
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!
547    SmallString<32> Str;
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();
554  }
555
556  case TemplateArgument::Pack: {
557    // FIXME: We're guessing at LangOptions!
558    SmallString<32> Str;
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();
565  }
566  }
567
568  llvm_unreachable("Invalid TemplateArgument Kind!");
569}
570
571const ASTTemplateArgumentListInfo *
572ASTTemplateArgumentListInfo::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);
578  return TAI;
579}
580
581void ASTTemplateArgumentListInfo::initializeFrom(
582                                      const TemplateArgumentListInfo &Info) {
583  LAngleLoc = Info.getLAngleLoc();
584  RAngleLoc = Info.getRAngleLoc();
585  NumTemplateArgs = Info.size();
586
587  TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
588  for (unsigned i = 0; i != NumTemplateArgs; ++i)
589    new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
590}
591
592void ASTTemplateArgumentListInfo::initializeFrom(
593                                          const TemplateArgumentListInfo &Info,
594                                                  bool &Dependent,
595                                                  bool &InstantiationDependent,
596                                       bool &ContainsUnexpandedParameterPack) {
597  LAngleLoc = Info.getLAngleLoc();
598  RAngleLoc = Info.getRAngleLoc();
599  NumTemplateArgs = Info.size();
600
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();
609
610    new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
611  }
612}
613
614void 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]);
620}
621
622std::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) {
623  return sizeof(ASTTemplateArgumentListInfo) +
624         sizeof(TemplateArgumentLoc) * NumTemplateArgs;
625}
626
627void
628ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc,
629                                         const TemplateArgumentListInfo &Info) {
630  Base::initializeFrom(Info);
631  setTemplateKeywordLoc(TemplateKWLoc);
632}
633
634void
635ASTTemplateKWAndArgsInfo
636::initializeFrom(SourceLocation TemplateKWLoc,
637                 const TemplateArgumentListInfo &Info,
638                 bool &Dependent,
639                 bool &InstantiationDependent,
640                 bool &ContainsUnexpandedParameterPack) {
641  Base::initializeFrom(Info, Dependent, InstantiationDependent,
642                       ContainsUnexpandedParameterPack);
643  setTemplateKeywordLoc(TemplateKWLoc);
644}
645
646void
647ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) {
648  // No explicit template arguments, but template keyword loc is valid.
649  assert(TemplateKWLoc.isValid());
650  LAngleLoc = SourceLocation();
651  RAngleLoc = SourceLocation();
652  NumTemplateArgs = 0;
653  setTemplateKeywordLoc(TemplateKWLoc);
654}
655
656std::size_t
657ASTTemplateKWAndArgsInfo::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
660  //        64-bit builds.
661  return Base::sizeFor(NumTemplateArgs) + sizeof(SourceLocation);
662}
663