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