TypeLoc.h revision 5013fcf1236980bd164ad070df298a0364e1e45f
1//===--- TypeLoc.h - Type Source Info Wrapper -------------------*- C++ -*-===// 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/// \file 11/// \brief Defines the clang::TypeLoc interface and its subclasses. 12/// 13//===----------------------------------------------------------------------===// 14 15#ifndef LLVM_CLANG_AST_TYPELOC_H 16#define LLVM_CLANG_AST_TYPELOC_H 17 18#include "clang/AST/Decl.h" 19#include "clang/AST/TemplateBase.h" 20#include "clang/AST/Type.h" 21#include "clang/Basic/Specifiers.h" 22#include "llvm/Support/Compiler.h" 23 24namespace clang { 25 class ASTContext; 26 class ParmVarDecl; 27 class TypeSourceInfo; 28 class UnqualTypeLoc; 29 30// Predeclare all the type nodes. 31#define ABSTRACT_TYPELOC(Class, Base) 32#define TYPELOC(Class, Base) \ 33 class Class##TypeLoc; 34#include "clang/AST/TypeLocNodes.def" 35 36/// \brief Base wrapper for a particular "section" of type source info. 37/// 38/// A client should use the TypeLoc subclasses through castAs()/getAs() 39/// in order to get at the actual information. 40class TypeLoc { 41protected: 42 // The correctness of this relies on the property that, for Type *Ty, 43 // QualType(Ty, 0).getAsOpaquePtr() == (void*) Ty 44 const void *Ty; 45 void *Data; 46 47public: 48 /// \brief Convert to the specified TypeLoc type, asserting that this TypeLoc 49 /// is of the desired type. 50 /// 51 /// \pre T::isKind(*this) 52 template<typename T> 53 T castAs() const { 54 assert(T::isKind(*this)); 55 T t; 56 TypeLoc& tl = t; 57 tl = *this; 58 return t; 59 } 60 61 /// \brief Convert to the specified TypeLoc type, returning a null TypeLoc if 62 /// this TypeLoc is not of the desired type. 63 template<typename T> 64 T getAs() const { 65 if (!T::isKind(*this)) 66 return T(); 67 T t; 68 TypeLoc& tl = t; 69 tl = *this; 70 return t; 71 } 72 73 /// The kinds of TypeLocs. Equivalent to the Type::TypeClass enum, 74 /// except it also defines a Qualified enum that corresponds to the 75 /// QualifiedLoc class. 76 enum TypeLocClass { 77#define ABSTRACT_TYPE(Class, Base) 78#define TYPE(Class, Base) \ 79 Class = Type::Class, 80#include "clang/AST/TypeNodes.def" 81 Qualified 82 }; 83 84 TypeLoc() : Ty(0), Data(0) { } 85 TypeLoc(QualType ty, void *opaqueData) 86 : Ty(ty.getAsOpaquePtr()), Data(opaqueData) { } 87 TypeLoc(const Type *ty, void *opaqueData) 88 : Ty(ty), Data(opaqueData) { } 89 90 TypeLocClass getTypeLocClass() const { 91 if (getType().hasLocalQualifiers()) return Qualified; 92 return (TypeLocClass) getType()->getTypeClass(); 93 } 94 95 bool isNull() const { return !Ty; } 96 LLVM_EXPLICIT operator bool() const { return Ty; } 97 98 /// \brief Returns the size of type source info data block for the given type. 99 static unsigned getFullDataSizeForType(QualType Ty); 100 101 /// \brief Returns the alignment of type source info data block for 102 /// the given type. 103 static unsigned getLocalAlignmentForType(QualType Ty); 104 105 /// \brief Get the type for which this source info wrapper provides 106 /// information. 107 QualType getType() const { 108 return QualType::getFromOpaquePtr(Ty); 109 } 110 111 const Type *getTypePtr() const { 112 return QualType::getFromOpaquePtr(Ty).getTypePtr(); 113 } 114 115 /// \brief Get the pointer where source information is stored. 116 void *getOpaqueData() const { 117 return Data; 118 } 119 120 /// \brief Get the begin source location. 121 SourceLocation getBeginLoc() const; 122 123 /// \brief Get the end source location. 124 SourceLocation getEndLoc() const; 125 126 /// \brief Get the full source range. 127 SourceRange getSourceRange() const LLVM_READONLY { 128 return SourceRange(getBeginLoc(), getEndLoc()); 129 } 130 SourceLocation getLocStart() const LLVM_READONLY { return getBeginLoc(); } 131 SourceLocation getLocEnd() const LLVM_READONLY { return getEndLoc(); } 132 133 /// \brief Get the local source range. 134 SourceRange getLocalSourceRange() const { 135 return getLocalSourceRangeImpl(*this); 136 } 137 138 /// \brief Returns the size of the type source info data block. 139 unsigned getFullDataSize() const { 140 return getFullDataSizeForType(getType()); 141 } 142 143 /// \brief Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the 144 /// TypeLoc is a PointerLoc and next TypeLoc is for "int". 145 TypeLoc getNextTypeLoc() const { 146 return getNextTypeLocImpl(*this); 147 } 148 149 /// \brief Skips past any qualifiers, if this is qualified. 150 UnqualTypeLoc getUnqualifiedLoc() const; // implemented in this header 151 152 TypeLoc IgnoreParens() const; 153 154 /// \brief Initializes this to state that every location in this 155 /// type is the given location. 156 /// 157 /// This method exists to provide a simple transition for code that 158 /// relies on location-less types. 159 void initialize(ASTContext &Context, SourceLocation Loc) const { 160 initializeImpl(Context, *this, Loc); 161 } 162 163 /// \brief Initializes this by copying its information from another 164 /// TypeLoc of the same type. 165 void initializeFullCopy(TypeLoc Other) const { 166 assert(getType() == Other.getType()); 167 size_t Size = getFullDataSize(); 168 memcpy(getOpaqueData(), Other.getOpaqueData(), Size); 169 } 170 171 /// \brief Initializes this by copying its information from another 172 /// TypeLoc of the same type. The given size must be the full data 173 /// size. 174 void initializeFullCopy(TypeLoc Other, unsigned Size) const { 175 assert(getType() == Other.getType()); 176 assert(getFullDataSize() == Size); 177 memcpy(getOpaqueData(), Other.getOpaqueData(), Size); 178 } 179 180 friend bool operator==(const TypeLoc &LHS, const TypeLoc &RHS) { 181 return LHS.Ty == RHS.Ty && LHS.Data == RHS.Data; 182 } 183 184 friend bool operator!=(const TypeLoc &LHS, const TypeLoc &RHS) { 185 return !(LHS == RHS); 186 } 187 188private: 189 static bool isKind(const TypeLoc&) { 190 return true; 191 } 192 193 static void initializeImpl(ASTContext &Context, TypeLoc TL, 194 SourceLocation Loc); 195 static TypeLoc getNextTypeLocImpl(TypeLoc TL); 196 static TypeLoc IgnoreParensImpl(TypeLoc TL); 197 static SourceRange getLocalSourceRangeImpl(TypeLoc TL); 198}; 199 200/// \brief Return the TypeLoc for a type source info. 201inline TypeLoc TypeSourceInfo::getTypeLoc() const { 202 return TypeLoc(Ty, const_cast<void*>(static_cast<const void*>(this + 1))); 203} 204 205/// \brief Wrapper of type source information for a type with 206/// no direct qualifiers. 207class UnqualTypeLoc : public TypeLoc { 208public: 209 UnqualTypeLoc() {} 210 UnqualTypeLoc(const Type *Ty, void *Data) : TypeLoc(Ty, Data) {} 211 212 const Type *getTypePtr() const { 213 return reinterpret_cast<const Type*>(Ty); 214 } 215 216 TypeLocClass getTypeLocClass() const { 217 return (TypeLocClass) getTypePtr()->getTypeClass(); 218 } 219 220private: 221 friend class TypeLoc; 222 static bool isKind(const TypeLoc &TL) { 223 return !TL.getType().hasLocalQualifiers(); 224 } 225}; 226 227/// \brief Wrapper of type source information for a type with 228/// non-trivial direct qualifiers. 229/// 230/// Currently, we intentionally do not provide source location for 231/// type qualifiers. 232class QualifiedTypeLoc : public TypeLoc { 233public: 234 SourceRange getLocalSourceRange() const { 235 return SourceRange(); 236 } 237 238 UnqualTypeLoc getUnqualifiedLoc() const { 239 unsigned align = 240 TypeLoc::getLocalAlignmentForType(QualType(getTypePtr(), 0)); 241 uintptr_t dataInt = reinterpret_cast<uintptr_t>(Data); 242 dataInt = llvm::RoundUpToAlignment(dataInt, align); 243 return UnqualTypeLoc(getTypePtr(), reinterpret_cast<void*>(dataInt)); 244 } 245 246 /// Initializes the local data of this type source info block to 247 /// provide no information. 248 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 249 // do nothing 250 } 251 252 TypeLoc getNextTypeLoc() const { 253 return getUnqualifiedLoc(); 254 } 255 256 /// \brief Returns the size of the type source info data block that is 257 /// specific to this type. 258 unsigned getLocalDataSize() const { 259 // In fact, we don't currently preserve any location information 260 // for qualifiers. 261 return 0; 262 } 263 264 /// \brief Returns the alignment of the type source info data block that is 265 /// specific to this type. 266 unsigned getLocalDataAlignment() const { 267 // We don't preserve any location information. 268 return 1; 269 } 270 271private: 272 friend class TypeLoc; 273 static bool isKind(const TypeLoc &TL) { 274 return TL.getType().hasLocalQualifiers(); 275 } 276}; 277 278inline UnqualTypeLoc TypeLoc::getUnqualifiedLoc() const { 279 if (QualifiedTypeLoc Loc = getAs<QualifiedTypeLoc>()) 280 return Loc.getUnqualifiedLoc(); 281 return castAs<UnqualTypeLoc>(); 282} 283 284/// A metaprogramming base class for TypeLoc classes which correspond 285/// to a particular Type subclass. It is accepted for a single 286/// TypeLoc class to correspond to multiple Type classes. 287/// 288/// \tparam Base a class from which to derive 289/// \tparam Derived the class deriving from this one 290/// \tparam TypeClass the concrete Type subclass associated with this 291/// location type 292/// \tparam LocalData the structure type of local location data for 293/// this type 294/// 295/// TypeLocs with non-constant amounts of local data should override 296/// getExtraLocalDataSize(); getExtraLocalData() will then point to 297/// this extra memory. 298/// 299/// TypeLocs with an inner type should define 300/// QualType getInnerType() const 301/// and getInnerTypeLoc() will then point to this inner type's 302/// location data. 303/// 304/// A word about hierarchies: this template is not designed to be 305/// derived from multiple times in a hierarchy. It is also not 306/// designed to be used for classes where subtypes might provide 307/// different amounts of source information. It should be subclassed 308/// only at the deepest portion of the hierarchy where all children 309/// have identical source information; if that's an abstract type, 310/// then further descendents should inherit from 311/// InheritingConcreteTypeLoc instead. 312template <class Base, class Derived, class TypeClass, class LocalData> 313class ConcreteTypeLoc : public Base { 314 315 const Derived *asDerived() const { 316 return static_cast<const Derived*>(this); 317 } 318 319 friend class TypeLoc; 320 static bool isKind(const TypeLoc &TL) { 321 return !TL.getType().hasLocalQualifiers() && 322 Derived::classofType(TL.getTypePtr()); 323 } 324 325 static bool classofType(const Type *Ty) { 326 return TypeClass::classof(Ty); 327 } 328 329public: 330 unsigned getLocalDataAlignment() const { 331 return std::max(llvm::alignOf<LocalData>(), 332 asDerived()->getExtraLocalDataAlignment()); 333 } 334 unsigned getLocalDataSize() const { 335 unsigned size = sizeof(LocalData); 336 unsigned extraAlign = asDerived()->getExtraLocalDataAlignment(); 337 size = llvm::RoundUpToAlignment(size, extraAlign); 338 size += asDerived()->getExtraLocalDataSize(); 339 return size; 340 } 341 342 TypeLoc getNextTypeLoc() const { 343 return getNextTypeLoc(asDerived()->getInnerType()); 344 } 345 346 const TypeClass *getTypePtr() const { 347 return cast<TypeClass>(Base::getTypePtr()); 348 } 349 350protected: 351 unsigned getExtraLocalDataSize() const { 352 return 0; 353 } 354 355 unsigned getExtraLocalDataAlignment() const { 356 return 1; 357 } 358 359 LocalData *getLocalData() const { 360 return static_cast<LocalData*>(Base::Data); 361 } 362 363 /// Gets a pointer past the Info structure; useful for classes with 364 /// local data that can't be captured in the Info (e.g. because it's 365 /// of variable size). 366 void *getExtraLocalData() const { 367 unsigned size = sizeof(LocalData); 368 unsigned extraAlign = asDerived()->getExtraLocalDataAlignment(); 369 size = llvm::RoundUpToAlignment(size, extraAlign); 370 return reinterpret_cast<char*>(Base::Data) + size; 371 } 372 373 void *getNonLocalData() const { 374 uintptr_t data = reinterpret_cast<uintptr_t>(Base::Data); 375 data += asDerived()->getLocalDataSize(); 376 data = llvm::RoundUpToAlignment(data, getNextTypeAlign()); 377 return reinterpret_cast<void*>(data); 378 } 379 380 struct HasNoInnerType {}; 381 HasNoInnerType getInnerType() const { return HasNoInnerType(); } 382 383 TypeLoc getInnerTypeLoc() const { 384 return TypeLoc(asDerived()->getInnerType(), getNonLocalData()); 385 } 386 387private: 388 unsigned getInnerTypeSize() const { 389 return getInnerTypeSize(asDerived()->getInnerType()); 390 } 391 392 unsigned getInnerTypeSize(HasNoInnerType _) const { 393 return 0; 394 } 395 396 unsigned getInnerTypeSize(QualType _) const { 397 return getInnerTypeLoc().getFullDataSize(); 398 } 399 400 unsigned getNextTypeAlign() const { 401 return getNextTypeAlign(asDerived()->getInnerType()); 402 } 403 404 unsigned getNextTypeAlign(HasNoInnerType _) const { 405 return 1; 406 } 407 408 unsigned getNextTypeAlign(QualType T) const { 409 return TypeLoc::getLocalAlignmentForType(T); 410 } 411 412 TypeLoc getNextTypeLoc(HasNoInnerType _) const { 413 return TypeLoc(); 414 } 415 416 TypeLoc getNextTypeLoc(QualType T) const { 417 return TypeLoc(T, getNonLocalData()); 418 } 419}; 420 421/// A metaprogramming class designed for concrete subtypes of abstract 422/// types where all subtypes share equivalently-structured source 423/// information. See the note on ConcreteTypeLoc. 424template <class Base, class Derived, class TypeClass> 425class InheritingConcreteTypeLoc : public Base { 426 friend class TypeLoc; 427 static bool classofType(const Type *Ty) { 428 return TypeClass::classof(Ty); 429 } 430 431 static bool isKind(const TypeLoc &TL) { 432 return !TL.getType().hasLocalQualifiers() && 433 Derived::classofType(TL.getTypePtr()); 434 } 435 static bool isKind(const UnqualTypeLoc &TL) { 436 return Derived::classofType(TL.getTypePtr()); 437 } 438 439public: 440 const TypeClass *getTypePtr() const { 441 return cast<TypeClass>(Base::getTypePtr()); 442 } 443}; 444 445 446struct TypeSpecLocInfo { 447 SourceLocation NameLoc; 448}; 449 450/// \brief A reasonable base class for TypeLocs that correspond to 451/// types that are written as a type-specifier. 452class TypeSpecTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, 453 TypeSpecTypeLoc, 454 Type, 455 TypeSpecLocInfo> { 456public: 457 enum { LocalDataSize = sizeof(TypeSpecLocInfo), 458 LocalDataAlignment = llvm::AlignOf<TypeSpecLocInfo>::Alignment }; 459 460 SourceLocation getNameLoc() const { 461 return this->getLocalData()->NameLoc; 462 } 463 void setNameLoc(SourceLocation Loc) { 464 this->getLocalData()->NameLoc = Loc; 465 } 466 SourceRange getLocalSourceRange() const { 467 return SourceRange(getNameLoc(), getNameLoc()); 468 } 469 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 470 setNameLoc(Loc); 471 } 472 473private: 474 friend class TypeLoc; 475 static bool isKind(const TypeLoc &TL); 476}; 477 478 479struct BuiltinLocInfo { 480 SourceLocation BuiltinLoc; 481}; 482 483/// \brief Wrapper for source info for builtin types. 484class BuiltinTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, 485 BuiltinTypeLoc, 486 BuiltinType, 487 BuiltinLocInfo> { 488public: 489 SourceLocation getBuiltinLoc() const { 490 return getLocalData()->BuiltinLoc; 491 } 492 void setBuiltinLoc(SourceLocation Loc) { 493 getLocalData()->BuiltinLoc = Loc; 494 } 495 496 SourceLocation getNameLoc() const { return getBuiltinLoc(); } 497 498 WrittenBuiltinSpecs& getWrittenBuiltinSpecs() { 499 return *(static_cast<WrittenBuiltinSpecs*>(getExtraLocalData())); 500 } 501 const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const { 502 return *(static_cast<WrittenBuiltinSpecs*>(getExtraLocalData())); 503 } 504 505 bool needsExtraLocalData() const { 506 BuiltinType::Kind bk = getTypePtr()->getKind(); 507 return (bk >= BuiltinType::UShort && bk <= BuiltinType::UInt128) 508 || (bk >= BuiltinType::Short && bk <= BuiltinType::LongDouble) 509 || bk == BuiltinType::UChar 510 || bk == BuiltinType::SChar; 511 } 512 513 unsigned getExtraLocalDataSize() const { 514 return needsExtraLocalData() ? sizeof(WrittenBuiltinSpecs) : 0; 515 } 516 517 unsigned getExtraLocalDataAlignment() const { 518 return needsExtraLocalData() ? llvm::alignOf<WrittenBuiltinSpecs>() : 1; 519 } 520 521 SourceRange getLocalSourceRange() const { 522 return SourceRange(getBuiltinLoc(), getBuiltinLoc()); 523 } 524 525 TypeSpecifierSign getWrittenSignSpec() const { 526 if (needsExtraLocalData()) 527 return static_cast<TypeSpecifierSign>(getWrittenBuiltinSpecs().Sign); 528 else 529 return TSS_unspecified; 530 } 531 bool hasWrittenSignSpec() const { 532 return getWrittenSignSpec() != TSS_unspecified; 533 } 534 void setWrittenSignSpec(TypeSpecifierSign written) { 535 if (needsExtraLocalData()) 536 getWrittenBuiltinSpecs().Sign = written; 537 } 538 539 TypeSpecifierWidth getWrittenWidthSpec() const { 540 if (needsExtraLocalData()) 541 return static_cast<TypeSpecifierWidth>(getWrittenBuiltinSpecs().Width); 542 else 543 return TSW_unspecified; 544 } 545 bool hasWrittenWidthSpec() const { 546 return getWrittenWidthSpec() != TSW_unspecified; 547 } 548 void setWrittenWidthSpec(TypeSpecifierWidth written) { 549 if (needsExtraLocalData()) 550 getWrittenBuiltinSpecs().Width = written; 551 } 552 553 TypeSpecifierType getWrittenTypeSpec() const; 554 bool hasWrittenTypeSpec() const { 555 return getWrittenTypeSpec() != TST_unspecified; 556 } 557 void setWrittenTypeSpec(TypeSpecifierType written) { 558 if (needsExtraLocalData()) 559 getWrittenBuiltinSpecs().Type = written; 560 } 561 562 bool hasModeAttr() const { 563 if (needsExtraLocalData()) 564 return getWrittenBuiltinSpecs().ModeAttr; 565 else 566 return false; 567 } 568 void setModeAttr(bool written) { 569 if (needsExtraLocalData()) 570 getWrittenBuiltinSpecs().ModeAttr = written; 571 } 572 573 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 574 setBuiltinLoc(Loc); 575 if (needsExtraLocalData()) { 576 WrittenBuiltinSpecs &wbs = getWrittenBuiltinSpecs(); 577 wbs.Sign = TSS_unspecified; 578 wbs.Width = TSW_unspecified; 579 wbs.Type = TST_unspecified; 580 wbs.ModeAttr = false; 581 } 582 } 583}; 584 585 586/// \brief Wrapper for source info for typedefs. 587class TypedefTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 588 TypedefTypeLoc, 589 TypedefType> { 590public: 591 TypedefNameDecl *getTypedefNameDecl() const { 592 return getTypePtr()->getDecl(); 593 } 594}; 595 596/// \brief Wrapper for source info for injected class names of class 597/// templates. 598class InjectedClassNameTypeLoc : 599 public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 600 InjectedClassNameTypeLoc, 601 InjectedClassNameType> { 602public: 603 CXXRecordDecl *getDecl() const { 604 return getTypePtr()->getDecl(); 605 } 606}; 607 608/// \brief Wrapper for source info for unresolved typename using decls. 609class UnresolvedUsingTypeLoc : 610 public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 611 UnresolvedUsingTypeLoc, 612 UnresolvedUsingType> { 613public: 614 UnresolvedUsingTypenameDecl *getDecl() const { 615 return getTypePtr()->getDecl(); 616 } 617}; 618 619/// \brief Wrapper for source info for tag types. Note that this only 620/// records source info for the name itself; a type written 'struct foo' 621/// should be represented as an ElaboratedTypeLoc. We currently 622/// only do that when C++ is enabled because of the expense of 623/// creating an ElaboratedType node for so many type references in C. 624class TagTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 625 TagTypeLoc, 626 TagType> { 627public: 628 TagDecl *getDecl() const { return getTypePtr()->getDecl(); } 629 630 /// \brief True if the tag was defined in this type specifier. 631 bool isDefinition() const { 632 TagDecl *D = getDecl(); 633 return D->isCompleteDefinition() && 634 (D->getIdentifier() == 0 || D->getLocation() == getNameLoc()); 635 } 636}; 637 638/// \brief Wrapper for source info for record types. 639class RecordTypeLoc : public InheritingConcreteTypeLoc<TagTypeLoc, 640 RecordTypeLoc, 641 RecordType> { 642public: 643 RecordDecl *getDecl() const { return getTypePtr()->getDecl(); } 644}; 645 646/// \brief Wrapper for source info for enum types. 647class EnumTypeLoc : public InheritingConcreteTypeLoc<TagTypeLoc, 648 EnumTypeLoc, 649 EnumType> { 650public: 651 EnumDecl *getDecl() const { return getTypePtr()->getDecl(); } 652}; 653 654/// \brief Wrapper for template type parameters. 655class TemplateTypeParmTypeLoc : 656 public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 657 TemplateTypeParmTypeLoc, 658 TemplateTypeParmType> { 659public: 660 TemplateTypeParmDecl *getDecl() const { return getTypePtr()->getDecl(); } 661}; 662 663/// \brief Wrapper for substituted template type parameters. 664class SubstTemplateTypeParmTypeLoc : 665 public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 666 SubstTemplateTypeParmTypeLoc, 667 SubstTemplateTypeParmType> { 668}; 669 670 /// \brief Wrapper for substituted template type parameters. 671class SubstTemplateTypeParmPackTypeLoc : 672 public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 673 SubstTemplateTypeParmPackTypeLoc, 674 SubstTemplateTypeParmPackType> { 675}; 676 677struct AttributedLocInfo { 678 union { 679 Expr *ExprOperand; 680 681 /// A raw SourceLocation. 682 unsigned EnumOperandLoc; 683 }; 684 685 SourceRange OperandParens; 686 687 SourceLocation AttrLoc; 688}; 689 690/// \brief Type source information for an attributed type. 691class AttributedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, 692 AttributedTypeLoc, 693 AttributedType, 694 AttributedLocInfo> { 695public: 696 AttributedType::Kind getAttrKind() const { 697 return getTypePtr()->getAttrKind(); 698 } 699 700 bool hasAttrExprOperand() const { 701 return (getAttrKind() >= AttributedType::FirstExprOperandKind && 702 getAttrKind() <= AttributedType::LastExprOperandKind); 703 } 704 705 bool hasAttrEnumOperand() const { 706 return (getAttrKind() >= AttributedType::FirstEnumOperandKind && 707 getAttrKind() <= AttributedType::LastEnumOperandKind); 708 } 709 710 bool hasAttrOperand() const { 711 return hasAttrExprOperand() || hasAttrEnumOperand(); 712 } 713 714 /// The modified type, which is generally canonically different from 715 /// the attribute type. 716 /// int main(int, char**) __attribute__((noreturn)) 717 /// ~~~ ~~~~~~~~~~~~~ 718 TypeLoc getModifiedLoc() const { 719 return getInnerTypeLoc(); 720 } 721 722 /// The location of the attribute name, i.e. 723 /// __attribute__((regparm(1000))) 724 /// ^~~~~~~ 725 SourceLocation getAttrNameLoc() const { 726 return getLocalData()->AttrLoc; 727 } 728 void setAttrNameLoc(SourceLocation loc) { 729 getLocalData()->AttrLoc = loc; 730 } 731 732 /// The attribute's expression operand, if it has one. 733 /// void *cur_thread __attribute__((address_space(21))) 734 /// ^~ 735 Expr *getAttrExprOperand() const { 736 assert(hasAttrExprOperand()); 737 return getLocalData()->ExprOperand; 738 } 739 void setAttrExprOperand(Expr *e) { 740 assert(hasAttrExprOperand()); 741 getLocalData()->ExprOperand = e; 742 } 743 744 /// The location of the attribute's enumerated operand, if it has one. 745 /// void * __attribute__((objc_gc(weak))) 746 /// ^~~~ 747 SourceLocation getAttrEnumOperandLoc() const { 748 assert(hasAttrEnumOperand()); 749 return SourceLocation::getFromRawEncoding(getLocalData()->EnumOperandLoc); 750 } 751 void setAttrEnumOperandLoc(SourceLocation loc) { 752 assert(hasAttrEnumOperand()); 753 getLocalData()->EnumOperandLoc = loc.getRawEncoding(); 754 } 755 756 /// The location of the parentheses around the operand, if there is 757 /// an operand. 758 /// void * __attribute__((objc_gc(weak))) 759 /// ^ ^ 760 SourceRange getAttrOperandParensRange() const { 761 assert(hasAttrOperand()); 762 return getLocalData()->OperandParens; 763 } 764 void setAttrOperandParensRange(SourceRange range) { 765 assert(hasAttrOperand()); 766 getLocalData()->OperandParens = range; 767 } 768 769 SourceRange getLocalSourceRange() const { 770 // Note that this does *not* include the range of the attribute 771 // enclosure, e.g.: 772 // __attribute__((foo(bar))) 773 // ^~~~~~~~~~~~~~~ ~~ 774 // or 775 // [[foo(bar)]] 776 // ^~ ~~ 777 // That enclosure doesn't necessarily belong to a single attribute 778 // anyway. 779 SourceRange range(getAttrNameLoc()); 780 if (hasAttrOperand()) 781 range.setEnd(getAttrOperandParensRange().getEnd()); 782 return range; 783 } 784 785 void initializeLocal(ASTContext &Context, SourceLocation loc) { 786 setAttrNameLoc(loc); 787 if (hasAttrExprOperand()) { 788 setAttrOperandParensRange(SourceRange(loc)); 789 setAttrExprOperand(0); 790 } else if (hasAttrEnumOperand()) { 791 setAttrOperandParensRange(SourceRange(loc)); 792 setAttrEnumOperandLoc(loc); 793 } 794 } 795 796 QualType getInnerType() const { 797 return getTypePtr()->getModifiedType(); 798 } 799}; 800 801 802struct ObjCProtocolListLocInfo { 803 SourceLocation LAngleLoc; 804 SourceLocation RAngleLoc; 805 bool HasBaseTypeAsWritten; 806}; 807 808// A helper class for defining ObjC TypeLocs that can qualified with 809// protocols. 810// 811// TypeClass basically has to be either ObjCInterfaceType or 812// ObjCObjectPointerType. 813class ObjCObjectTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, 814 ObjCObjectTypeLoc, 815 ObjCObjectType, 816 ObjCProtocolListLocInfo> { 817 // SourceLocations are stored after Info, one for each Protocol. 818 SourceLocation *getProtocolLocArray() const { 819 return (SourceLocation*) this->getExtraLocalData(); 820 } 821 822public: 823 SourceLocation getLAngleLoc() const { 824 return this->getLocalData()->LAngleLoc; 825 } 826 void setLAngleLoc(SourceLocation Loc) { 827 this->getLocalData()->LAngleLoc = Loc; 828 } 829 830 SourceLocation getRAngleLoc() const { 831 return this->getLocalData()->RAngleLoc; 832 } 833 void setRAngleLoc(SourceLocation Loc) { 834 this->getLocalData()->RAngleLoc = Loc; 835 } 836 837 unsigned getNumProtocols() const { 838 return this->getTypePtr()->getNumProtocols(); 839 } 840 841 SourceLocation getProtocolLoc(unsigned i) const { 842 assert(i < getNumProtocols() && "Index is out of bounds!"); 843 return getProtocolLocArray()[i]; 844 } 845 void setProtocolLoc(unsigned i, SourceLocation Loc) { 846 assert(i < getNumProtocols() && "Index is out of bounds!"); 847 getProtocolLocArray()[i] = Loc; 848 } 849 850 ObjCProtocolDecl *getProtocol(unsigned i) const { 851 assert(i < getNumProtocols() && "Index is out of bounds!"); 852 return *(this->getTypePtr()->qual_begin() + i); 853 } 854 855 bool hasBaseTypeAsWritten() const { 856 return getLocalData()->HasBaseTypeAsWritten; 857 } 858 859 void setHasBaseTypeAsWritten(bool HasBaseType) { 860 getLocalData()->HasBaseTypeAsWritten = HasBaseType; 861 } 862 863 TypeLoc getBaseLoc() const { 864 return getInnerTypeLoc(); 865 } 866 867 SourceRange getLocalSourceRange() const { 868 return SourceRange(getLAngleLoc(), getRAngleLoc()); 869 } 870 871 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 872 setHasBaseTypeAsWritten(true); 873 setLAngleLoc(Loc); 874 setRAngleLoc(Loc); 875 for (unsigned i = 0, e = getNumProtocols(); i != e; ++i) 876 setProtocolLoc(i, Loc); 877 } 878 879 unsigned getExtraLocalDataSize() const { 880 return this->getNumProtocols() * sizeof(SourceLocation); 881 } 882 883 unsigned getExtraLocalDataAlignment() const { 884 return llvm::alignOf<SourceLocation>(); 885 } 886 887 QualType getInnerType() const { 888 return getTypePtr()->getBaseType(); 889 } 890}; 891 892 893struct ObjCInterfaceLocInfo { 894 SourceLocation NameLoc; 895 SourceLocation NameEndLoc; 896}; 897 898/// \brief Wrapper for source info for ObjC interfaces. 899class ObjCInterfaceTypeLoc : public ConcreteTypeLoc<ObjCObjectTypeLoc, 900 ObjCInterfaceTypeLoc, 901 ObjCInterfaceType, 902 ObjCInterfaceLocInfo> { 903public: 904 ObjCInterfaceDecl *getIFaceDecl() const { 905 return getTypePtr()->getDecl(); 906 } 907 908 SourceLocation getNameLoc() const { 909 return getLocalData()->NameLoc; 910 } 911 912 void setNameLoc(SourceLocation Loc) { 913 getLocalData()->NameLoc = Loc; 914 } 915 916 SourceRange getLocalSourceRange() const { 917 return SourceRange(getNameLoc(), getNameEndLoc()); 918 } 919 920 SourceLocation getNameEndLoc() const { 921 return getLocalData()->NameEndLoc; 922 } 923 924 void setNameEndLoc(SourceLocation Loc) { 925 getLocalData()->NameEndLoc = Loc; 926 } 927 928 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 929 setNameLoc(Loc); 930 setNameEndLoc(Loc); 931 } 932}; 933 934struct ParenLocInfo { 935 SourceLocation LParenLoc; 936 SourceLocation RParenLoc; 937}; 938 939class ParenTypeLoc 940 : public ConcreteTypeLoc<UnqualTypeLoc, ParenTypeLoc, ParenType, 941 ParenLocInfo> { 942public: 943 SourceLocation getLParenLoc() const { 944 return this->getLocalData()->LParenLoc; 945 } 946 SourceLocation getRParenLoc() const { 947 return this->getLocalData()->RParenLoc; 948 } 949 void setLParenLoc(SourceLocation Loc) { 950 this->getLocalData()->LParenLoc = Loc; 951 } 952 void setRParenLoc(SourceLocation Loc) { 953 this->getLocalData()->RParenLoc = Loc; 954 } 955 956 SourceRange getLocalSourceRange() const { 957 return SourceRange(getLParenLoc(), getRParenLoc()); 958 } 959 960 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 961 setLParenLoc(Loc); 962 setRParenLoc(Loc); 963 } 964 965 TypeLoc getInnerLoc() const { 966 return getInnerTypeLoc(); 967 } 968 969 QualType getInnerType() const { 970 return this->getTypePtr()->getInnerType(); 971 } 972}; 973 974inline TypeLoc TypeLoc::IgnoreParens() const { 975 if (ParenTypeLoc::isKind(*this)) 976 return IgnoreParensImpl(*this); 977 return *this; 978} 979 980 981struct DecayedLocInfo { }; // Nothing. 982 983/// \brief Wrapper for source info for pointers decayed from arrays and 984/// functions. 985class DecayedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, DecayedTypeLoc, 986 DecayedType, DecayedLocInfo> { 987public: 988 TypeLoc getOriginalLoc() const { 989 return getInnerTypeLoc(); 990 } 991 992 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 993 // do nothing 994 } 995 996 QualType getInnerType() const { 997 // The inner type is the undecayed type, since that's what we have source 998 // location information for. 999 return getTypePtr()->getOriginalType(); 1000 } 1001 1002 SourceRange getLocalSourceRange() const { 1003 return SourceRange(); 1004 } 1005 1006 unsigned getLocalDataSize() const { 1007 // sizeof(DecayedLocInfo) is 1, but we don't need its address to be unique 1008 // anyway. TypeLocBuilder can't handle data sizes of 1. 1009 return 0; // No data. 1010 } 1011}; 1012 1013 1014struct PointerLikeLocInfo { 1015 SourceLocation StarLoc; 1016}; 1017 1018/// A base class for 1019template <class Derived, class TypeClass, class LocalData = PointerLikeLocInfo> 1020class PointerLikeTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, Derived, 1021 TypeClass, LocalData> { 1022public: 1023 SourceLocation getSigilLoc() const { 1024 return this->getLocalData()->StarLoc; 1025 } 1026 void setSigilLoc(SourceLocation Loc) { 1027 this->getLocalData()->StarLoc = Loc; 1028 } 1029 1030 TypeLoc getPointeeLoc() const { 1031 return this->getInnerTypeLoc(); 1032 } 1033 1034 SourceRange getLocalSourceRange() const { 1035 return SourceRange(getSigilLoc(), getSigilLoc()); 1036 } 1037 1038 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 1039 setSigilLoc(Loc); 1040 } 1041 1042 QualType getInnerType() const { 1043 return this->getTypePtr()->getPointeeType(); 1044 } 1045}; 1046 1047 1048/// \brief Wrapper for source info for pointers. 1049class PointerTypeLoc : public PointerLikeTypeLoc<PointerTypeLoc, 1050 PointerType> { 1051public: 1052 SourceLocation getStarLoc() const { 1053 return getSigilLoc(); 1054 } 1055 void setStarLoc(SourceLocation Loc) { 1056 setSigilLoc(Loc); 1057 } 1058}; 1059 1060 1061/// \brief Wrapper for source info for block pointers. 1062class BlockPointerTypeLoc : public PointerLikeTypeLoc<BlockPointerTypeLoc, 1063 BlockPointerType> { 1064public: 1065 SourceLocation getCaretLoc() const { 1066 return getSigilLoc(); 1067 } 1068 void setCaretLoc(SourceLocation Loc) { 1069 setSigilLoc(Loc); 1070 } 1071}; 1072 1073struct MemberPointerLocInfo : public PointerLikeLocInfo { 1074 TypeSourceInfo *ClassTInfo; 1075}; 1076 1077/// \brief Wrapper for source info for member pointers. 1078class MemberPointerTypeLoc : public PointerLikeTypeLoc<MemberPointerTypeLoc, 1079 MemberPointerType, 1080 MemberPointerLocInfo> { 1081public: 1082 SourceLocation getStarLoc() const { 1083 return getSigilLoc(); 1084 } 1085 void setStarLoc(SourceLocation Loc) { 1086 setSigilLoc(Loc); 1087 } 1088 1089 const Type *getClass() const { 1090 return getTypePtr()->getClass(); 1091 } 1092 TypeSourceInfo *getClassTInfo() const { 1093 return getLocalData()->ClassTInfo; 1094 } 1095 void setClassTInfo(TypeSourceInfo* TI) { 1096 getLocalData()->ClassTInfo = TI; 1097 } 1098 1099 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 1100 setSigilLoc(Loc); 1101 setClassTInfo(0); 1102 } 1103 1104 SourceRange getLocalSourceRange() const { 1105 if (TypeSourceInfo *TI = getClassTInfo()) 1106 return SourceRange(TI->getTypeLoc().getBeginLoc(), getStarLoc()); 1107 else 1108 return SourceRange(getStarLoc()); 1109 } 1110}; 1111 1112/// Wraps an ObjCPointerType with source location information. 1113class ObjCObjectPointerTypeLoc : 1114 public PointerLikeTypeLoc<ObjCObjectPointerTypeLoc, 1115 ObjCObjectPointerType> { 1116public: 1117 SourceLocation getStarLoc() const { 1118 return getSigilLoc(); 1119 } 1120 1121 void setStarLoc(SourceLocation Loc) { 1122 setSigilLoc(Loc); 1123 } 1124}; 1125 1126 1127class ReferenceTypeLoc : public PointerLikeTypeLoc<ReferenceTypeLoc, 1128 ReferenceType> { 1129public: 1130 QualType getInnerType() const { 1131 return getTypePtr()->getPointeeTypeAsWritten(); 1132 } 1133}; 1134 1135class LValueReferenceTypeLoc : 1136 public InheritingConcreteTypeLoc<ReferenceTypeLoc, 1137 LValueReferenceTypeLoc, 1138 LValueReferenceType> { 1139public: 1140 SourceLocation getAmpLoc() const { 1141 return getSigilLoc(); 1142 } 1143 void setAmpLoc(SourceLocation Loc) { 1144 setSigilLoc(Loc); 1145 } 1146}; 1147 1148class RValueReferenceTypeLoc : 1149 public InheritingConcreteTypeLoc<ReferenceTypeLoc, 1150 RValueReferenceTypeLoc, 1151 RValueReferenceType> { 1152public: 1153 SourceLocation getAmpAmpLoc() const { 1154 return getSigilLoc(); 1155 } 1156 void setAmpAmpLoc(SourceLocation Loc) { 1157 setSigilLoc(Loc); 1158 } 1159}; 1160 1161 1162struct FunctionLocInfo { 1163 SourceLocation LocalRangeBegin; 1164 SourceLocation LParenLoc; 1165 SourceLocation RParenLoc; 1166 SourceLocation LocalRangeEnd; 1167}; 1168 1169/// \brief Wrapper for source info for functions. 1170class FunctionTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, 1171 FunctionTypeLoc, 1172 FunctionType, 1173 FunctionLocInfo> { 1174public: 1175 SourceLocation getLocalRangeBegin() const { 1176 return getLocalData()->LocalRangeBegin; 1177 } 1178 void setLocalRangeBegin(SourceLocation L) { 1179 getLocalData()->LocalRangeBegin = L; 1180 } 1181 1182 SourceLocation getLocalRangeEnd() const { 1183 return getLocalData()->LocalRangeEnd; 1184 } 1185 void setLocalRangeEnd(SourceLocation L) { 1186 getLocalData()->LocalRangeEnd = L; 1187 } 1188 1189 SourceLocation getLParenLoc() const { 1190 return this->getLocalData()->LParenLoc; 1191 } 1192 void setLParenLoc(SourceLocation Loc) { 1193 this->getLocalData()->LParenLoc = Loc; 1194 } 1195 1196 SourceLocation getRParenLoc() const { 1197 return this->getLocalData()->RParenLoc; 1198 } 1199 void setRParenLoc(SourceLocation Loc) { 1200 this->getLocalData()->RParenLoc = Loc; 1201 } 1202 1203 SourceRange getParensRange() const { 1204 return SourceRange(getLParenLoc(), getRParenLoc()); 1205 } 1206 1207 ArrayRef<ParmVarDecl *> getParams() const { 1208 return ArrayRef<ParmVarDecl *>(getParmArray(), getNumArgs()); 1209 } 1210 1211 // ParmVarDecls* are stored after Info, one for each argument. 1212 ParmVarDecl **getParmArray() const { 1213 return (ParmVarDecl**) getExtraLocalData(); 1214 } 1215 1216 unsigned getNumArgs() const { 1217 if (isa<FunctionNoProtoType>(getTypePtr())) 1218 return 0; 1219 return cast<FunctionProtoType>(getTypePtr())->getNumArgs(); 1220 } 1221 ParmVarDecl *getArg(unsigned i) const { return getParmArray()[i]; } 1222 void setArg(unsigned i, ParmVarDecl *VD) { getParmArray()[i] = VD; } 1223 1224 TypeLoc getResultLoc() const { 1225 return getInnerTypeLoc(); 1226 } 1227 1228 SourceRange getLocalSourceRange() const { 1229 return SourceRange(getLocalRangeBegin(), getLocalRangeEnd()); 1230 } 1231 1232 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 1233 setLocalRangeBegin(Loc); 1234 setLParenLoc(Loc); 1235 setRParenLoc(Loc); 1236 setLocalRangeEnd(Loc); 1237 for (unsigned i = 0, e = getNumArgs(); i != e; ++i) 1238 setArg(i, NULL); 1239 } 1240 1241 /// \brief Returns the size of the type source info data block that is 1242 /// specific to this type. 1243 unsigned getExtraLocalDataSize() const { 1244 return getNumArgs() * sizeof(ParmVarDecl*); 1245 } 1246 1247 unsigned getExtraLocalDataAlignment() const { 1248 return llvm::alignOf<ParmVarDecl*>(); 1249 } 1250 1251 QualType getInnerType() const { return getTypePtr()->getResultType(); } 1252}; 1253 1254class FunctionProtoTypeLoc : 1255 public InheritingConcreteTypeLoc<FunctionTypeLoc, 1256 FunctionProtoTypeLoc, 1257 FunctionProtoType> { 1258}; 1259 1260class FunctionNoProtoTypeLoc : 1261 public InheritingConcreteTypeLoc<FunctionTypeLoc, 1262 FunctionNoProtoTypeLoc, 1263 FunctionNoProtoType> { 1264}; 1265 1266 1267struct ArrayLocInfo { 1268 SourceLocation LBracketLoc, RBracketLoc; 1269 Expr *Size; 1270}; 1271 1272/// \brief Wrapper for source info for arrays. 1273class ArrayTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, 1274 ArrayTypeLoc, 1275 ArrayType, 1276 ArrayLocInfo> { 1277public: 1278 SourceLocation getLBracketLoc() const { 1279 return getLocalData()->LBracketLoc; 1280 } 1281 void setLBracketLoc(SourceLocation Loc) { 1282 getLocalData()->LBracketLoc = Loc; 1283 } 1284 1285 SourceLocation getRBracketLoc() const { 1286 return getLocalData()->RBracketLoc; 1287 } 1288 void setRBracketLoc(SourceLocation Loc) { 1289 getLocalData()->RBracketLoc = Loc; 1290 } 1291 1292 SourceRange getBracketsRange() const { 1293 return SourceRange(getLBracketLoc(), getRBracketLoc()); 1294 } 1295 1296 Expr *getSizeExpr() const { 1297 return getLocalData()->Size; 1298 } 1299 void setSizeExpr(Expr *Size) { 1300 getLocalData()->Size = Size; 1301 } 1302 1303 TypeLoc getElementLoc() const { 1304 return getInnerTypeLoc(); 1305 } 1306 1307 SourceRange getLocalSourceRange() const { 1308 return SourceRange(getLBracketLoc(), getRBracketLoc()); 1309 } 1310 1311 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 1312 setLBracketLoc(Loc); 1313 setRBracketLoc(Loc); 1314 setSizeExpr(NULL); 1315 } 1316 1317 QualType getInnerType() const { return getTypePtr()->getElementType(); } 1318}; 1319 1320class ConstantArrayTypeLoc : 1321 public InheritingConcreteTypeLoc<ArrayTypeLoc, 1322 ConstantArrayTypeLoc, 1323 ConstantArrayType> { 1324}; 1325 1326class IncompleteArrayTypeLoc : 1327 public InheritingConcreteTypeLoc<ArrayTypeLoc, 1328 IncompleteArrayTypeLoc, 1329 IncompleteArrayType> { 1330}; 1331 1332class DependentSizedArrayTypeLoc : 1333 public InheritingConcreteTypeLoc<ArrayTypeLoc, 1334 DependentSizedArrayTypeLoc, 1335 DependentSizedArrayType> { 1336 1337}; 1338 1339class VariableArrayTypeLoc : 1340 public InheritingConcreteTypeLoc<ArrayTypeLoc, 1341 VariableArrayTypeLoc, 1342 VariableArrayType> { 1343}; 1344 1345 1346// Location information for a TemplateName. Rudimentary for now. 1347struct TemplateNameLocInfo { 1348 SourceLocation NameLoc; 1349}; 1350 1351struct TemplateSpecializationLocInfo : TemplateNameLocInfo { 1352 SourceLocation TemplateKWLoc; 1353 SourceLocation LAngleLoc; 1354 SourceLocation RAngleLoc; 1355}; 1356 1357class TemplateSpecializationTypeLoc : 1358 public ConcreteTypeLoc<UnqualTypeLoc, 1359 TemplateSpecializationTypeLoc, 1360 TemplateSpecializationType, 1361 TemplateSpecializationLocInfo> { 1362public: 1363 SourceLocation getTemplateKeywordLoc() const { 1364 return getLocalData()->TemplateKWLoc; 1365 } 1366 void setTemplateKeywordLoc(SourceLocation Loc) { 1367 getLocalData()->TemplateKWLoc = Loc; 1368 } 1369 1370 SourceLocation getLAngleLoc() const { 1371 return getLocalData()->LAngleLoc; 1372 } 1373 void setLAngleLoc(SourceLocation Loc) { 1374 getLocalData()->LAngleLoc = Loc; 1375 } 1376 1377 SourceLocation getRAngleLoc() const { 1378 return getLocalData()->RAngleLoc; 1379 } 1380 void setRAngleLoc(SourceLocation Loc) { 1381 getLocalData()->RAngleLoc = Loc; 1382 } 1383 1384 unsigned getNumArgs() const { 1385 return getTypePtr()->getNumArgs(); 1386 } 1387 void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI) { 1388 getArgInfos()[i] = AI; 1389 } 1390 TemplateArgumentLocInfo getArgLocInfo(unsigned i) const { 1391 return getArgInfos()[i]; 1392 } 1393 1394 TemplateArgumentLoc getArgLoc(unsigned i) const { 1395 return TemplateArgumentLoc(getTypePtr()->getArg(i), getArgLocInfo(i)); 1396 } 1397 1398 SourceLocation getTemplateNameLoc() const { 1399 return getLocalData()->NameLoc; 1400 } 1401 void setTemplateNameLoc(SourceLocation Loc) { 1402 getLocalData()->NameLoc = Loc; 1403 } 1404 1405 /// \brief - Copy the location information from the given info. 1406 void copy(TemplateSpecializationTypeLoc Loc) { 1407 unsigned size = getFullDataSize(); 1408 assert(size == Loc.getFullDataSize()); 1409 1410 // We're potentially copying Expr references here. We don't 1411 // bother retaining them because TypeSourceInfos live forever, so 1412 // as long as the Expr was retained when originally written into 1413 // the TypeLoc, we're okay. 1414 memcpy(Data, Loc.Data, size); 1415 } 1416 1417 SourceRange getLocalSourceRange() const { 1418 if (getTemplateKeywordLoc().isValid()) 1419 return SourceRange(getTemplateKeywordLoc(), getRAngleLoc()); 1420 else 1421 return SourceRange(getTemplateNameLoc(), getRAngleLoc()); 1422 } 1423 1424 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 1425 setTemplateKeywordLoc(Loc); 1426 setTemplateNameLoc(Loc); 1427 setLAngleLoc(Loc); 1428 setRAngleLoc(Loc); 1429 initializeArgLocs(Context, getNumArgs(), getTypePtr()->getArgs(), 1430 getArgInfos(), Loc); 1431 } 1432 1433 static void initializeArgLocs(ASTContext &Context, unsigned NumArgs, 1434 const TemplateArgument *Args, 1435 TemplateArgumentLocInfo *ArgInfos, 1436 SourceLocation Loc); 1437 1438 unsigned getExtraLocalDataSize() const { 1439 return getNumArgs() * sizeof(TemplateArgumentLocInfo); 1440 } 1441 1442 unsigned getExtraLocalDataAlignment() const { 1443 return llvm::alignOf<TemplateArgumentLocInfo>(); 1444 } 1445 1446private: 1447 TemplateArgumentLocInfo *getArgInfos() const { 1448 return static_cast<TemplateArgumentLocInfo*>(getExtraLocalData()); 1449 } 1450}; 1451 1452//===----------------------------------------------------------------------===// 1453// 1454// All of these need proper implementations. 1455// 1456//===----------------------------------------------------------------------===// 1457 1458// FIXME: size expression and attribute locations (or keyword if we 1459// ever fully support altivec syntax). 1460class VectorTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 1461 VectorTypeLoc, 1462 VectorType> { 1463}; 1464 1465// FIXME: size expression and attribute locations. 1466class ExtVectorTypeLoc : public InheritingConcreteTypeLoc<VectorTypeLoc, 1467 ExtVectorTypeLoc, 1468 ExtVectorType> { 1469}; 1470 1471// FIXME: attribute locations. 1472// For some reason, this isn't a subtype of VectorType. 1473class DependentSizedExtVectorTypeLoc : 1474 public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 1475 DependentSizedExtVectorTypeLoc, 1476 DependentSizedExtVectorType> { 1477}; 1478 1479// FIXME: location of the '_Complex' keyword. 1480class ComplexTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 1481 ComplexTypeLoc, 1482 ComplexType> { 1483}; 1484 1485struct TypeofLocInfo { 1486 SourceLocation TypeofLoc; 1487 SourceLocation LParenLoc; 1488 SourceLocation RParenLoc; 1489}; 1490 1491struct TypeOfExprTypeLocInfo : public TypeofLocInfo { 1492}; 1493 1494struct TypeOfTypeLocInfo : public TypeofLocInfo { 1495 TypeSourceInfo* UnderlyingTInfo; 1496}; 1497 1498template <class Derived, class TypeClass, class LocalData = TypeofLocInfo> 1499class TypeofLikeTypeLoc 1500 : public ConcreteTypeLoc<UnqualTypeLoc, Derived, TypeClass, LocalData> { 1501public: 1502 SourceLocation getTypeofLoc() const { 1503 return this->getLocalData()->TypeofLoc; 1504 } 1505 void setTypeofLoc(SourceLocation Loc) { 1506 this->getLocalData()->TypeofLoc = Loc; 1507 } 1508 1509 SourceLocation getLParenLoc() const { 1510 return this->getLocalData()->LParenLoc; 1511 } 1512 void setLParenLoc(SourceLocation Loc) { 1513 this->getLocalData()->LParenLoc = Loc; 1514 } 1515 1516 SourceLocation getRParenLoc() const { 1517 return this->getLocalData()->RParenLoc; 1518 } 1519 void setRParenLoc(SourceLocation Loc) { 1520 this->getLocalData()->RParenLoc = Loc; 1521 } 1522 1523 SourceRange getParensRange() const { 1524 return SourceRange(getLParenLoc(), getRParenLoc()); 1525 } 1526 void setParensRange(SourceRange range) { 1527 setLParenLoc(range.getBegin()); 1528 setRParenLoc(range.getEnd()); 1529 } 1530 1531 SourceRange getLocalSourceRange() const { 1532 return SourceRange(getTypeofLoc(), getRParenLoc()); 1533 } 1534 1535 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 1536 setTypeofLoc(Loc); 1537 setLParenLoc(Loc); 1538 setRParenLoc(Loc); 1539 } 1540}; 1541 1542class TypeOfExprTypeLoc : public TypeofLikeTypeLoc<TypeOfExprTypeLoc, 1543 TypeOfExprType, 1544 TypeOfExprTypeLocInfo> { 1545public: 1546 Expr* getUnderlyingExpr() const { 1547 return getTypePtr()->getUnderlyingExpr(); 1548 } 1549 // Reimplemented to account for GNU/C++ extension 1550 // typeof unary-expression 1551 // where there are no parentheses. 1552 SourceRange getLocalSourceRange() const; 1553}; 1554 1555class TypeOfTypeLoc 1556 : public TypeofLikeTypeLoc<TypeOfTypeLoc, TypeOfType, TypeOfTypeLocInfo> { 1557public: 1558 QualType getUnderlyingType() const { 1559 return this->getTypePtr()->getUnderlyingType(); 1560 } 1561 TypeSourceInfo* getUnderlyingTInfo() const { 1562 return this->getLocalData()->UnderlyingTInfo; 1563 } 1564 void setUnderlyingTInfo(TypeSourceInfo* TI) const { 1565 this->getLocalData()->UnderlyingTInfo = TI; 1566 } 1567}; 1568 1569// FIXME: location of the 'decltype' and parens. 1570class DecltypeTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 1571 DecltypeTypeLoc, 1572 DecltypeType> { 1573public: 1574 Expr *getUnderlyingExpr() const { return getTypePtr()->getUnderlyingExpr(); } 1575}; 1576 1577struct UnaryTransformTypeLocInfo { 1578 // FIXME: While there's only one unary transform right now, future ones may 1579 // need different representations 1580 SourceLocation KWLoc, LParenLoc, RParenLoc; 1581 TypeSourceInfo *UnderlyingTInfo; 1582}; 1583 1584class UnaryTransformTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, 1585 UnaryTransformTypeLoc, 1586 UnaryTransformType, 1587 UnaryTransformTypeLocInfo> { 1588public: 1589 SourceLocation getKWLoc() const { return getLocalData()->KWLoc; } 1590 void setKWLoc(SourceLocation Loc) { getLocalData()->KWLoc = Loc; } 1591 1592 SourceLocation getLParenLoc() const { return getLocalData()->LParenLoc; } 1593 void setLParenLoc(SourceLocation Loc) { getLocalData()->LParenLoc = Loc; } 1594 1595 SourceLocation getRParenLoc() const { return getLocalData()->RParenLoc; } 1596 void setRParenLoc(SourceLocation Loc) { getLocalData()->RParenLoc = Loc; } 1597 1598 TypeSourceInfo* getUnderlyingTInfo() const { 1599 return getLocalData()->UnderlyingTInfo; 1600 } 1601 void setUnderlyingTInfo(TypeSourceInfo *TInfo) { 1602 getLocalData()->UnderlyingTInfo = TInfo; 1603 } 1604 1605 SourceRange getLocalSourceRange() const { 1606 return SourceRange(getKWLoc(), getRParenLoc()); 1607 } 1608 1609 SourceRange getParensRange() const { 1610 return SourceRange(getLParenLoc(), getRParenLoc()); 1611 } 1612 void setParensRange(SourceRange Range) { 1613 setLParenLoc(Range.getBegin()); 1614 setRParenLoc(Range.getEnd()); 1615 } 1616 1617 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 1618 setKWLoc(Loc); 1619 setRParenLoc(Loc); 1620 setLParenLoc(Loc); 1621 } 1622}; 1623 1624class AutoTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, 1625 AutoTypeLoc, 1626 AutoType> { 1627}; 1628 1629struct ElaboratedLocInfo { 1630 SourceLocation ElaboratedKWLoc; 1631 /// \brief Data associated with the nested-name-specifier location. 1632 void *QualifierData; 1633}; 1634 1635class ElaboratedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, 1636 ElaboratedTypeLoc, 1637 ElaboratedType, 1638 ElaboratedLocInfo> { 1639public: 1640 SourceLocation getElaboratedKeywordLoc() const { 1641 return this->getLocalData()->ElaboratedKWLoc; 1642 } 1643 void setElaboratedKeywordLoc(SourceLocation Loc) { 1644 this->getLocalData()->ElaboratedKWLoc = Loc; 1645 } 1646 1647 NestedNameSpecifierLoc getQualifierLoc() const { 1648 return NestedNameSpecifierLoc(getTypePtr()->getQualifier(), 1649 getLocalData()->QualifierData); 1650 } 1651 1652 void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc) { 1653 assert(QualifierLoc.getNestedNameSpecifier() 1654 == getTypePtr()->getQualifier() && 1655 "Inconsistent nested-name-specifier pointer"); 1656 getLocalData()->QualifierData = QualifierLoc.getOpaqueData(); 1657 } 1658 1659 SourceRange getLocalSourceRange() const { 1660 if (getElaboratedKeywordLoc().isValid()) 1661 if (getQualifierLoc()) 1662 return SourceRange(getElaboratedKeywordLoc(), 1663 getQualifierLoc().getEndLoc()); 1664 else 1665 return SourceRange(getElaboratedKeywordLoc()); 1666 else 1667 return getQualifierLoc().getSourceRange(); 1668 } 1669 1670 void initializeLocal(ASTContext &Context, SourceLocation Loc); 1671 1672 TypeLoc getNamedTypeLoc() const { 1673 return getInnerTypeLoc(); 1674 } 1675 1676 QualType getInnerType() const { 1677 return getTypePtr()->getNamedType(); 1678 } 1679 1680 void copy(ElaboratedTypeLoc Loc) { 1681 unsigned size = getFullDataSize(); 1682 assert(size == Loc.getFullDataSize()); 1683 memcpy(Data, Loc.Data, size); 1684 } 1685}; 1686 1687// This is exactly the structure of an ElaboratedTypeLoc whose inner 1688// type is some sort of TypeDeclTypeLoc. 1689struct DependentNameLocInfo : ElaboratedLocInfo { 1690 SourceLocation NameLoc; 1691}; 1692 1693class DependentNameTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, 1694 DependentNameTypeLoc, 1695 DependentNameType, 1696 DependentNameLocInfo> { 1697public: 1698 SourceLocation getElaboratedKeywordLoc() const { 1699 return this->getLocalData()->ElaboratedKWLoc; 1700 } 1701 void setElaboratedKeywordLoc(SourceLocation Loc) { 1702 this->getLocalData()->ElaboratedKWLoc = Loc; 1703 } 1704 1705 NestedNameSpecifierLoc getQualifierLoc() const { 1706 return NestedNameSpecifierLoc(getTypePtr()->getQualifier(), 1707 getLocalData()->QualifierData); 1708 } 1709 1710 void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc) { 1711 assert(QualifierLoc.getNestedNameSpecifier() 1712 == getTypePtr()->getQualifier() && 1713 "Inconsistent nested-name-specifier pointer"); 1714 getLocalData()->QualifierData = QualifierLoc.getOpaqueData(); 1715 } 1716 1717 SourceLocation getNameLoc() const { 1718 return this->getLocalData()->NameLoc; 1719 } 1720 void setNameLoc(SourceLocation Loc) { 1721 this->getLocalData()->NameLoc = Loc; 1722 } 1723 1724 SourceRange getLocalSourceRange() const { 1725 if (getElaboratedKeywordLoc().isValid()) 1726 return SourceRange(getElaboratedKeywordLoc(), getNameLoc()); 1727 else 1728 return SourceRange(getQualifierLoc().getBeginLoc(), getNameLoc()); 1729 } 1730 1731 void copy(DependentNameTypeLoc Loc) { 1732 unsigned size = getFullDataSize(); 1733 assert(size == Loc.getFullDataSize()); 1734 memcpy(Data, Loc.Data, size); 1735 } 1736 1737 void initializeLocal(ASTContext &Context, SourceLocation Loc); 1738}; 1739 1740struct DependentTemplateSpecializationLocInfo : DependentNameLocInfo { 1741 SourceLocation TemplateKWLoc; 1742 SourceLocation LAngleLoc; 1743 SourceLocation RAngleLoc; 1744 // followed by a TemplateArgumentLocInfo[] 1745}; 1746 1747class DependentTemplateSpecializationTypeLoc : 1748 public ConcreteTypeLoc<UnqualTypeLoc, 1749 DependentTemplateSpecializationTypeLoc, 1750 DependentTemplateSpecializationType, 1751 DependentTemplateSpecializationLocInfo> { 1752public: 1753 SourceLocation getElaboratedKeywordLoc() const { 1754 return this->getLocalData()->ElaboratedKWLoc; 1755 } 1756 void setElaboratedKeywordLoc(SourceLocation Loc) { 1757 this->getLocalData()->ElaboratedKWLoc = Loc; 1758 } 1759 1760 NestedNameSpecifierLoc getQualifierLoc() const { 1761 if (!getLocalData()->QualifierData) 1762 return NestedNameSpecifierLoc(); 1763 1764 return NestedNameSpecifierLoc(getTypePtr()->getQualifier(), 1765 getLocalData()->QualifierData); 1766 } 1767 1768 void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc) { 1769 if (!QualifierLoc) { 1770 // Even if we have a nested-name-specifier in the dependent 1771 // template specialization type, we won't record the nested-name-specifier 1772 // location information when this type-source location information is 1773 // part of a nested-name-specifier. 1774 getLocalData()->QualifierData = 0; 1775 return; 1776 } 1777 1778 assert(QualifierLoc.getNestedNameSpecifier() 1779 == getTypePtr()->getQualifier() && 1780 "Inconsistent nested-name-specifier pointer"); 1781 getLocalData()->QualifierData = QualifierLoc.getOpaqueData(); 1782 } 1783 1784 SourceLocation getTemplateKeywordLoc() const { 1785 return getLocalData()->TemplateKWLoc; 1786 } 1787 void setTemplateKeywordLoc(SourceLocation Loc) { 1788 getLocalData()->TemplateKWLoc = Loc; 1789 } 1790 1791 SourceLocation getTemplateNameLoc() const { 1792 return this->getLocalData()->NameLoc; 1793 } 1794 void setTemplateNameLoc(SourceLocation Loc) { 1795 this->getLocalData()->NameLoc = Loc; 1796 } 1797 1798 SourceLocation getLAngleLoc() const { 1799 return this->getLocalData()->LAngleLoc; 1800 } 1801 void setLAngleLoc(SourceLocation Loc) { 1802 this->getLocalData()->LAngleLoc = Loc; 1803 } 1804 1805 SourceLocation getRAngleLoc() const { 1806 return this->getLocalData()->RAngleLoc; 1807 } 1808 void setRAngleLoc(SourceLocation Loc) { 1809 this->getLocalData()->RAngleLoc = Loc; 1810 } 1811 1812 unsigned getNumArgs() const { 1813 return getTypePtr()->getNumArgs(); 1814 } 1815 1816 void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI) { 1817 getArgInfos()[i] = AI; 1818 } 1819 TemplateArgumentLocInfo getArgLocInfo(unsigned i) const { 1820 return getArgInfos()[i]; 1821 } 1822 1823 TemplateArgumentLoc getArgLoc(unsigned i) const { 1824 return TemplateArgumentLoc(getTypePtr()->getArg(i), getArgLocInfo(i)); 1825 } 1826 1827 SourceRange getLocalSourceRange() const { 1828 if (getElaboratedKeywordLoc().isValid()) 1829 return SourceRange(getElaboratedKeywordLoc(), getRAngleLoc()); 1830 else if (getQualifierLoc()) 1831 return SourceRange(getQualifierLoc().getBeginLoc(), getRAngleLoc()); 1832 else if (getTemplateKeywordLoc().isValid()) 1833 return SourceRange(getTemplateKeywordLoc(), getRAngleLoc()); 1834 else 1835 return SourceRange(getTemplateNameLoc(), getRAngleLoc()); 1836 } 1837 1838 void copy(DependentTemplateSpecializationTypeLoc Loc) { 1839 unsigned size = getFullDataSize(); 1840 assert(size == Loc.getFullDataSize()); 1841 memcpy(Data, Loc.Data, size); 1842 } 1843 1844 void initializeLocal(ASTContext &Context, SourceLocation Loc); 1845 1846 unsigned getExtraLocalDataSize() const { 1847 return getNumArgs() * sizeof(TemplateArgumentLocInfo); 1848 } 1849 1850 unsigned getExtraLocalDataAlignment() const { 1851 return llvm::alignOf<TemplateArgumentLocInfo>(); 1852 } 1853 1854private: 1855 TemplateArgumentLocInfo *getArgInfos() const { 1856 return static_cast<TemplateArgumentLocInfo*>(getExtraLocalData()); 1857 } 1858}; 1859 1860 1861struct PackExpansionTypeLocInfo { 1862 SourceLocation EllipsisLoc; 1863}; 1864 1865class PackExpansionTypeLoc 1866 : public ConcreteTypeLoc<UnqualTypeLoc, PackExpansionTypeLoc, 1867 PackExpansionType, PackExpansionTypeLocInfo> { 1868public: 1869 SourceLocation getEllipsisLoc() const { 1870 return this->getLocalData()->EllipsisLoc; 1871 } 1872 1873 void setEllipsisLoc(SourceLocation Loc) { 1874 this->getLocalData()->EllipsisLoc = Loc; 1875 } 1876 1877 SourceRange getLocalSourceRange() const { 1878 return SourceRange(getEllipsisLoc(), getEllipsisLoc()); 1879 } 1880 1881 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 1882 setEllipsisLoc(Loc); 1883 } 1884 1885 TypeLoc getPatternLoc() const { 1886 return getInnerTypeLoc(); 1887 } 1888 1889 QualType getInnerType() const { 1890 return this->getTypePtr()->getPattern(); 1891 } 1892}; 1893 1894struct AtomicTypeLocInfo { 1895 SourceLocation KWLoc, LParenLoc, RParenLoc; 1896}; 1897 1898class AtomicTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, AtomicTypeLoc, 1899 AtomicType, AtomicTypeLocInfo> { 1900public: 1901 TypeLoc getValueLoc() const { 1902 return this->getInnerTypeLoc(); 1903 } 1904 1905 SourceRange getLocalSourceRange() const { 1906 return SourceRange(getKWLoc(), getRParenLoc()); 1907 } 1908 1909 SourceLocation getKWLoc() const { 1910 return this->getLocalData()->KWLoc; 1911 } 1912 void setKWLoc(SourceLocation Loc) { 1913 this->getLocalData()->KWLoc = Loc; 1914 } 1915 1916 SourceLocation getLParenLoc() const { 1917 return this->getLocalData()->LParenLoc; 1918 } 1919 void setLParenLoc(SourceLocation Loc) { 1920 this->getLocalData()->LParenLoc = Loc; 1921 } 1922 1923 SourceLocation getRParenLoc() const { 1924 return this->getLocalData()->RParenLoc; 1925 } 1926 void setRParenLoc(SourceLocation Loc) { 1927 this->getLocalData()->RParenLoc = Loc; 1928 } 1929 1930 SourceRange getParensRange() const { 1931 return SourceRange(getLParenLoc(), getRParenLoc()); 1932 } 1933 void setParensRange(SourceRange Range) { 1934 setLParenLoc(Range.getBegin()); 1935 setRParenLoc(Range.getEnd()); 1936 } 1937 1938 void initializeLocal(ASTContext &Context, SourceLocation Loc) { 1939 setKWLoc(Loc); 1940 setLParenLoc(Loc); 1941 setRParenLoc(Loc); 1942 } 1943 1944 QualType getInnerType() const { 1945 return this->getTypePtr()->getValueType(); 1946 } 1947}; 1948 1949 1950} 1951 1952#endif 1953