lib/AST/TemplateBase.cpp

   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 ///
  37 /// \param Policy the printing policy for EnumConstantDecl printing.
  38 static void printIntegral(const TemplateArgument &TemplArg,
  39                           raw_ostream &Out, const PrintingPolicy& Policy) {
  40   const ::clang::Type *T = TemplArg.getIntegralType().getTypePtr();
  41   const llvm::APSInt &Val = TemplArg.getAsIntegral();
  42
  43   if (const EnumType *ET = T->getAs<EnumType>()) {
  44     for (const EnumConstantDecl* ECD : ET->getDecl()->enumerators()) {
  45       // In Sema::CheckTemplateArugment, enum template arguments value are
  46       // extended to the size of the integer underlying the enum type.  This
  47       // may create a size difference between the enum value and template
  48       // argument value, requiring isSameValue here instead of operator==.
  49       if (llvm::APSInt::isSameValue(ECD->getInitVal(), Val)) {
  50         ECD->printQualifiedName(Out, Policy);
  51         return;
  52       }
  53     }
  54   }
  55
  56   if (T->isBooleanType() && !Policy.MSVCFormatting) {
  57     Out << (Val.getBoolValue() ? "true" : "false");
  58   } else if (T->isCharType()) {
  59     const char Ch = Val.getZExtValue();
  60     Out << ((Ch == '\'') ? "'\\" : "'");
  61     Out.write_escaped(StringRef(&Ch, 1), /*UseHexEscapes=*/ true);
  62     Out << "'";
  63   } else {
  64     Out << Val;
  65   }
  66 }
  67
  68 //===----------------------------------------------------------------------===//
  69 // TemplateArgument Implementation
  70 //===----------------------------------------------------------------------===//
  71
  72 TemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value,
  73                                    QualType Type) {
  74   Integer.Kind = Integral;
  75   // Copy the APSInt value into our decomposed form.
  76   Integer.BitWidth = Value.getBitWidth();
  77   Integer.IsUnsigned = Value.isUnsigned();
  78   // If the value is large, we have to get additional memory from the ASTContext
  79   unsigned NumWords = Value.getNumWords();
  80   if (NumWords > 1) {
  81     void *Mem = Ctx.Allocate(NumWords * sizeof(uint64_t));
  82     std::memcpy(Mem, Value.getRawData(), NumWords * sizeof(uint64_t));
  83     Integer.pVal = static_cast<uint64_t *>(Mem);
  84   } else {
  85     Integer.VAL = Value.getZExtValue();
  86   }
  87
  88   Integer.Type = Type.getAsOpaquePtr();
  89 }
  90
  91 TemplateArgument
  92 TemplateArgument::CreatePackCopy(ASTContext &Context,
  93                                  ArrayRef<TemplateArgument> Args) {
  94   if (Args.empty())
  95     return getEmptyPack();
  96
  97   return TemplateArgument(Args.copy(Context));
  98 }
  99
 100 bool TemplateArgument::isDependent() const {
 101   switch (getKind()) {
 102   case Null:
 103     llvm_unreachable("Should not have a NULL template argument");
 104
 105   case Type:
 106     return getAsType()->isDependentType() ||
 107            isa<PackExpansionType>(getAsType());
 108
 109   case Template:
 110     return getAsTemplate().isDependent();
 111
 112   case TemplateExpansion:
 113     return true;
 114
 115   case Declaration:
 116     if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
 117       return DC->isDependentContext();
 118     return getAsDecl()->getDeclContext()->isDependentContext();
 119
 120   case NullPtr:
 121     return false;
 122
 123   case Integral:
 124     // Never dependent
 125     return false;
 126
 127   case Expression:
 128     return (getAsExpr()->isTypeDependent() || getAsExpr()->isValueDependent() ||
 129             isa<PackExpansionExpr>(getAsExpr()));
 130
 131   case Pack:
 132     for (const auto &P : pack_elements())
 133       if (P.isDependent())
 134         return true;
 135     return false;
 136   }
 137
 138   llvm_unreachable("Invalid TemplateArgument Kind!");
 139 }
 140
 141 bool TemplateArgument::isInstantiationDependent() const {
 142   switch (getKind()) {
 143   case Null:
 144     llvm_unreachable("Should not have a NULL template argument");
 145
 146   case Type:
 147     return getAsType()->isInstantiationDependentType();
 148
 149   case Template:
 150     return getAsTemplate().isInstantiationDependent();
 151
 152   case TemplateExpansion:
 153     return true;
 154
 155   case Declaration:
 156     if (DeclContext *DC = dyn_cast<DeclContext>(getAsDecl()))
 157       return DC->isDependentContext();
 158     return getAsDecl()->getDeclContext()->isDependentContext();
 159
 160   case NullPtr:
 161     return false;
 162
 163   case Integral:
 164     // Never dependent
 165     return false;
 166
 167   case Expression:
 168     return getAsExpr()->isInstantiationDependent();
 169
 170   case Pack:
 171     for (const auto &P : pack_elements())
 172       if (P.isInstantiationDependent())
 173         return true;
 174     return false;
 175   }
 176
 177   llvm_unreachable("Invalid TemplateArgument Kind!");
 178 }
 179
 180 bool TemplateArgument::isPackExpansion() const {
 181   switch (getKind()) {
 182   case Null:
 183   case Declaration:
 184   case Integral:
 185   case Pack:
 186   case Template:
 187   case NullPtr:
 188     return false;
 189
 190   case TemplateExpansion:
 191     return true;
 192
 193   case Type:
 194     return isa<PackExpansionType>(getAsType());
 195
 196   case Expression:
 197     return isa<PackExpansionExpr>(getAsExpr());
 198   }
 199
 200   llvm_unreachable("Invalid TemplateArgument Kind!");
 201 }
 202
 203 bool TemplateArgument::containsUnexpandedParameterPack() const {
 204   switch (getKind()) {
 205   case Null:
 206   case Declaration:
 207   case Integral:
 208   case TemplateExpansion:
 209   case NullPtr:
 210     break;
 211
 212   case Type:
 213     if (getAsType()->containsUnexpandedParameterPack())
 214       return true;
 215     break;
 216
 217   case Template:
 218     if (getAsTemplate().containsUnexpandedParameterPack())
 219       return true;
 220     break;
 221
 222   case Expression:
 223     if (getAsExpr()->containsUnexpandedParameterPack())
 224       return true;
 225     break;
 226
 227   case Pack:
 228     for (const auto &P : pack_elements())
 229       if (P.containsUnexpandedParameterPack())
 230         return true;
 231
 232     break;
 233   }
 234
 235   return false;
 236 }
 237
 238 Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const {
 239   assert(getKind() == TemplateExpansion);
 240   if (TemplateArg.NumExpansions)
 241     return TemplateArg.NumExpansions - 1;
 242
 243   return None;
 244 }
 245
 246 QualType TemplateArgument::getNonTypeTemplateArgumentType() const {
 247   switch (getKind()) {
 248   case TemplateArgument::Null:
 249   case TemplateArgument::Type:
 250   case TemplateArgument::Template:
 251   case TemplateArgument::TemplateExpansion:
 252   case TemplateArgument::Pack:
 253     return QualType();
 254
 255   case TemplateArgument::Integral:
 256     return getIntegralType();
 257
 258   case TemplateArgument::Expression:
 259     return getAsExpr()->getType();
 260
 261   case TemplateArgument::Declaration:
 262     return getParamTypeForDecl();
 263
 264   case TemplateArgument::NullPtr:
 265     return getNullPtrType();
 266   }
 267
 268   llvm_unreachable("Invalid TemplateArgument Kind!");
 269 }
 270
 271 void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID,
 272                                const ASTContext &Context) const {
 273   ID.AddInteger(getKind());
 274   switch (getKind()) {
 275   case Null:
 276     break;
 277
 278   case Type:
 279     getAsType().Profile(ID);
 280     break;
 281
 282   case NullPtr:
 283     getNullPtrType().Profile(ID);
 284     break;
 285
 286   case Declaration:
 287     ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : nullptr);
 288     break;
 289
 290   case Template:
 291   case TemplateExpansion: {
 292     TemplateName Template = getAsTemplateOrTemplatePattern();
 293     if (TemplateTemplateParmDecl *TTP
 294           = dyn_cast_or_null<TemplateTemplateParmDecl>(
 295                                                 Template.getAsTemplateDecl())) {
 296       ID.AddBoolean(true);
 297       ID.AddInteger(TTP->getDepth());
 298       ID.AddInteger(TTP->getPosition());
 299       ID.AddBoolean(TTP->isParameterPack());
 300     } else {
 301       ID.AddBoolean(false);
 302       ID.AddPointer(Context.getCanonicalTemplateName(Template)
 303                                                           .getAsVoidPointer());
 304     }
 305     break;
 306   }
 307
 308   case Integral:
 309     getAsIntegral().Profile(ID);
 310     getIntegralType().Profile(ID);
 311     break;
 312
 313   case Expression:
 314     getAsExpr()->Profile(ID, Context, true);
 315     break;
 316
 317   case Pack:
 318     ID.AddInteger(Args.NumArgs);
 319     for (unsigned I = 0; I != Args.NumArgs; ++I)
 320       Args.Args[I].Profile(ID, Context);
 321   }
 322 }
 323
 324 bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const {
 325   if (getKind() != Other.getKind()) return false;
 326
 327   switch (getKind()) {
 328   case Null:
 329   case Type:
 330   case Expression:
 331   case Template:
 332   case TemplateExpansion:
 333   case NullPtr:
 334     return TypeOrValue.V == Other.TypeOrValue.V;
 335
 336   case Declaration:
 337     return getAsDecl() == Other.getAsDecl();
 338
 339   case Integral:
 340     return getIntegralType() == Other.getIntegralType() &&
 341            getAsIntegral() == Other.getAsIntegral();
 342
 343   case Pack:
 344     if (Args.NumArgs != Other.Args.NumArgs) return false;
 345     for (unsigned I = 0, E = Args.NumArgs; I != E; ++I)
 346       if (!Args.Args[I].structurallyEquals(Other.Args.Args[I]))
 347         return false;
 348     return true;
 349   }
 350
 351   llvm_unreachable("Invalid TemplateArgument Kind!");
 352 }
 353
 354 TemplateArgument TemplateArgument::getPackExpansionPattern() const {
 355   assert(isPackExpansion());
 356
 357   switch (getKind()) {
 358   case Type:
 359     return getAsType()->getAs<PackExpansionType>()->getPattern();
 360
 361   case Expression:
 362     return cast<PackExpansionExpr>(getAsExpr())->getPattern();
 363
 364   case TemplateExpansion:
 365     return TemplateArgument(getAsTemplateOrTemplatePattern());
 366
 367   case Declaration:
 368   case Integral:
 369   case Pack:
 370   case Null:
 371   case Template:
 372   case NullPtr:
 373     return TemplateArgument();
 374   }
 375
 376   llvm_unreachable("Invalid TemplateArgument Kind!");
 377 }
 378
 379 void TemplateArgument::print(const PrintingPolicy &Policy,
 380                              raw_ostream &Out) const {
 381   switch (getKind()) {
 382   case Null:
 383     Out << "(no value)";
 384     break;
 385
 386   case Type: {
 387     PrintingPolicy SubPolicy(Policy);
 388     SubPolicy.SuppressStrongLifetime = true;
 389     getAsType().print(Out, SubPolicy);
 390     break;
 391   }
 392
 393   case Declaration: {
 394     NamedDecl *ND = cast<NamedDecl>(getAsDecl());
 395     Out << '&';
 396     if (ND->getDeclName()) {
 397       // FIXME: distinguish between pointer and reference args?
 398       ND->printQualifiedName(Out);
 399     } else {
 400       Out << "(anonymous)";
 401     }
 402     break;
 403   }
 404
 405   case NullPtr:
 406     Out << "nullptr";
 407     break;
 408
 409   case Template:
 410     getAsTemplate().print(Out, Policy);
 411     break;
 412
 413   case TemplateExpansion:
 414     getAsTemplateOrTemplatePattern().print(Out, Policy);
 415     Out << "...";
 416     break;
 417
 418   case Integral: {
 419     printIntegral(*this, Out, Policy);
 420     break;
 421   }
 422
 423   case Expression:
 424     getAsExpr()->printPretty(Out, nullptr, Policy);
 425     break;
 426
 427   case Pack:
 428     Out << "<";
 429     bool First = true;
 430     for (const auto &P : pack_elements()) {
 431       if (First)
 432         First = false;
 433       else
 434         Out << ", ";
 435
 436       P.print(Policy, Out);
 437     }
 438     Out << ">";
 439     break;
 440   }
 441 }
 442
 443 void TemplateArgument::dump(raw_ostream &Out) const {
 444   LangOptions LO; // FIXME! see also TemplateName::dump().
 445   LO.CPlusPlus = true;
 446   LO.Bool = true;
 447   print(PrintingPolicy(LO), Out);
 448 }
 449
 450 LLVM_DUMP_METHOD void TemplateArgument::dump() const { dump(llvm::errs()); }
 451
 452 //===----------------------------------------------------------------------===//
 453 // TemplateArgumentLoc Implementation
 454 //===----------------------------------------------------------------------===//
 455
 456 TemplateArgumentLocInfo::TemplateArgumentLocInfo() {
 457   memset((void*)this, 0, sizeof(TemplateArgumentLocInfo));
 458 }
 459
 460 SourceRange TemplateArgumentLoc::getSourceRange() const {
 461   switch (Argument.getKind()) {
 462   case TemplateArgument::Expression:
 463     return getSourceExpression()->getSourceRange();
 464
 465   case TemplateArgument::Declaration:
 466     return getSourceDeclExpression()->getSourceRange();
 467
 468   case TemplateArgument::NullPtr:
 469     return getSourceNullPtrExpression()->getSourceRange();
 470
 471   case TemplateArgument::Type:
 472     if (TypeSourceInfo *TSI = getTypeSourceInfo())
 473       return TSI->getTypeLoc().getSourceRange();
 474     else
 475       return SourceRange();
 476
 477   case TemplateArgument::Template:
 478     if (getTemplateQualifierLoc())
 479       return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
 480                          getTemplateNameLoc());
 481     return SourceRange(getTemplateNameLoc());
 482
 483   case TemplateArgument::TemplateExpansion:
 484     if (getTemplateQualifierLoc())
 485       return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
 486                          getTemplateEllipsisLoc());
 487     return SourceRange(getTemplateNameLoc(), getTemplateEllipsisLoc());
 488
 489   case TemplateArgument::Integral:
 490     return getSourceIntegralExpression()->getSourceRange();
 491
 492   case TemplateArgument::Pack:
 493   case TemplateArgument::Null:
 494     return SourceRange();
 495   }
 496
 497   llvm_unreachable("Invalid TemplateArgument Kind!");
 498 }
 499
 500 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
 501                                            const TemplateArgument &Arg) {
 502   switch (Arg.getKind()) {
 503   case TemplateArgument::Null:
 504     // This is bad, but not as bad as crashing because of argument
 505     // count mismatches.
 506     return DB << "(null template argument)";
 507
 508   case TemplateArgument::Type:
 509     return DB << Arg.getAsType();
 510
 511   case TemplateArgument::Declaration:
 512     return DB << Arg.getAsDecl();
 513
 514   case TemplateArgument::NullPtr:
 515     return DB << "nullptr";
 516
 517   case TemplateArgument::Integral:
 518     return DB << Arg.getAsIntegral().toString(10);
 519
 520   case TemplateArgument::Template:
 521     return DB << Arg.getAsTemplate();
 522
 523   case TemplateArgument::TemplateExpansion:
 524     return DB << Arg.getAsTemplateOrTemplatePattern() << "...";
 525
 526   case TemplateArgument::Expression: {
 527     // This shouldn't actually ever happen, so it's okay that we're
 528     // regurgitating an expression here.
 529     // FIXME: We're guessing at LangOptions!
 530     SmallString<32> Str;
 531     llvm::raw_svector_ostream OS(Str);
 532     LangOptions LangOpts;
 533     LangOpts.CPlusPlus = true;
 534     PrintingPolicy Policy(LangOpts);
 535     Arg.getAsExpr()->printPretty(OS, nullptr, Policy);
 536     return DB << OS.str();
 537   }
 538
 539   case TemplateArgument::Pack: {
 540     // FIXME: We're guessing at LangOptions!
 541     SmallString<32> Str;
 542     llvm::raw_svector_ostream OS(Str);
 543     LangOptions LangOpts;
 544     LangOpts.CPlusPlus = true;
 545     PrintingPolicy Policy(LangOpts);
 546     Arg.print(Policy, OS);
 547     return DB << OS.str();
 548   }
 549   }
 550
 551   llvm_unreachable("Invalid TemplateArgument Kind!");
 552 }
 553
 554 const ASTTemplateArgumentListInfo *
 555 ASTTemplateArgumentListInfo::Create(ASTContext &C,
 556                                     const TemplateArgumentListInfo &List) {
 557   std::size_t size = totalSizeToAlloc<TemplateArgumentLoc>(List.size());
 558   void *Mem = C.Allocate(size, alignof(ASTTemplateArgumentListInfo));
 559   return new (Mem) ASTTemplateArgumentListInfo(List);
 560 }
 561
 562 ASTTemplateArgumentListInfo::ASTTemplateArgumentListInfo(
 563     const TemplateArgumentListInfo &Info) {
 564   LAngleLoc = Info.getLAngleLoc();
 565   RAngleLoc = Info.getRAngleLoc();
 566   NumTemplateArgs = Info.size();
 567
 568   TemplateArgumentLoc *ArgBuffer = getTrailingObjects<TemplateArgumentLoc>();
 569   for (unsigned i = 0; i != NumTemplateArgs; ++i)
 570     new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
 571 }
 572
 573 void ASTTemplateKWAndArgsInfo::initializeFrom(
 574     SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info,
 575     TemplateArgumentLoc *OutArgArray) {
 576   this->TemplateKWLoc = TemplateKWLoc;
 577   LAngleLoc = Info.getLAngleLoc();
 578   RAngleLoc = Info.getRAngleLoc();
 579   NumTemplateArgs = Info.size();
 580
 581   for (unsigned i = 0; i != NumTemplateArgs; ++i)
 582     new (&OutArgArray[i]) TemplateArgumentLoc(Info[i]);
 583 }
 584
 585 void ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc) {
 586   assert(TemplateKWLoc.isValid());
 587   LAngleLoc = SourceLocation();
 588   RAngleLoc = SourceLocation();
 589   this->TemplateKWLoc = TemplateKWLoc;
 590   NumTemplateArgs = 0;
 591 }
 592
 593 void ASTTemplateKWAndArgsInfo::initializeFrom(
 594     SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info,
 595     TemplateArgumentLoc *OutArgArray, bool &Dependent,
 596     bool &InstantiationDependent, bool &ContainsUnexpandedParameterPack) {
 597   this->TemplateKWLoc = TemplateKWLoc;
 598   LAngleLoc = Info.getLAngleLoc();
 599   RAngleLoc = Info.getRAngleLoc();
 600   NumTemplateArgs = Info.size();
 601
 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 (&OutArgArray[i]) TemplateArgumentLoc(Info[i]);
 611   }
 612 }
 613
 614 void ASTTemplateKWAndArgsInfo::copyInto(const TemplateArgumentLoc *ArgArray,
 615                                         TemplateArgumentListInfo &Info) const {
 616   Info.setLAngleLoc(LAngleLoc);
 617   Info.setRAngleLoc(RAngleLoc);
 618   for (unsigned I = 0; I != NumTemplateArgs; ++I)
 619     Info.addArgument(ArgArray[I]);
 620 }