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