contrib/llvm/tools/clang/include/clang/AST/TypeLoc.h

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