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

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