Home | History | Annotate | Download | only in AST 
      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 "llvm/Support/raw_ostream.h"
     27 #include <algorithm>
     28 
     29 using 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.
     36 static 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 
     57 TemplateArgument::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 
     76 TemplateArgument 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 
     87 bool 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 
    128 bool 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 
    169 bool 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 
    192 bool 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 
    227 Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const {
    228   assert(Kind == TemplateExpansion);
    229   if (TemplateArg.NumExpansions)
    230     return TemplateArg.NumExpansions - 1;
    231 
    232   return None;
    233 }
    234 
    235 void 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 
    284 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 == 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 
    315 TemplateArgument 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 
    340 void 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     getAsType().print(Out, SubPolicy);
    351     break;
    352   }
    353 
    354   case Declaration: {
    355     NamedDecl *ND = cast<NamedDecl>(getAsDecl());
    356     if (ND->getDeclName()) {
    357       // FIXME: distinguish between pointer and reference args?
    358       Out << *ND;
    359     } else {
    360       Out << "<anonymous>";
    361     }
    362     break;
    363   }
    364 
    365   case NullPtr:
    366     Out << "nullptr";
    367     break;
    368 
    369   case Template:
    370     getAsTemplate().print(Out, Policy);
    371     break;
    372 
    373   case TemplateExpansion:
    374     getAsTemplateOrTemplatePattern().print(Out, Policy);
    375     Out << "...";
    376     break;
    377 
    378   case Integral: {
    379     printIntegral(*this, Out);
    380     break;
    381   }
    382 
    383   case Expression:
    384     getAsExpr()->printPretty(Out, 0, Policy);
    385     break;
    386 
    387   case Pack:
    388     Out << "<";
    389     bool First = true;
    390     for (TemplateArgument::pack_iterator P = pack_begin(), PEnd = pack_end();
    391          P != PEnd; ++P) {
    392       if (First)
    393         First = false;
    394       else
    395         Out << ", ";
    396 
    397       P->print(Policy, Out);
    398     }
    399     Out << ">";
    400     break;
    401   }
    402 }
    403 
    404 //===----------------------------------------------------------------------===//
    405 // TemplateArgumentLoc Implementation
    406 //===----------------------------------------------------------------------===//
    407 
    408 TemplateArgumentLocInfo::TemplateArgumentLocInfo() {
    409   memset((void*)this, 0, sizeof(TemplateArgumentLocInfo));
    410 }
    411 
    412 SourceRange TemplateArgumentLoc::getSourceRange() const {
    413   switch (Argument.getKind()) {
    414   case TemplateArgument::Expression:
    415     return getSourceExpression()->getSourceRange();
    416 
    417   case TemplateArgument::Declaration:
    418     return getSourceDeclExpression()->getSourceRange();
    419 
    420   case TemplateArgument::NullPtr:
    421     return getSourceNullPtrExpression()->getSourceRange();
    422 
    423   case TemplateArgument::Type:
    424     if (TypeSourceInfo *TSI = getTypeSourceInfo())
    425       return TSI->getTypeLoc().getSourceRange();
    426     else
    427       return SourceRange();
    428 
    429   case TemplateArgument::Template:
    430     if (getTemplateQualifierLoc())
    431       return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
    432                          getTemplateNameLoc());
    433     return SourceRange(getTemplateNameLoc());
    434 
    435   case TemplateArgument::TemplateExpansion:
    436     if (getTemplateQualifierLoc())
    437       return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
    438                          getTemplateEllipsisLoc());
    439     return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc());
    440 
    441   case TemplateArgument::Integral:
    442     return getSourceIntegralExpression()->getSourceRange();
    443 
    444   case TemplateArgument::Pack:
    445   case TemplateArgument::Null:
    446     return SourceRange();
    447   }
    448 
    449   llvm_unreachable("Invalid TemplateArgument Kind!");
    450 }
    451 
    452 TemplateArgumentLoc TemplateArgumentLoc::getPackExpansionPattern(
    453     SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions,
    454     ASTContext &Context) const {
    455   assert(Argument.isPackExpansion());
    456 
    457   switch (Argument.getKind()) {
    458   case TemplateArgument::Type: {
    459     // FIXME: We shouldn't ever have to worry about missing
    460     // type-source info!
    461     TypeSourceInfo *ExpansionTSInfo = getTypeSourceInfo();
    462     if (!ExpansionTSInfo)
    463       ExpansionTSInfo = Context.getTrivialTypeSourceInfo(
    464                                                      getArgument().getAsType(),
    465                                                          Ellipsis);
    466     PackExpansionTypeLoc Expansion =
    467         ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>();
    468     Ellipsis = Expansion.getEllipsisLoc();
    469 
    470     TypeLoc Pattern = Expansion.getPatternLoc();
    471     NumExpansions = Expansion.getTypePtr()->getNumExpansions();
    472 
    473     // FIXME: This is horrible. We know where the source location data is for
    474     // the pattern, and we have the pattern's type, but we are forced to copy
    475     // them into an ASTContext because TypeSourceInfo bundles them together
    476     // and TemplateArgumentLoc traffics in TypeSourceInfo pointers.
    477     TypeSourceInfo *PatternTSInfo
    478       = Context.CreateTypeSourceInfo(Pattern.getType(),
    479                                      Pattern.getFullDataSize());
    480     memcpy(PatternTSInfo->getTypeLoc().getOpaqueData(),
    481            Pattern.getOpaqueData(), Pattern.getFullDataSize());
    482     return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
    483                                PatternTSInfo);
    484   }
    485 
    486   case TemplateArgument::Expression: {
    487     PackExpansionExpr *Expansion
    488       = cast<PackExpansionExpr>(Argument.getAsExpr());
    489     Expr *Pattern = Expansion->getPattern();
    490     Ellipsis = Expansion->getEllipsisLoc();
    491     NumExpansions = Expansion->getNumExpansions();
    492     return TemplateArgumentLoc(Pattern, Pattern);
    493   }
    494 
    495   case TemplateArgument::TemplateExpansion:
    496     Ellipsis = getTemplateEllipsisLoc();
    497     NumExpansions = Argument.getNumTemplateExpansions();
    498     return TemplateArgumentLoc(Argument.getPackExpansionPattern(),
    499                                getTemplateQualifierLoc(),
    500                                getTemplateNameLoc());
    501 
    502   case TemplateArgument::Declaration:
    503   case TemplateArgument::NullPtr:
    504   case TemplateArgument::Template:
    505   case TemplateArgument::Integral:
    506   case TemplateArgument::Pack:
    507   case TemplateArgument::Null:
    508     return TemplateArgumentLoc();
    509   }
    510 
    511   llvm_unreachable("Invalid TemplateArgument Kind!");
    512 }
    513 
    514 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
    515                                            const TemplateArgument &Arg) {
    516   switch (Arg.getKind()) {
    517   case TemplateArgument::Null:
    518     // This is bad, but not as bad as crashing because of argument
    519     // count mismatches.
    520     return DB << "(null template argument)";
    521 
    522   case TemplateArgument::Type:
    523     return DB << Arg.getAsType();
    524 
    525   case TemplateArgument::Declaration:
    526     return DB << Arg.getAsDecl();
    527 
    528   case TemplateArgument::NullPtr:
    529     return DB << "nullptr";
    530 
    531   case TemplateArgument::Integral:
    532     return DB << Arg.getAsIntegral().toString(10);
    533 
    534   case TemplateArgument::Template:
    535     return DB << Arg.getAsTemplate();
    536 
    537   case TemplateArgument::TemplateExpansion:
    538     return DB << Arg.getAsTemplateOrTemplatePattern() << "...";
    539 
    540   case TemplateArgument::Expression: {
    541     // This shouldn't actually ever happen, so it's okay that we're
    542     // regurgitating an expression here.
    543     // FIXME: We're guessing at LangOptions!
    544     SmallString<32> Str;
    545     llvm::raw_svector_ostream OS(Str);
    546     LangOptions LangOpts;
    547     LangOpts.CPlusPlus = true;
    548     PrintingPolicy Policy(LangOpts);
    549     Arg.getAsExpr()->printPretty(OS, 0, Policy);
    550     return DB << OS.str();
    551   }
    552 
    553   case TemplateArgument::Pack: {
    554     // FIXME: We're guessing at LangOptions!
    555     SmallString<32> Str;
    556     llvm::raw_svector_ostream OS(Str);
    557     LangOptions LangOpts;
    558     LangOpts.CPlusPlus = true;
    559     PrintingPolicy Policy(LangOpts);
    560     Arg.print(Policy, OS);
    561     return DB << OS.str();
    562   }
    563   }
    564 
    565   llvm_unreachable("Invalid TemplateArgument Kind!");
    566 }
    567 
    568 const ASTTemplateArgumentListInfo *
    569 ASTTemplateArgumentListInfo::Create(ASTContext &C,
    570                                     const TemplateArgumentListInfo &List) {
    571   std::size_t size = ASTTemplateArgumentListInfo::sizeFor(List.size());
    572   void *Mem = C.Allocate(size, llvm::alignOf<ASTTemplateArgumentListInfo>());
    573   ASTTemplateArgumentListInfo *TAI = new (Mem) ASTTemplateArgumentListInfo();
    574   TAI->initializeFrom(List);
    575   return TAI;
    576 }
    577 
    578 void ASTTemplateArgumentListInfo::initializeFrom(
    579                                       const TemplateArgumentListInfo &Info) {
    580   LAngleLoc = Info.getLAngleLoc();
    581   RAngleLoc = Info.getRAngleLoc();
    582   NumTemplateArgs = Info.size();
    583 
    584   TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
    585   for (unsigned i = 0; i != NumTemplateArgs; ++i)
    586     new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
    587 }
    588 
    589 void ASTTemplateArgumentListInfo::initializeFrom(
    590                                           const TemplateArgumentListInfo &Info,
    591                                                   bool &Dependent,
    592                                                   bool &InstantiationDependent,
    593                                        bool &ContainsUnexpandedParameterPack) {
    594   LAngleLoc = Info.getLAngleLoc();
    595   RAngleLoc = Info.getRAngleLoc();
    596   NumTemplateArgs = Info.size();
    597 
    598   TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
    599   for (unsigned i = 0; i != NumTemplateArgs; ++i) {
    600     Dependent = Dependent || Info[i].getArgument().isDependent();
    601     InstantiationDependent = InstantiationDependent ||
    602                              Info[i].getArgument().isInstantiationDependent();
    603     ContainsUnexpandedParameterPack
    604       = ContainsUnexpandedParameterPack ||
    605         Info[i].getArgument().containsUnexpandedParameterPack();
    606 
    607     new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
    608   }
    609 }
    610 
    611 void ASTTemplateArgumentListInfo::copyInto(
    612                                       TemplateArgumentListInfo &Info) const {
    613   Info.setLAngleLoc(LAngleLoc);
    614   Info.setRAngleLoc(RAngleLoc);
    615   for (unsigned I = 0; I != NumTemplateArgs; ++I)
    616     Info.addArgument(getTemplateArgs()[I]);
    617 }
    618 
    619 std::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) {
    620   return sizeof(ASTTemplateArgumentListInfo) +
    621          sizeof(TemplateArgumentLoc) * NumTemplateArgs;
    622 }
    623 
    624 void
    625 ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc,
    626                                          const TemplateArgumentListInfo &Info) {
    627   Base::initializeFrom(Info);
    628   setTemplateKeywordLoc(TemplateKWLoc);
    629 }
    630 
    631 void
    632 ASTTemplateKWAndArgsInfo
    633 ::initializeFrom(SourceLocation TemplateKWLoc,
    634                  const TemplateArgumentListInfo &Info,
    635                  bool &Dependent,
    636                  bool &InstantiationDependent,
    637                  bool &ContainsUnexpandedParameterPack) {
    638   Base::initializeFrom(Info, Dependent, InstantiationDependent,
    639                        ContainsUnexpandedParameterPack);
    640   setTemplateKeywordLoc(TemplateKWLoc);
    641 }
    642 
    643 void
    644 ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) {
    645   // No explicit template arguments, but template keyword loc is valid.
    646   assert(TemplateKWLoc.isValid());
    647   LAngleLoc = SourceLocation();
    648   RAngleLoc = SourceLocation();
    649   NumTemplateArgs = 0;
    650   setTemplateKeywordLoc(TemplateKWLoc);
    651 }
    652 
    653 std::size_t
    654 ASTTemplateKWAndArgsInfo::sizeFor(unsigned NumTemplateArgs) {
    655   // Add space for the template keyword location.
    656   // FIXME: There's room for this in the padding before the template args in
    657   //        64-bit builds.
    658   return Base::sizeFor(NumTemplateArgs) + sizeof(SourceLocation);
    659 }
    660