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 };
    542 
    543 /// \brief Wrapper for source info for unresolved typename using decls.
    544 class UnresolvedUsingTypeLoc :
    545     public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
    546                                      UnresolvedUsingTypeLoc,
    547                                      UnresolvedUsingType> {
    548 public:
    549   UnresolvedUsingTypenameDecl *getDecl() const {
    550     return getTypePtr()->getDecl();
    551   }
    552 };
    553 
    554 /// \brief Wrapper for source info for tag types.  Note that this only
    555 /// records source info for the name itself; a type written 'struct foo'
    556 /// should be represented as an ElaboratedTypeLoc.  We currently
    557 /// only do that when C++ is enabled because of the expense of
    558 /// creating an ElaboratedType node for so many type references in C.
    559 class TagTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
    560                                                     TagTypeLoc,
    561                                                     TagType> {
    562 public:
    563   TagDecl *getDecl() const { return getTypePtr()->getDecl(); }
    564 };
    565 
    566 /// \brief Wrapper for source info for record types.
    567 class RecordTypeLoc : public InheritingConcreteTypeLoc<TagTypeLoc,
    568                                                        RecordTypeLoc,
    569                                                        RecordType> {
    570 public:
    571   RecordDecl *getDecl() const { return getTypePtr()->getDecl(); }
    572 };
    573 
    574 /// \brief Wrapper for source info for enum types.
    575 class EnumTypeLoc : public InheritingConcreteTypeLoc<TagTypeLoc,
    576                                                      EnumTypeLoc,
    577                                                      EnumType> {
    578 public:
    579   EnumDecl *getDecl() const { return getTypePtr()->getDecl(); }
    580 };
    581 
    582 /// \brief Wrapper for template type parameters.
    583 class TemplateTypeParmTypeLoc :
    584     public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
    585                                      TemplateTypeParmTypeLoc,
    586                                      TemplateTypeParmType> {
    587 public:
    588   TemplateTypeParmDecl *getDecl() const { return getTypePtr()->getDecl(); }
    589 };
    590 
    591 /// \brief Wrapper for substituted template type parameters.
    592 class SubstTemplateTypeParmTypeLoc :
    593     public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
    594                                      SubstTemplateTypeParmTypeLoc,
    595                                      SubstTemplateTypeParmType> {
    596 };
    597 
    598   /// \brief Wrapper for substituted template type parameters.
    599 class SubstTemplateTypeParmPackTypeLoc :
    600     public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
    601                                      SubstTemplateTypeParmPackTypeLoc,
    602                                      SubstTemplateTypeParmPackType> {
    603 };
    604 
    605 struct AttributedLocInfo {
    606   union {
    607     Expr *ExprOperand;
    608 
    609     /// A raw SourceLocation.
    610     unsigned EnumOperandLoc;
    611   };
    612 
    613   SourceRange OperandParens;
    614 
    615   SourceLocation AttrLoc;
    616 };
    617 
    618 /// \brief Type source information for an attributed type.
    619 class AttributedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
    620                                                  AttributedTypeLoc,
    621                                                  AttributedType,
    622                                                  AttributedLocInfo> {
    623 public:
    624   AttributedType::Kind getAttrKind() const {
    625     return getTypePtr()->getAttrKind();
    626   }
    627 
    628   bool hasAttrExprOperand() const {
    629     return (getAttrKind() >= AttributedType::FirstExprOperandKind &&
    630             getAttrKind() <= AttributedType::LastExprOperandKind);
    631   }
    632 
    633   bool hasAttrEnumOperand() const {
    634     return (getAttrKind() >= AttributedType::FirstEnumOperandKind &&
    635             getAttrKind() <= AttributedType::LastEnumOperandKind);
    636   }
    637 
    638   bool hasAttrOperand() const {
    639     return hasAttrExprOperand() || hasAttrEnumOperand();
    640   }
    641 
    642   /// The modified type, which is generally canonically different from
    643   /// the attribute type.
    644   ///    int main(int, char**) __attribute__((noreturn))
    645   ///    ~~~     ~~~~~~~~~~~~~
    646   TypeLoc getModifiedLoc() const {
    647     return getInnerTypeLoc();
    648   }
    649 
    650   /// The location of the attribute name, i.e.
    651   ///    __attribute__((regparm(1000)))
    652   ///                   ^~~~~~~
    653   SourceLocation getAttrNameLoc() const {
    654     return getLocalData()->AttrLoc;
    655   }
    656   void setAttrNameLoc(SourceLocation loc) {
    657     getLocalData()->AttrLoc = loc;
    658   }
    659 
    660   /// The attribute's expression operand, if it has one.
    661   ///    void *cur_thread __attribute__((address_space(21)))
    662   ///                                                  ^~
    663   Expr *getAttrExprOperand() const {
    664     assert(hasAttrExprOperand());
    665     return getLocalData()->ExprOperand;
    666   }
    667   void setAttrExprOperand(Expr *e) {
    668     assert(hasAttrExprOperand());
    669     getLocalData()->ExprOperand = e;
    670   }
    671 
    672   /// The location of the attribute's enumerated operand, if it has one.
    673   ///    void * __attribute__((objc_gc(weak)))
    674   ///                                  ^~~~
    675   SourceLocation getAttrEnumOperandLoc() const {
    676     assert(hasAttrEnumOperand());
    677     return SourceLocation::getFromRawEncoding(getLocalData()->EnumOperandLoc);
    678   }
    679   void setAttrEnumOperandLoc(SourceLocation loc) {
    680     assert(hasAttrEnumOperand());
    681     getLocalData()->EnumOperandLoc = loc.getRawEncoding();
    682   }
    683 
    684   /// The location of the parentheses around the operand, if there is
    685   /// an operand.
    686   ///    void * __attribute__((objc_gc(weak)))
    687   ///                                 ^    ^
    688   SourceRange getAttrOperandParensRange() const {
    689     assert(hasAttrOperand());
    690     return getLocalData()->OperandParens;
    691   }
    692   void setAttrOperandParensRange(SourceRange range) {
    693     assert(hasAttrOperand());
    694     getLocalData()->OperandParens = range;
    695   }
    696 
    697   SourceRange getLocalSourceRange() const {
    698     // Note that this does *not* include the range of the attribute
    699     // enclosure, e.g.:
    700     //    __attribute__((foo(bar)))
    701     //    ^~~~~~~~~~~~~~~        ~~
    702     // or
    703     //    [[foo(bar)]]
    704     //    ^~        ~~
    705     // That enclosure doesn't necessarily belong to a single attribute
    706     // anyway.
    707     SourceRange range(getAttrNameLoc());
    708     if (hasAttrOperand())
    709       range.setEnd(getAttrOperandParensRange().getEnd());
    710     return range;
    711   }
    712 
    713   void initializeLocal(ASTContext &Context, SourceLocation loc) {
    714     setAttrNameLoc(loc);
    715     if (hasAttrExprOperand()) {
    716       setAttrOperandParensRange(SourceRange(loc));
    717       setAttrExprOperand(0);
    718     } else if (hasAttrEnumOperand()) {
    719       setAttrOperandParensRange(SourceRange(loc));
    720       setAttrEnumOperandLoc(loc);
    721     }
    722   }
    723 
    724   QualType getInnerType() const {
    725     return getTypePtr()->getModifiedType();
    726   }
    727 };
    728 
    729 
    730 struct ObjCProtocolListLocInfo {
    731   SourceLocation LAngleLoc;
    732   SourceLocation RAngleLoc;
    733   bool HasBaseTypeAsWritten;
    734 };
    735 
    736 // A helper class for defining ObjC TypeLocs that can qualified with
    737 // protocols.
    738 //
    739 // TypeClass basically has to be either ObjCInterfaceType or
    740 // ObjCObjectPointerType.
    741 class ObjCObjectTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
    742                                                  ObjCObjectTypeLoc,
    743                                                  ObjCObjectType,
    744                                                  ObjCProtocolListLocInfo> {
    745   // SourceLocations are stored after Info, one for each Protocol.
    746   SourceLocation *getProtocolLocArray() const {
    747     return (SourceLocation*) this->getExtraLocalData();
    748   }
    749 
    750 public:
    751   SourceLocation getLAngleLoc() const {
    752     return this->getLocalData()->LAngleLoc;
    753   }
    754   void setLAngleLoc(SourceLocation Loc) {
    755     this->getLocalData()->LAngleLoc = Loc;
    756   }
    757 
    758   SourceLocation getRAngleLoc() const {
    759     return this->getLocalData()->RAngleLoc;
    760   }
    761   void setRAngleLoc(SourceLocation Loc) {
    762     this->getLocalData()->RAngleLoc = Loc;
    763   }
    764 
    765   unsigned getNumProtocols() const {
    766     return this->getTypePtr()->getNumProtocols();
    767   }
    768 
    769   SourceLocation getProtocolLoc(unsigned i) const {
    770     assert(i < getNumProtocols() && "Index is out of bounds!");
    771     return getProtocolLocArray()[i];
    772   }
    773   void setProtocolLoc(unsigned i, SourceLocation Loc) {
    774     assert(i < getNumProtocols() && "Index is out of bounds!");
    775     getProtocolLocArray()[i] = Loc;
    776   }
    777 
    778   ObjCProtocolDecl *getProtocol(unsigned i) const {
    779     assert(i < getNumProtocols() && "Index is out of bounds!");
    780     return *(this->getTypePtr()->qual_begin() + i);
    781   }
    782 
    783   bool hasBaseTypeAsWritten() const {
    784     return getLocalData()->HasBaseTypeAsWritten;
    785   }
    786 
    787   void setHasBaseTypeAsWritten(bool HasBaseType) {
    788     getLocalData()->HasBaseTypeAsWritten = HasBaseType;
    789   }
    790 
    791   TypeLoc getBaseLoc() const {
    792     return getInnerTypeLoc();
    793   }
    794 
    795   SourceRange getLocalSourceRange() const {
    796     return SourceRange(getLAngleLoc(), getRAngleLoc());
    797   }
    798 
    799   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
    800     setHasBaseTypeAsWritten(true);
    801     setLAngleLoc(Loc);
    802     setRAngleLoc(Loc);
    803     for (unsigned i = 0, e = getNumProtocols(); i != e; ++i)
    804       setProtocolLoc(i, Loc);
    805   }
    806 
    807   unsigned getExtraLocalDataSize() const {
    808     return this->getNumProtocols() * sizeof(SourceLocation);
    809   }
    810 
    811   QualType getInnerType() const {
    812     return getTypePtr()->getBaseType();
    813   }
    814 };
    815 
    816 
    817 struct ObjCInterfaceLocInfo {
    818   SourceLocation NameLoc;
    819 };
    820 
    821 /// \brief Wrapper for source info for ObjC interfaces.
    822 class ObjCInterfaceTypeLoc : public ConcreteTypeLoc<ObjCObjectTypeLoc,
    823                                                     ObjCInterfaceTypeLoc,
    824                                                     ObjCInterfaceType,
    825                                                     ObjCInterfaceLocInfo> {
    826 public:
    827   ObjCInterfaceDecl *getIFaceDecl() const {
    828     return getTypePtr()->getDecl();
    829   }
    830 
    831   SourceLocation getNameLoc() const {
    832     return getLocalData()->NameLoc;
    833   }
    834 
    835   void setNameLoc(SourceLocation Loc) {
    836     getLocalData()->NameLoc = Loc;
    837   }
    838 
    839   SourceRange getLocalSourceRange() const {
    840     return SourceRange(getNameLoc());
    841   }
    842 
    843   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
    844     setNameLoc(Loc);
    845   }
    846 };
    847 
    848 struct ParenLocInfo {
    849   SourceLocation LParenLoc;
    850   SourceLocation RParenLoc;
    851 };
    852 
    853 class ParenTypeLoc
    854   : public ConcreteTypeLoc<UnqualTypeLoc, ParenTypeLoc, ParenType,
    855                            ParenLocInfo> {
    856 public:
    857   SourceLocation getLParenLoc() const {
    858     return this->getLocalData()->LParenLoc;
    859   }
    860   SourceLocation getRParenLoc() const {
    861     return this->getLocalData()->RParenLoc;
    862   }
    863   void setLParenLoc(SourceLocation Loc) {
    864     this->getLocalData()->LParenLoc = Loc;
    865   }
    866   void setRParenLoc(SourceLocation Loc) {
    867     this->getLocalData()->RParenLoc = Loc;
    868   }
    869 
    870   SourceRange getLocalSourceRange() const {
    871     return SourceRange(getLParenLoc(), getRParenLoc());
    872   }
    873 
    874   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
    875     setLParenLoc(Loc);
    876     setRParenLoc(Loc);
    877   }
    878 
    879   TypeLoc getInnerLoc() const {
    880     return getInnerTypeLoc();
    881   }
    882 
    883   QualType getInnerType() const {
    884     return this->getTypePtr()->getInnerType();
    885   }
    886 };
    887 
    888 
    889 struct PointerLikeLocInfo {
    890   SourceLocation StarLoc;
    891 };
    892 
    893 /// A base class for
    894 template <class Derived, class TypeClass, class LocalData = PointerLikeLocInfo>
    895 class PointerLikeTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc, Derived,
    896                                                   TypeClass, LocalData> {
    897 public:
    898   SourceLocation getSigilLoc() const {
    899     return this->getLocalData()->StarLoc;
    900   }
    901   void setSigilLoc(SourceLocation Loc) {
    902     this->getLocalData()->StarLoc = Loc;
    903   }
    904 
    905   TypeLoc getPointeeLoc() const {
    906     return this->getInnerTypeLoc();
    907   }
    908 
    909   SourceRange getLocalSourceRange() const {
    910     return SourceRange(getSigilLoc(), getSigilLoc());
    911   }
    912 
    913   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
    914     setSigilLoc(Loc);
    915   }
    916 
    917   QualType getInnerType() const {
    918     return this->getTypePtr()->getPointeeType();
    919   }
    920 };
    921 
    922 
    923 /// \brief Wrapper for source info for pointers.
    924 class PointerTypeLoc : public PointerLikeTypeLoc<PointerTypeLoc,
    925                                                  PointerType> {
    926 public:
    927   SourceLocation getStarLoc() const {
    928     return getSigilLoc();
    929   }
    930   void setStarLoc(SourceLocation Loc) {
    931     setSigilLoc(Loc);
    932   }
    933 };
    934 
    935 
    936 /// \brief Wrapper for source info for block pointers.
    937 class BlockPointerTypeLoc : public PointerLikeTypeLoc<BlockPointerTypeLoc,
    938                                                       BlockPointerType> {
    939 public:
    940   SourceLocation getCaretLoc() const {
    941     return getSigilLoc();
    942   }
    943   void setCaretLoc(SourceLocation Loc) {
    944     setSigilLoc(Loc);
    945   }
    946 };
    947 
    948 struct MemberPointerLocInfo : public PointerLikeLocInfo {
    949   TypeSourceInfo *ClassTInfo;
    950 };
    951 
    952 /// \brief Wrapper for source info for member pointers.
    953 class MemberPointerTypeLoc : public PointerLikeTypeLoc<MemberPointerTypeLoc,
    954                                                        MemberPointerType,
    955                                                        MemberPointerLocInfo> {
    956 public:
    957   SourceLocation getStarLoc() const {
    958     return getSigilLoc();
    959   }
    960   void setStarLoc(SourceLocation Loc) {
    961     setSigilLoc(Loc);
    962   }
    963 
    964   const Type *getClass() const {
    965     return getTypePtr()->getClass();
    966   }
    967   TypeSourceInfo *getClassTInfo() const {
    968     return getLocalData()->ClassTInfo;
    969   }
    970   void setClassTInfo(TypeSourceInfo* TI) {
    971     getLocalData()->ClassTInfo = TI;
    972   }
    973 
    974   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
    975     setSigilLoc(Loc);
    976     setClassTInfo(0);
    977   }
    978 
    979   SourceRange getLocalSourceRange() const {
    980     if (TypeSourceInfo *TI = getClassTInfo())
    981       return SourceRange(TI->getTypeLoc().getBeginLoc(), getStarLoc());
    982     else
    983       return SourceRange(getStarLoc());
    984   }
    985 };
    986 
    987 /// Wraps an ObjCPointerType with source location information.
    988 class ObjCObjectPointerTypeLoc :
    989     public PointerLikeTypeLoc<ObjCObjectPointerTypeLoc,
    990                               ObjCObjectPointerType> {
    991 public:
    992   SourceLocation getStarLoc() const {
    993     return getSigilLoc();
    994   }
    995 
    996   void setStarLoc(SourceLocation Loc) {
    997     setSigilLoc(Loc);
    998   }
    999 };
   1000 
   1001 
   1002 class ReferenceTypeLoc : public PointerLikeTypeLoc<ReferenceTypeLoc,
   1003                                                    ReferenceType> {
   1004 public:
   1005   QualType getInnerType() const {
   1006     return getTypePtr()->getPointeeTypeAsWritten();
   1007   }
   1008 };
   1009 
   1010 class LValueReferenceTypeLoc :
   1011     public InheritingConcreteTypeLoc<ReferenceTypeLoc,
   1012                                      LValueReferenceTypeLoc,
   1013                                      LValueReferenceType> {
   1014 public:
   1015   SourceLocation getAmpLoc() const {
   1016     return getSigilLoc();
   1017   }
   1018   void setAmpLoc(SourceLocation Loc) {
   1019     setSigilLoc(Loc);
   1020   }
   1021 };
   1022 
   1023 class RValueReferenceTypeLoc :
   1024     public InheritingConcreteTypeLoc<ReferenceTypeLoc,
   1025                                      RValueReferenceTypeLoc,
   1026                                      RValueReferenceType> {
   1027 public:
   1028   SourceLocation getAmpAmpLoc() const {
   1029     return getSigilLoc();
   1030   }
   1031   void setAmpAmpLoc(SourceLocation Loc) {
   1032     setSigilLoc(Loc);
   1033   }
   1034 };
   1035 
   1036 
   1037 struct FunctionLocInfo {
   1038   SourceLocation LocalRangeBegin;
   1039   SourceLocation LocalRangeEnd;
   1040   bool TrailingReturn;
   1041 };
   1042 
   1043 /// \brief Wrapper for source info for functions.
   1044 class FunctionTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
   1045                                                FunctionTypeLoc,
   1046                                                FunctionType,
   1047                                                FunctionLocInfo> {
   1048 public:
   1049   SourceLocation getLocalRangeBegin() const {
   1050     return getLocalData()->LocalRangeBegin;
   1051   }
   1052   void setLocalRangeBegin(SourceLocation L) {
   1053     getLocalData()->LocalRangeBegin = L;
   1054   }
   1055 
   1056   SourceLocation getLocalRangeEnd() const {
   1057     return getLocalData()->LocalRangeEnd;
   1058   }
   1059   void setLocalRangeEnd(SourceLocation L) {
   1060     getLocalData()->LocalRangeEnd = L;
   1061   }
   1062 
   1063   bool getTrailingReturn() const {
   1064     return getLocalData()->TrailingReturn;
   1065   }
   1066   void setTrailingReturn(bool Trailing) {
   1067     getLocalData()->TrailingReturn = Trailing;
   1068   }
   1069 
   1070   // ParmVarDecls* are stored after Info, one for each argument.
   1071   ParmVarDecl **getParmArray() const {
   1072     return (ParmVarDecl**) getExtraLocalData();
   1073   }
   1074 
   1075   unsigned getNumArgs() const {
   1076     if (isa<FunctionNoProtoType>(getTypePtr()))
   1077       return 0;
   1078     return cast<FunctionProtoType>(getTypePtr())->getNumArgs();
   1079   }
   1080   ParmVarDecl *getArg(unsigned i) const { return getParmArray()[i]; }
   1081   void setArg(unsigned i, ParmVarDecl *VD) { getParmArray()[i] = VD; }
   1082 
   1083   TypeLoc getResultLoc() const {
   1084     return getInnerTypeLoc();
   1085   }
   1086 
   1087   SourceRange getLocalSourceRange() const {
   1088     return SourceRange(getLocalRangeBegin(), getLocalRangeEnd());
   1089   }
   1090 
   1091   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
   1092     setLocalRangeBegin(Loc);
   1093     setLocalRangeEnd(Loc);
   1094     setTrailingReturn(false);
   1095     for (unsigned i = 0, e = getNumArgs(); i != e; ++i)
   1096       setArg(i, NULL);
   1097   }
   1098 
   1099   /// \brief Returns the size of the type source info data block that is
   1100   /// specific to this type.
   1101   unsigned getExtraLocalDataSize() const {
   1102     return getNumArgs() * sizeof(ParmVarDecl*);
   1103   }
   1104 
   1105   QualType getInnerType() const { return getTypePtr()->getResultType(); }
   1106 };
   1107 
   1108 class FunctionProtoTypeLoc :
   1109     public InheritingConcreteTypeLoc<FunctionTypeLoc,
   1110                                      FunctionProtoTypeLoc,
   1111                                      FunctionProtoType> {
   1112 };
   1113 
   1114 class FunctionNoProtoTypeLoc :
   1115     public InheritingConcreteTypeLoc<FunctionTypeLoc,
   1116                                      FunctionNoProtoTypeLoc,
   1117                                      FunctionNoProtoType> {
   1118 };
   1119 
   1120 
   1121 struct ArrayLocInfo {
   1122   SourceLocation LBracketLoc, RBracketLoc;
   1123   Expr *Size;
   1124 };
   1125 
   1126 /// \brief Wrapper for source info for arrays.
   1127 class ArrayTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
   1128                                             ArrayTypeLoc,
   1129                                             ArrayType,
   1130                                             ArrayLocInfo> {
   1131 public:
   1132   SourceLocation getLBracketLoc() const {
   1133     return getLocalData()->LBracketLoc;
   1134   }
   1135   void setLBracketLoc(SourceLocation Loc) {
   1136     getLocalData()->LBracketLoc = Loc;
   1137   }
   1138 
   1139   SourceLocation getRBracketLoc() const {
   1140     return getLocalData()->RBracketLoc;
   1141   }
   1142   void setRBracketLoc(SourceLocation Loc) {
   1143     getLocalData()->RBracketLoc = Loc;
   1144   }
   1145 
   1146   SourceRange getBracketsRange() const {
   1147     return SourceRange(getLBracketLoc(), getRBracketLoc());
   1148   }
   1149 
   1150   Expr *getSizeExpr() const {
   1151     return getLocalData()->Size;
   1152   }
   1153   void setSizeExpr(Expr *Size) {
   1154     getLocalData()->Size = Size;
   1155   }
   1156 
   1157   TypeLoc getElementLoc() const {
   1158     return getInnerTypeLoc();
   1159   }
   1160 
   1161   SourceRange getLocalSourceRange() const {
   1162     return SourceRange(getLBracketLoc(), getRBracketLoc());
   1163   }
   1164 
   1165   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
   1166     setLBracketLoc(Loc);
   1167     setRBracketLoc(Loc);
   1168     setSizeExpr(NULL);
   1169   }
   1170 
   1171   QualType getInnerType() const { return getTypePtr()->getElementType(); }
   1172 };
   1173 
   1174 class ConstantArrayTypeLoc :
   1175     public InheritingConcreteTypeLoc<ArrayTypeLoc,
   1176                                      ConstantArrayTypeLoc,
   1177                                      ConstantArrayType> {
   1178 };
   1179 
   1180 class IncompleteArrayTypeLoc :
   1181     public InheritingConcreteTypeLoc<ArrayTypeLoc,
   1182                                      IncompleteArrayTypeLoc,
   1183                                      IncompleteArrayType> {
   1184 };
   1185 
   1186 class DependentSizedArrayTypeLoc :
   1187     public InheritingConcreteTypeLoc<ArrayTypeLoc,
   1188                                      DependentSizedArrayTypeLoc,
   1189                                      DependentSizedArrayType> {
   1190 
   1191 };
   1192 
   1193 class VariableArrayTypeLoc :
   1194     public InheritingConcreteTypeLoc<ArrayTypeLoc,
   1195                                      VariableArrayTypeLoc,
   1196                                      VariableArrayType> {
   1197 };
   1198 
   1199 
   1200 // Location information for a TemplateName.  Rudimentary for now.
   1201 struct TemplateNameLocInfo {
   1202   SourceLocation NameLoc;
   1203 };
   1204 
   1205 struct TemplateSpecializationLocInfo : TemplateNameLocInfo {
   1206   SourceLocation LAngleLoc;
   1207   SourceLocation RAngleLoc;
   1208 };
   1209 
   1210 class TemplateSpecializationTypeLoc :
   1211     public ConcreteTypeLoc<UnqualTypeLoc,
   1212                            TemplateSpecializationTypeLoc,
   1213                            TemplateSpecializationType,
   1214                            TemplateSpecializationLocInfo> {
   1215 public:
   1216   SourceLocation getLAngleLoc() const {
   1217     return getLocalData()->LAngleLoc;
   1218   }
   1219   void setLAngleLoc(SourceLocation Loc) {
   1220     getLocalData()->LAngleLoc = Loc;
   1221   }
   1222 
   1223   SourceLocation getRAngleLoc() const {
   1224     return getLocalData()->RAngleLoc;
   1225   }
   1226   void setRAngleLoc(SourceLocation Loc) {
   1227     getLocalData()->RAngleLoc = Loc;
   1228   }
   1229 
   1230   unsigned getNumArgs() const {
   1231     return getTypePtr()->getNumArgs();
   1232   }
   1233   void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI) {
   1234     getArgInfos()[i] = AI;
   1235   }
   1236   TemplateArgumentLocInfo getArgLocInfo(unsigned i) const {
   1237     return getArgInfos()[i];
   1238   }
   1239 
   1240   TemplateArgumentLoc getArgLoc(unsigned i) const {
   1241     return TemplateArgumentLoc(getTypePtr()->getArg(i), getArgLocInfo(i));
   1242   }
   1243 
   1244   SourceLocation getTemplateNameLoc() const {
   1245     return getLocalData()->NameLoc;
   1246   }
   1247   void setTemplateNameLoc(SourceLocation Loc) {
   1248     getLocalData()->NameLoc = Loc;
   1249   }
   1250 
   1251   /// \brief - Copy the location information from the given info.
   1252   void copy(TemplateSpecializationTypeLoc Loc) {
   1253     unsigned size = getFullDataSize();
   1254     assert(size == Loc.getFullDataSize());
   1255 
   1256     // We're potentially copying Expr references here.  We don't
   1257     // bother retaining them because TypeSourceInfos live forever, so
   1258     // as long as the Expr was retained when originally written into
   1259     // the TypeLoc, we're okay.
   1260     memcpy(Data, Loc.Data, size);
   1261   }
   1262 
   1263   SourceRange getLocalSourceRange() const {
   1264     return SourceRange(getTemplateNameLoc(), getRAngleLoc());
   1265   }
   1266 
   1267   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
   1268     setLAngleLoc(Loc);
   1269     setRAngleLoc(Loc);
   1270     setTemplateNameLoc(Loc);
   1271     initializeArgLocs(Context, getNumArgs(), getTypePtr()->getArgs(),
   1272                       getArgInfos(), Loc);
   1273   }
   1274 
   1275   static void initializeArgLocs(ASTContext &Context, unsigned NumArgs,
   1276                                 const TemplateArgument *Args,
   1277                                 TemplateArgumentLocInfo *ArgInfos,
   1278                                 SourceLocation Loc);
   1279 
   1280   unsigned getExtraLocalDataSize() const {
   1281     return getNumArgs() * sizeof(TemplateArgumentLocInfo);
   1282   }
   1283 
   1284 private:
   1285   TemplateArgumentLocInfo *getArgInfos() const {
   1286     return static_cast<TemplateArgumentLocInfo*>(getExtraLocalData());
   1287   }
   1288 };
   1289 
   1290 //===----------------------------------------------------------------------===//
   1291 //
   1292 //  All of these need proper implementations.
   1293 //
   1294 //===----------------------------------------------------------------------===//
   1295 
   1296 // FIXME: size expression and attribute locations (or keyword if we
   1297 // ever fully support altivec syntax).
   1298 class VectorTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
   1299                                                        VectorTypeLoc,
   1300                                                        VectorType> {
   1301 };
   1302 
   1303 // FIXME: size expression and attribute locations.
   1304 class ExtVectorTypeLoc : public InheritingConcreteTypeLoc<VectorTypeLoc,
   1305                                                           ExtVectorTypeLoc,
   1306                                                           ExtVectorType> {
   1307 };
   1308 
   1309 // FIXME: attribute locations.
   1310 // For some reason, this isn't a subtype of VectorType.
   1311 class DependentSizedExtVectorTypeLoc :
   1312     public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
   1313                                      DependentSizedExtVectorTypeLoc,
   1314                                      DependentSizedExtVectorType> {
   1315 };
   1316 
   1317 // FIXME: location of the '_Complex' keyword.
   1318 class ComplexTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
   1319                                                         ComplexTypeLoc,
   1320                                                         ComplexType> {
   1321 };
   1322 
   1323 struct TypeofLocInfo {
   1324   SourceLocation TypeofLoc;
   1325   SourceLocation LParenLoc;
   1326   SourceLocation RParenLoc;
   1327 };
   1328 
   1329 struct TypeOfExprTypeLocInfo : public TypeofLocInfo {
   1330 };
   1331 
   1332 struct TypeOfTypeLocInfo : public TypeofLocInfo {
   1333   TypeSourceInfo* UnderlyingTInfo;
   1334 };
   1335 
   1336 template <class Derived, class TypeClass, class LocalData = TypeofLocInfo>
   1337 class TypeofLikeTypeLoc
   1338   : public ConcreteTypeLoc<UnqualTypeLoc, Derived, TypeClass, LocalData> {
   1339 public:
   1340   SourceLocation getTypeofLoc() const {
   1341     return this->getLocalData()->TypeofLoc;
   1342   }
   1343   void setTypeofLoc(SourceLocation Loc) {
   1344     this->getLocalData()->TypeofLoc = Loc;
   1345   }
   1346 
   1347   SourceLocation getLParenLoc() const {
   1348     return this->getLocalData()->LParenLoc;
   1349   }
   1350   void setLParenLoc(SourceLocation Loc) {
   1351     this->getLocalData()->LParenLoc = Loc;
   1352   }
   1353 
   1354   SourceLocation getRParenLoc() const {
   1355     return this->getLocalData()->RParenLoc;
   1356   }
   1357   void setRParenLoc(SourceLocation Loc) {
   1358     this->getLocalData()->RParenLoc = Loc;
   1359   }
   1360 
   1361   SourceRange getParensRange() const {
   1362     return SourceRange(getLParenLoc(), getRParenLoc());
   1363   }
   1364   void setParensRange(SourceRange range) {
   1365       setLParenLoc(range.getBegin());
   1366       setRParenLoc(range.getEnd());
   1367   }
   1368 
   1369   SourceRange getLocalSourceRange() const {
   1370     return SourceRange(getTypeofLoc(), getRParenLoc());
   1371   }
   1372 
   1373   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
   1374     setTypeofLoc(Loc);
   1375     setLParenLoc(Loc);
   1376     setRParenLoc(Loc);
   1377   }
   1378 };
   1379 
   1380 class TypeOfExprTypeLoc : public TypeofLikeTypeLoc<TypeOfExprTypeLoc,
   1381                                                    TypeOfExprType,
   1382                                                    TypeOfExprTypeLocInfo> {
   1383 public:
   1384   Expr* getUnderlyingExpr() const {
   1385     return getTypePtr()->getUnderlyingExpr();
   1386   }
   1387   // Reimplemented to account for GNU/C++ extension
   1388   //     typeof unary-expression
   1389   // where there are no parentheses.
   1390   SourceRange getLocalSourceRange() const;
   1391 };
   1392 
   1393 class TypeOfTypeLoc
   1394   : public TypeofLikeTypeLoc<TypeOfTypeLoc, TypeOfType, TypeOfTypeLocInfo> {
   1395 public:
   1396   QualType getUnderlyingType() const {
   1397     return this->getTypePtr()->getUnderlyingType();
   1398   }
   1399   TypeSourceInfo* getUnderlyingTInfo() const {
   1400     return this->getLocalData()->UnderlyingTInfo;
   1401   }
   1402   void setUnderlyingTInfo(TypeSourceInfo* TI) const {
   1403     this->getLocalData()->UnderlyingTInfo = TI;
   1404   }
   1405 };
   1406 
   1407 // FIXME: location of the 'decltype' and parens.
   1408 class DecltypeTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
   1409                                                          DecltypeTypeLoc,
   1410                                                          DecltypeType> {
   1411 };
   1412 
   1413 struct UnaryTransformTypeLocInfo {
   1414   // FIXME: While there's only one unary transform right now, future ones may
   1415   // need different representations
   1416   SourceLocation KWLoc, LParenLoc, RParenLoc;
   1417   TypeSourceInfo *UnderlyingTInfo;
   1418 };
   1419 
   1420 class UnaryTransformTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
   1421                                                     UnaryTransformTypeLoc,
   1422                                                     UnaryTransformType,
   1423                                                     UnaryTransformTypeLocInfo> {
   1424 public:
   1425   SourceLocation getKWLoc() const { return getLocalData()->KWLoc; }
   1426   void setKWLoc(SourceLocation Loc) { getLocalData()->KWLoc = Loc; }
   1427 
   1428   SourceLocation getLParenLoc() const { return getLocalData()->LParenLoc; }
   1429   void setLParenLoc(SourceLocation Loc) { getLocalData()->LParenLoc = Loc; }
   1430 
   1431   SourceLocation getRParenLoc() const { return getLocalData()->RParenLoc; }
   1432   void setRParenLoc(SourceLocation Loc) { getLocalData()->RParenLoc = Loc; }
   1433 
   1434   TypeSourceInfo* getUnderlyingTInfo() const {
   1435     return getLocalData()->UnderlyingTInfo;
   1436   }
   1437   void setUnderlyingTInfo(TypeSourceInfo *TInfo) {
   1438     getLocalData()->UnderlyingTInfo = TInfo;
   1439   }
   1440 
   1441   SourceRange getLocalSourceRange() const {
   1442     return SourceRange(getKWLoc(), getRParenLoc());
   1443   }
   1444 
   1445   SourceRange getParensRange() const {
   1446     return SourceRange(getLParenLoc(), getRParenLoc());
   1447   }
   1448   void setParensRange(SourceRange Range) {
   1449     setLParenLoc(Range.getBegin());
   1450     setRParenLoc(Range.getEnd());
   1451   }
   1452 
   1453   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
   1454     setKWLoc(Loc);
   1455     setRParenLoc(Loc);
   1456     setLParenLoc(Loc);
   1457   }
   1458 };
   1459 
   1460 class AutoTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
   1461                                                         AutoTypeLoc,
   1462                                                         AutoType> {
   1463 };
   1464 
   1465 struct ElaboratedLocInfo {
   1466   SourceLocation KeywordLoc;
   1467 
   1468   /// \brief Opaque data pointer used to reconstruct a nested-name-specifier
   1469   /// from
   1470   void *QualifierData;
   1471 };
   1472 
   1473 class ElaboratedTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
   1474                                                  ElaboratedTypeLoc,
   1475                                                  ElaboratedType,
   1476                                                  ElaboratedLocInfo> {
   1477 public:
   1478   SourceLocation getKeywordLoc() const {
   1479     return this->getLocalData()->KeywordLoc;
   1480   }
   1481   void setKeywordLoc(SourceLocation Loc) {
   1482     this->getLocalData()->KeywordLoc = Loc;
   1483   }
   1484 
   1485   NestedNameSpecifierLoc getQualifierLoc() const {
   1486     return NestedNameSpecifierLoc(getTypePtr()->getQualifier(),
   1487                                   getLocalData()->QualifierData);
   1488   }
   1489 
   1490   void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc) {
   1491     assert(QualifierLoc.getNestedNameSpecifier()
   1492                                             == getTypePtr()->getQualifier() &&
   1493            "Inconsistent nested-name-specifier pointer");
   1494     getLocalData()->QualifierData = QualifierLoc.getOpaqueData();
   1495   }
   1496 
   1497   SourceRange getLocalSourceRange() const {
   1498     if (getKeywordLoc().isValid())
   1499       if (getQualifierLoc())
   1500         return SourceRange(getKeywordLoc(), getQualifierLoc().getEndLoc());
   1501       else
   1502         return SourceRange(getKeywordLoc());
   1503     else
   1504       return getQualifierLoc().getSourceRange();
   1505   }
   1506 
   1507   void initializeLocal(ASTContext &Context, SourceLocation Loc);
   1508 
   1509   TypeLoc getNamedTypeLoc() const {
   1510     return getInnerTypeLoc();
   1511   }
   1512 
   1513   QualType getInnerType() const {
   1514     return getTypePtr()->getNamedType();
   1515   }
   1516 
   1517   void copy(ElaboratedTypeLoc Loc) {
   1518     unsigned size = getFullDataSize();
   1519     assert(size == Loc.getFullDataSize());
   1520     memcpy(Data, Loc.Data, size);
   1521   }
   1522 };
   1523 
   1524 // This is exactly the structure of an ElaboratedTypeLoc whose inner
   1525 // type is some sort of TypeDeclTypeLoc.
   1526 struct DependentNameLocInfo : ElaboratedLocInfo {
   1527   SourceLocation NameLoc;
   1528 
   1529   /// \brief Data associated with the nested-name-specifier location.
   1530   void *QualifierData;
   1531 };
   1532 
   1533 class DependentNameTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
   1534                                                     DependentNameTypeLoc,
   1535                                                     DependentNameType,
   1536                                                     DependentNameLocInfo> {
   1537 public:
   1538   SourceLocation getKeywordLoc() const {
   1539     return this->getLocalData()->KeywordLoc;
   1540   }
   1541   void setKeywordLoc(SourceLocation Loc) {
   1542     this->getLocalData()->KeywordLoc = Loc;
   1543   }
   1544 
   1545   NestedNameSpecifierLoc getQualifierLoc() const {
   1546     return NestedNameSpecifierLoc(getTypePtr()->getQualifier(),
   1547                                   getLocalData()->QualifierData);
   1548   }
   1549 
   1550   void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc) {
   1551     assert(QualifierLoc.getNestedNameSpecifier()
   1552                                             == getTypePtr()->getQualifier() &&
   1553            "Inconsistent nested-name-specifier pointer");
   1554     getLocalData()->QualifierData = QualifierLoc.getOpaqueData();
   1555   }
   1556 
   1557   SourceLocation getNameLoc() const {
   1558     return this->getLocalData()->NameLoc;
   1559   }
   1560   void setNameLoc(SourceLocation Loc) {
   1561     this->getLocalData()->NameLoc = Loc;
   1562   }
   1563 
   1564   SourceRange getLocalSourceRange() const {
   1565     if (getKeywordLoc().isValid())
   1566       return SourceRange(getKeywordLoc(), getNameLoc());
   1567     else
   1568       return SourceRange(getQualifierLoc().getBeginLoc(), getNameLoc());
   1569   }
   1570 
   1571   void copy(DependentNameTypeLoc Loc) {
   1572     unsigned size = getFullDataSize();
   1573     assert(size == Loc.getFullDataSize());
   1574     memcpy(Data, Loc.Data, size);
   1575   }
   1576 
   1577   void initializeLocal(ASTContext &Context, SourceLocation Loc);
   1578 };
   1579 
   1580 struct DependentTemplateSpecializationLocInfo : DependentNameLocInfo {
   1581   SourceLocation KeywordLoc;
   1582   SourceLocation LAngleLoc;
   1583   SourceLocation RAngleLoc;
   1584   // followed by a TemplateArgumentLocInfo[]
   1585 };
   1586 
   1587 class DependentTemplateSpecializationTypeLoc :
   1588     public ConcreteTypeLoc<UnqualTypeLoc,
   1589                            DependentTemplateSpecializationTypeLoc,
   1590                            DependentTemplateSpecializationType,
   1591                            DependentTemplateSpecializationLocInfo> {
   1592 public:
   1593   SourceLocation getKeywordLoc() const {
   1594     return this->getLocalData()->KeywordLoc;
   1595   }
   1596   void setKeywordLoc(SourceLocation Loc) {
   1597     this->getLocalData()->KeywordLoc = Loc;
   1598   }
   1599 
   1600   NestedNameSpecifierLoc getQualifierLoc() const {
   1601     if (!getLocalData()->QualifierData)
   1602       return NestedNameSpecifierLoc();
   1603 
   1604     return NestedNameSpecifierLoc(getTypePtr()->getQualifier(),
   1605                                   getLocalData()->QualifierData);
   1606   }
   1607 
   1608   void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc) {
   1609     if (!QualifierLoc) {
   1610       // Even if we have a nested-name-specifier in the dependent
   1611       // template specialization type, we won't record the nested-name-specifier
   1612       // location information when this type-source location information is
   1613       // part of a nested-name-specifier.
   1614       getLocalData()->QualifierData = 0;
   1615       return;
   1616     }
   1617 
   1618     assert(QualifierLoc.getNestedNameSpecifier()
   1619                                         == getTypePtr()->getQualifier() &&
   1620            "Inconsistent nested-name-specifier pointer");
   1621     getLocalData()->QualifierData = QualifierLoc.getOpaqueData();
   1622   }
   1623 
   1624   SourceLocation getNameLoc() const {
   1625     return this->getLocalData()->NameLoc;
   1626   }
   1627   void setNameLoc(SourceLocation Loc) {
   1628     this->getLocalData()->NameLoc = Loc;
   1629   }
   1630 
   1631   SourceLocation getLAngleLoc() const {
   1632     return this->getLocalData()->LAngleLoc;
   1633   }
   1634   void setLAngleLoc(SourceLocation Loc) {
   1635     this->getLocalData()->LAngleLoc = Loc;
   1636   }
   1637 
   1638   SourceLocation getRAngleLoc() const {
   1639     return this->getLocalData()->RAngleLoc;
   1640   }
   1641   void setRAngleLoc(SourceLocation Loc) {
   1642     this->getLocalData()->RAngleLoc = Loc;
   1643   }
   1644 
   1645   unsigned getNumArgs() const {
   1646     return getTypePtr()->getNumArgs();
   1647   }
   1648 
   1649   void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI) {
   1650     getArgInfos()[i] = AI;
   1651   }
   1652   TemplateArgumentLocInfo getArgLocInfo(unsigned i) const {
   1653     return getArgInfos()[i];
   1654   }
   1655 
   1656   TemplateArgumentLoc getArgLoc(unsigned i) const {
   1657     return TemplateArgumentLoc(getTypePtr()->getArg(i), getArgLocInfo(i));
   1658   }
   1659 
   1660   SourceRange getLocalSourceRange() const {
   1661     if (getKeywordLoc().isValid())
   1662       return SourceRange(getKeywordLoc(), getRAngleLoc());
   1663     else if (getQualifierLoc())
   1664       return SourceRange(getQualifierLoc().getBeginLoc(), getRAngleLoc());
   1665     else
   1666       return SourceRange(getNameLoc(), getRAngleLoc());
   1667   }
   1668 
   1669   void copy(DependentTemplateSpecializationTypeLoc Loc) {
   1670     unsigned size = getFullDataSize();
   1671     assert(size == Loc.getFullDataSize());
   1672     memcpy(Data, Loc.Data, size);
   1673   }
   1674 
   1675   void initializeLocal(ASTContext &Context, SourceLocation Loc);
   1676 
   1677   unsigned getExtraLocalDataSize() const {
   1678     return getNumArgs() * sizeof(TemplateArgumentLocInfo);
   1679   }
   1680 
   1681 private:
   1682   TemplateArgumentLocInfo *getArgInfos() const {
   1683     return static_cast<TemplateArgumentLocInfo*>(getExtraLocalData());
   1684   }
   1685 };
   1686 
   1687 
   1688 struct PackExpansionTypeLocInfo {
   1689   SourceLocation EllipsisLoc;
   1690 };
   1691 
   1692 class PackExpansionTypeLoc
   1693   : public ConcreteTypeLoc<UnqualTypeLoc, PackExpansionTypeLoc,
   1694                            PackExpansionType, PackExpansionTypeLocInfo> {
   1695 public:
   1696   SourceLocation getEllipsisLoc() const {
   1697     return this->getLocalData()->EllipsisLoc;
   1698   }
   1699 
   1700   void setEllipsisLoc(SourceLocation Loc) {
   1701     this->getLocalData()->EllipsisLoc = Loc;
   1702   }
   1703 
   1704   SourceRange getLocalSourceRange() const {
   1705     return SourceRange(getEllipsisLoc(), getEllipsisLoc());
   1706   }
   1707 
   1708   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
   1709     setEllipsisLoc(Loc);
   1710   }
   1711 
   1712   TypeLoc getPatternLoc() const {
   1713     return getInnerTypeLoc();
   1714   }
   1715 
   1716   QualType getInnerType() const {
   1717     return this->getTypePtr()->getPattern();
   1718   }
   1719 };
   1720 
   1721 }
   1722 
   1723 #endif
   1724