contrib/llvm/tools/clang/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 <algorithm>
  27 #include <cctype>
  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 llvm::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
 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     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
 410 TemplateArgumentLocInfo::TemplateArgumentLocInfo() {
 411   memset((void*)this, 0, sizeof(TemplateArgumentLocInfo));
 412 }
 413
 414 SourceRange 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
 454 TemplateArgumentLoc
 455 TemplateArgumentLoc::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
 517 const 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
 571 const ASTTemplateArgumentListInfo *
 572 ASTTemplateArgumentListInfo::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
 581 void 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
 592 void 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
 614 void 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
 622 std::size_t ASTTemplateArgumentListInfo::sizeFor(unsigned NumTemplateArgs) {
 623   return sizeof(ASTTemplateArgumentListInfo) +
 624          sizeof(TemplateArgumentLoc) * NumTemplateArgs;
 625 }
 626
 627 void
 628 ASTTemplateKWAndArgsInfo::initializeFrom(SourceLocation TemplateKWLoc,
 629                                          const TemplateArgumentListInfo &Info) {
 630   Base::initializeFrom(Info);
 631   setTemplateKeywordLoc(TemplateKWLoc);
 632 }
 633
 634 void
 635 ASTTemplateKWAndArgsInfo
 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
 646 void
 647 ASTTemplateKWAndArgsInfo::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
 656 std::size_t
 657 ASTTemplateKWAndArgsInfo::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 }