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