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

   1 //===--- Type.h - C Language Family Type Representation ---------*- 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 Type interface and subclasses.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_AST_TYPE_H
  15 #define LLVM_CLANG_AST_TYPE_H
  16
  17 #include "clang/AST/NestedNameSpecifier.h"
  18 #include "clang/AST/TemplateName.h"
  19 #include "clang/Basic/Diagnostic.h"
  20 #include "clang/Basic/ExceptionSpecificationType.h"
  21 #include "clang/Basic/IdentifierTable.h"
  22 #include "clang/Basic/LLVM.h"
  23 #include "clang/Basic/Linkage.h"
  24 #include "clang/Basic/PartialDiagnostic.h"
  25 #include "clang/Basic/Specifiers.h"
  26 #include "clang/Basic/Visibility.h"
  27 #include "llvm/ADT/APSInt.h"
  28 #include "llvm/ADT/FoldingSet.h"
  29 #include "llvm/ADT/Optional.h"
  30 #include "llvm/ADT/PointerIntPair.h"
  31 #include "llvm/ADT/PointerUnion.h"
  32 #include "llvm/ADT/Twine.h"
  33 #include "llvm/Support/ErrorHandling.h"
  34 #include "llvm/Support/type_traits.h"
  35
  36 namespace clang {
  37   enum {
  38     TypeAlignmentInBits = 4,
  39     TypeAlignment = 1 << TypeAlignmentInBits
  40   };
  41   class Type;
  42   class ExtQuals;
  43   class QualType;
  44 }
  45
  46 namespace llvm {
  47   template <typename T>
  48   class PointerLikeTypeTraits;
  49   template<>
  50   class PointerLikeTypeTraits< ::clang::Type*> {
  51   public:
  52     static inline void *getAsVoidPointer(::clang::Type *P) { return P; }
  53     static inline ::clang::Type *getFromVoidPointer(void *P) {
  54       return static_cast< ::clang::Type*>(P);
  55     }
  56     enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
  57   };
  58   template<>
  59   class PointerLikeTypeTraits< ::clang::ExtQuals*> {
  60   public:
  61     static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }
  62     static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
  63       return static_cast< ::clang::ExtQuals*>(P);
  64     }
  65     enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
  66   };
  67
  68   template <>
  69   struct isPodLike<clang::QualType> { static const bool value = true; };
  70 }
  71
  72 namespace clang {
  73   class ASTContext;
  74   class TypedefNameDecl;
  75   class TemplateDecl;
  76   class TemplateTypeParmDecl;
  77   class NonTypeTemplateParmDecl;
  78   class TemplateTemplateParmDecl;
  79   class TagDecl;
  80   class RecordDecl;
  81   class CXXRecordDecl;
  82   class EnumDecl;
  83   class FieldDecl;
  84   class FunctionDecl;
  85   class ObjCInterfaceDecl;
  86   class ObjCProtocolDecl;
  87   class ObjCMethodDecl;
  88   class UnresolvedUsingTypenameDecl;
  89   class Expr;
  90   class Stmt;
  91   class SourceLocation;
  92   class StmtIteratorBase;
  93   class TemplateArgument;
  94   class TemplateArgumentLoc;
  95   class TemplateArgumentListInfo;
  96   class ElaboratedType;
  97   class ExtQuals;
  98   class ExtQualsTypeCommonBase;
  99   struct PrintingPolicy;
 100
 101   template <typename> class CanQual;
 102   typedef CanQual<Type> CanQualType;
 103
 104   // Provide forward declarations for all of the *Type classes
 105 #define TYPE(Class, Base) class Class##Type;
 106 #include "clang/AST/TypeNodes.def"
 107
 108 /// Qualifiers - The collection of all-type qualifiers we support.
 109 /// Clang supports five independent qualifiers:
 110 /// * C99: const, volatile, and restrict
 111 /// * Embedded C (TR18037): address spaces
 112 /// * Objective C: the GC attributes (none, weak, or strong)
 113 class Qualifiers {
 114 public:
 115   enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
 116     Const    = 0x1,
 117     Restrict = 0x2,
 118     Volatile = 0x4,
 119     CVRMask = Const | Volatile | Restrict
 120   };
 121
 122   enum GC {
 123     GCNone = 0,
 124     Weak,
 125     Strong
 126   };
 127
 128   enum ObjCLifetime {
 129     /// There is no lifetime qualification on this type.
 130     OCL_None,
 131
 132     /// This object can be modified without requiring retains or
 133     /// releases.
 134     OCL_ExplicitNone,
 135
 136     /// Assigning into this object requires the old value to be
 137     /// released and the new value to be retained.  The timing of the
 138     /// release of the old value is inexact: it may be moved to
 139     /// immediately after the last known point where the value is
 140     /// live.
 141     OCL_Strong,
 142
 143     /// Reading or writing from this object requires a barrier call.
 144     OCL_Weak,
 145
 146     /// Assigning into this object requires a lifetime extension.
 147     OCL_Autoreleasing
 148   };
 149
 150   enum {
 151     /// The maximum supported address space number.
 152     /// 24 bits should be enough for anyone.
 153     MaxAddressSpace = 0xffffffu,
 154
 155     /// The width of the "fast" qualifier mask.
 156     FastWidth = 3,
 157
 158     /// The fast qualifier mask.
 159     FastMask = (1 << FastWidth) - 1
 160   };
 161
 162   Qualifiers() : Mask(0) {}
 163
 164   /// \brief Returns the common set of qualifiers while removing them from
 165   /// the given sets.
 166   static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
 167     // If both are only CVR-qualified, bit operations are sufficient.
 168     if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
 169       Qualifiers Q;
 170       Q.Mask = L.Mask & R.Mask;
 171       L.Mask &= ~Q.Mask;
 172       R.Mask &= ~Q.Mask;
 173       return Q;
 174     }
 175
 176     Qualifiers Q;
 177     unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
 178     Q.addCVRQualifiers(CommonCRV);
 179     L.removeCVRQualifiers(CommonCRV);
 180     R.removeCVRQualifiers(CommonCRV);
 181
 182     if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
 183       Q.setObjCGCAttr(L.getObjCGCAttr());
 184       L.removeObjCGCAttr();
 185       R.removeObjCGCAttr();
 186     }
 187
 188     if (L.getObjCLifetime() == R.getObjCLifetime()) {
 189       Q.setObjCLifetime(L.getObjCLifetime());
 190       L.removeObjCLifetime();
 191       R.removeObjCLifetime();
 192     }
 193
 194     if (L.getAddressSpace() == R.getAddressSpace()) {
 195       Q.setAddressSpace(L.getAddressSpace());
 196       L.removeAddressSpace();
 197       R.removeAddressSpace();
 198     }
 199     return Q;
 200   }
 201
 202   static Qualifiers fromFastMask(unsigned Mask) {
 203     Qualifiers Qs;
 204     Qs.addFastQualifiers(Mask);
 205     return Qs;
 206   }
 207
 208   static Qualifiers fromCVRMask(unsigned CVR) {
 209     Qualifiers Qs;
 210     Qs.addCVRQualifiers(CVR);
 211     return Qs;
 212   }
 213
 214   // Deserialize qualifiers from an opaque representation.
 215   static Qualifiers fromOpaqueValue(unsigned opaque) {
 216     Qualifiers Qs;
 217     Qs.Mask = opaque;
 218     return Qs;
 219   }
 220
 221   // Serialize these qualifiers into an opaque representation.
 222   unsigned getAsOpaqueValue() const {
 223     return Mask;
 224   }
 225
 226   bool hasConst() const { return Mask & Const; }
 227   void setConst(bool flag) {
 228     Mask = (Mask & ~Const) | (flag ? Const : 0);
 229   }
 230   void removeConst() { Mask &= ~Const; }
 231   void addConst() { Mask |= Const; }
 232
 233   bool hasVolatile() const { return Mask & Volatile; }
 234   void setVolatile(bool flag) {
 235     Mask = (Mask & ~Volatile) | (flag ? Volatile : 0);
 236   }
 237   void removeVolatile() { Mask &= ~Volatile; }
 238   void addVolatile() { Mask |= Volatile; }
 239
 240   bool hasRestrict() const { return Mask & Restrict; }
 241   void setRestrict(bool flag) {
 242     Mask = (Mask & ~Restrict) | (flag ? Restrict : 0);
 243   }
 244   void removeRestrict() { Mask &= ~Restrict; }
 245   void addRestrict() { Mask |= Restrict; }
 246
 247   bool hasCVRQualifiers() const { return getCVRQualifiers(); }
 248   unsigned getCVRQualifiers() const { return Mask & CVRMask; }
 249   void setCVRQualifiers(unsigned mask) {
 250     assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits");
 251     Mask = (Mask & ~CVRMask) | mask;
 252   }
 253   void removeCVRQualifiers(unsigned mask) {
 254     assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits");
 255     Mask &= ~mask;
 256   }
 257   void removeCVRQualifiers() {
 258     removeCVRQualifiers(CVRMask);
 259   }
 260   void addCVRQualifiers(unsigned mask) {
 261     assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits");
 262     Mask |= mask;
 263   }
 264
 265   bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
 266   GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
 267   void setObjCGCAttr(GC type) {
 268     Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
 269   }
 270   void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
 271   void addObjCGCAttr(GC type) {
 272     assert(type);
 273     setObjCGCAttr(type);
 274   }
 275   Qualifiers withoutObjCGCAttr() const {
 276     Qualifiers qs = *this;
 277     qs.removeObjCGCAttr();
 278     return qs;
 279   }
 280   Qualifiers withoutObjCLifetime() const {
 281     Qualifiers qs = *this;
 282     qs.removeObjCLifetime();
 283     return qs;
 284   }
 285
 286   bool hasObjCLifetime() const { return Mask & LifetimeMask; }
 287   ObjCLifetime getObjCLifetime() const {
 288     return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
 289   }
 290   void setObjCLifetime(ObjCLifetime type) {
 291     Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
 292   }
 293   void removeObjCLifetime() { setObjCLifetime(OCL_None); }
 294   void addObjCLifetime(ObjCLifetime type) {
 295     assert(type);
 296     assert(!hasObjCLifetime());
 297     Mask |= (type << LifetimeShift);
 298   }
 299
 300   /// True if the lifetime is neither None or ExplicitNone.
 301   bool hasNonTrivialObjCLifetime() const {
 302     ObjCLifetime lifetime = getObjCLifetime();
 303     return (lifetime > OCL_ExplicitNone);
 304   }
 305
 306   /// True if the lifetime is either strong or weak.
 307   bool hasStrongOrWeakObjCLifetime() const {
 308     ObjCLifetime lifetime = getObjCLifetime();
 309     return (lifetime == OCL_Strong || lifetime == OCL_Weak);
 310   }
 311
 312   bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
 313   unsigned getAddressSpace() const { return Mask >> AddressSpaceShift; }
 314   void setAddressSpace(unsigned space) {
 315     assert(space <= MaxAddressSpace);
 316     Mask = (Mask & ~AddressSpaceMask)
 317          | (((uint32_t) space) << AddressSpaceShift);
 318   }
 319   void removeAddressSpace() { setAddressSpace(0); }
 320   void addAddressSpace(unsigned space) {
 321     assert(space);
 322     setAddressSpace(space);
 323   }
 324
 325   // Fast qualifiers are those that can be allocated directly
 326   // on a QualType object.
 327   bool hasFastQualifiers() const { return getFastQualifiers(); }
 328   unsigned getFastQualifiers() const { return Mask & FastMask; }
 329   void setFastQualifiers(unsigned mask) {
 330     assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits");
 331     Mask = (Mask & ~FastMask) | mask;
 332   }
 333   void removeFastQualifiers(unsigned mask) {
 334     assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits");
 335     Mask &= ~mask;
 336   }
 337   void removeFastQualifiers() {
 338     removeFastQualifiers(FastMask);
 339   }
 340   void addFastQualifiers(unsigned mask) {
 341     assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits");
 342     Mask |= mask;
 343   }
 344
 345   /// hasNonFastQualifiers - Return true if the set contains any
 346   /// qualifiers which require an ExtQuals node to be allocated.
 347   bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
 348   Qualifiers getNonFastQualifiers() const {
 349     Qualifiers Quals = *this;
 350     Quals.setFastQualifiers(0);
 351     return Quals;
 352   }
 353
 354   /// hasQualifiers - Return true if the set contains any qualifiers.
 355   bool hasQualifiers() const { return Mask; }
 356   bool empty() const { return !Mask; }
 357
 358   /// \brief Add the qualifiers from the given set to this set.
 359   void addQualifiers(Qualifiers Q) {
 360     // If the other set doesn't have any non-boolean qualifiers, just
 361     // bit-or it in.
 362     if (!(Q.Mask & ~CVRMask))
 363       Mask |= Q.Mask;
 364     else {
 365       Mask |= (Q.Mask & CVRMask);
 366       if (Q.hasAddressSpace())
 367         addAddressSpace(Q.getAddressSpace());
 368       if (Q.hasObjCGCAttr())
 369         addObjCGCAttr(Q.getObjCGCAttr());
 370       if (Q.hasObjCLifetime())
 371         addObjCLifetime(Q.getObjCLifetime());
 372     }
 373   }
 374
 375   /// \brief Remove the qualifiers from the given set from this set.
 376   void removeQualifiers(Qualifiers Q) {
 377     // If the other set doesn't have any non-boolean qualifiers, just
 378     // bit-and the inverse in.
 379     if (!(Q.Mask & ~CVRMask))
 380       Mask &= ~Q.Mask;
 381     else {
 382       Mask &= ~(Q.Mask & CVRMask);
 383       if (getObjCGCAttr() == Q.getObjCGCAttr())
 384         removeObjCGCAttr();
 385       if (getObjCLifetime() == Q.getObjCLifetime())
 386         removeObjCLifetime();
 387       if (getAddressSpace() == Q.getAddressSpace())
 388         removeAddressSpace();
 389     }
 390   }
 391
 392   /// \brief Add the qualifiers from the given set to this set, given that
 393   /// they don't conflict.
 394   void addConsistentQualifiers(Qualifiers qs) {
 395     assert(getAddressSpace() == qs.getAddressSpace() ||
 396            !hasAddressSpace() || !qs.hasAddressSpace());
 397     assert(getObjCGCAttr() == qs.getObjCGCAttr() ||
 398            !hasObjCGCAttr() || !qs.hasObjCGCAttr());
 399     assert(getObjCLifetime() == qs.getObjCLifetime() ||
 400            !hasObjCLifetime() || !qs.hasObjCLifetime());
 401     Mask |= qs.Mask;
 402   }
 403
 404   /// \brief Determines if these qualifiers compatibly include another set.
 405   /// Generally this answers the question of whether an object with the other
 406   /// qualifiers can be safely used as an object with these qualifiers.
 407   bool compatiblyIncludes(Qualifiers other) const {
 408     return
 409       // Address spaces must match exactly.
 410       getAddressSpace() == other.getAddressSpace() &&
 411       // ObjC GC qualifiers can match, be added, or be removed, but can't be
 412       // changed.
 413       (getObjCGCAttr() == other.getObjCGCAttr() ||
 414        !hasObjCGCAttr() || !other.hasObjCGCAttr()) &&
 415       // ObjC lifetime qualifiers must match exactly.
 416       getObjCLifetime() == other.getObjCLifetime() &&
 417       // CVR qualifiers may subset.
 418       (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask));
 419   }
 420
 421   /// \brief Determines if these qualifiers compatibly include another set of
 422   /// qualifiers from the narrow perspective of Objective-C ARC lifetime.
 423   ///
 424   /// One set of Objective-C lifetime qualifiers compatibly includes the other
 425   /// if the lifetime qualifiers match, or if both are non-__weak and the
 426   /// including set also contains the 'const' qualifier.
 427   bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
 428     if (getObjCLifetime() == other.getObjCLifetime())
 429       return true;
 430
 431     if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
 432       return false;
 433
 434     return hasConst();
 435   }
 436
 437   /// \brief Determine whether this set of qualifiers is a strict superset of
 438   /// another set of qualifiers, not considering qualifier compatibility.
 439   bool isStrictSupersetOf(Qualifiers Other) const;
 440
 441   bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
 442   bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }
 443
 444   operator bool() const { return hasQualifiers(); }
 445
 446   Qualifiers &operator+=(Qualifiers R) {
 447     addQualifiers(R);
 448     return *this;
 449   }
 450
 451   // Union two qualifier sets.  If an enumerated qualifier appears
 452   // in both sets, use the one from the right.
 453   friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
 454     L += R;
 455     return L;
 456   }
 457
 458   Qualifiers &operator-=(Qualifiers R) {
 459     removeQualifiers(R);
 460     return *this;
 461   }
 462
 463   /// \brief Compute the difference between two qualifier sets.
 464   friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
 465     L -= R;
 466     return L;
 467   }
 468
 469   std::string getAsString() const;
 470   std::string getAsString(const PrintingPolicy &Policy) const;
 471
 472   bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
 473   void print(raw_ostream &OS, const PrintingPolicy &Policy,
 474              bool appendSpaceIfNonEmpty = false) const;
 475
 476   void Profile(llvm::FoldingSetNodeID &ID) const {
 477     ID.AddInteger(Mask);
 478   }
 479
 480 private:
 481
 482   // bits:     |0 1 2|3 .. 4|5  ..  7|8   ...   31|
 483   //           |C R V|GCAttr|Lifetime|AddressSpace|
 484   uint32_t Mask;
 485
 486   static const uint32_t GCAttrMask = 0x18;
 487   static const uint32_t GCAttrShift = 3;
 488   static const uint32_t LifetimeMask = 0xE0;
 489   static const uint32_t LifetimeShift = 5;
 490   static const uint32_t AddressSpaceMask = ~(CVRMask|GCAttrMask|LifetimeMask);
 491   static const uint32_t AddressSpaceShift = 8;
 492 };
 493
 494 /// A std::pair-like structure for storing a qualified type split
 495 /// into its local qualifiers and its locally-unqualified type.
 496 struct SplitQualType {
 497   /// The locally-unqualified type.
 498   const Type *Ty;
 499
 500   /// The local qualifiers.
 501   Qualifiers Quals;
 502
 503   SplitQualType() : Ty(0), Quals() {}
 504   SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}
 505
 506   SplitQualType getSingleStepDesugaredType() const; // end of this file
 507
 508   // Make llvm::tie work.
 509   operator std::pair<const Type *,Qualifiers>() const {
 510     return std::pair<const Type *,Qualifiers>(Ty, Quals);
 511   }
 512
 513   friend bool operator==(SplitQualType a, SplitQualType b) {
 514     return a.Ty == b.Ty && a.Quals == b.Quals;
 515   }
 516   friend bool operator!=(SplitQualType a, SplitQualType b) {
 517     return a.Ty != b.Ty || a.Quals != b.Quals;
 518   }
 519 };
 520
 521 /// QualType - For efficiency, we don't store CV-qualified types as nodes on
 522 /// their own: instead each reference to a type stores the qualifiers.  This
 523 /// greatly reduces the number of nodes we need to allocate for types (for
 524 /// example we only need one for 'int', 'const int', 'volatile int',
 525 /// 'const volatile int', etc).
 526 ///
 527 /// As an added efficiency bonus, instead of making this a pair, we
 528 /// just store the two bits we care about in the low bits of the
 529 /// pointer.  To handle the packing/unpacking, we make QualType be a
 530 /// simple wrapper class that acts like a smart pointer.  A third bit
 531 /// indicates whether there are extended qualifiers present, in which
 532 /// case the pointer points to a special structure.
 533 class QualType {
 534   // Thankfully, these are efficiently composable.
 535   llvm::PointerIntPair<llvm::PointerUnion<const Type*,const ExtQuals*>,
 536                        Qualifiers::FastWidth> Value;
 537
 538   const ExtQuals *getExtQualsUnsafe() const {
 539     return Value.getPointer().get<const ExtQuals*>();
 540   }
 541
 542   const Type *getTypePtrUnsafe() const {
 543     return Value.getPointer().get<const Type*>();
 544   }
 545
 546   const ExtQualsTypeCommonBase *getCommonPtr() const {
 547     assert(!isNull() && "Cannot retrieve a NULL type pointer");
 548     uintptr_t CommonPtrVal
 549       = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
 550     CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
 551     return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
 552   }
 553
 554   friend class QualifierCollector;
 555 public:
 556   QualType() {}
 557
 558   QualType(const Type *Ptr, unsigned Quals)
 559     : Value(Ptr, Quals) {}
 560   QualType(const ExtQuals *Ptr, unsigned Quals)
 561     : Value(Ptr, Quals) {}
 562
 563   unsigned getLocalFastQualifiers() const { return Value.getInt(); }
 564   void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }
 565
 566   /// Retrieves a pointer to the underlying (unqualified) type.
 567   ///
 568   /// This function requires that the type not be NULL. If the type might be
 569   /// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
 570   const Type *getTypePtr() const;
 571
 572   const Type *getTypePtrOrNull() const;
 573
 574   /// Retrieves a pointer to the name of the base type.
 575   const IdentifierInfo *getBaseTypeIdentifier() const;
 576
 577   /// Divides a QualType into its unqualified type and a set of local
 578   /// qualifiers.
 579   SplitQualType split() const;
 580
 581   void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
 582   static QualType getFromOpaquePtr(const void *Ptr) {
 583     QualType T;
 584     T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
 585     return T;
 586   }
 587
 588   const Type &operator*() const {
 589     return *getTypePtr();
 590   }
 591
 592   const Type *operator->() const {
 593     return getTypePtr();
 594   }
 595
 596   bool isCanonical() const;
 597   bool isCanonicalAsParam() const;
 598
 599   /// isNull - Return true if this QualType doesn't point to a type yet.
 600   bool isNull() const {
 601     return Value.getPointer().isNull();
 602   }
 603
 604   /// \brief Determine whether this particular QualType instance has the
 605   /// "const" qualifier set, without looking through typedefs that may have
 606   /// added "const" at a different level.
 607   bool isLocalConstQualified() const {
 608     return (getLocalFastQualifiers() & Qualifiers::Const);
 609   }
 610
 611   /// \brief Determine whether this type is const-qualified.
 612   bool isConstQualified() const;
 613
 614   /// \brief Determine whether this particular QualType instance has the
 615   /// "restrict" qualifier set, without looking through typedefs that may have
 616   /// added "restrict" at a different level.
 617   bool isLocalRestrictQualified() const {
 618     return (getLocalFastQualifiers() & Qualifiers::Restrict);
 619   }
 620
 621   /// \brief Determine whether this type is restrict-qualified.
 622   bool isRestrictQualified() const;
 623
 624   /// \brief Determine whether this particular QualType instance has the
 625   /// "volatile" qualifier set, without looking through typedefs that may have
 626   /// added "volatile" at a different level.
 627   bool isLocalVolatileQualified() const {
 628     return (getLocalFastQualifiers() & Qualifiers::Volatile);
 629   }
 630
 631   /// \brief Determine whether this type is volatile-qualified.
 632   bool isVolatileQualified() const;
 633
 634   /// \brief Determine whether this particular QualType instance has any
 635   /// qualifiers, without looking through any typedefs that might add
 636   /// qualifiers at a different level.
 637   bool hasLocalQualifiers() const {
 638     return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
 639   }
 640
 641   /// \brief Determine whether this type has any qualifiers.
 642   bool hasQualifiers() const;
 643
 644   /// \brief Determine whether this particular QualType instance has any
 645   /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
 646   /// instance.
 647   bool hasLocalNonFastQualifiers() const {
 648     return Value.getPointer().is<const ExtQuals*>();
 649   }
 650
 651   /// \brief Retrieve the set of qualifiers local to this particular QualType
 652   /// instance, not including any qualifiers acquired through typedefs or
 653   /// other sugar.
 654   Qualifiers getLocalQualifiers() const;
 655
 656   /// \brief Retrieve the set of qualifiers applied to this type.
 657   Qualifiers getQualifiers() const;
 658
 659   /// \brief Retrieve the set of CVR (const-volatile-restrict) qualifiers
 660   /// local to this particular QualType instance, not including any qualifiers
 661   /// acquired through typedefs or other sugar.
 662   unsigned getLocalCVRQualifiers() const {
 663     return getLocalFastQualifiers();
 664   }
 665
 666   /// \brief Retrieve the set of CVR (const-volatile-restrict) qualifiers
 667   /// applied to this type.
 668   unsigned getCVRQualifiers() const;
 669
 670   bool isConstant(ASTContext& Ctx) const {
 671     return QualType::isConstant(*this, Ctx);
 672   }
 673
 674   /// \brief Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
 675   bool isPODType(ASTContext &Context) const;
 676
 677   /// isCXX98PODType() - Return true if this is a POD type according to the
 678   /// rules of the C++98 standard, regardless of the current compilation's
 679   /// language.
 680   bool isCXX98PODType(ASTContext &Context) const;
 681
 682   /// isCXX11PODType() - Return true if this is a POD type according to the
 683   /// more relaxed rules of the C++11 standard, regardless of the current
 684   /// compilation's language.
 685   /// (C++0x [basic.types]p9)
 686   bool isCXX11PODType(ASTContext &Context) const;
 687
 688   /// isTrivialType - Return true if this is a trivial type
 689   /// (C++0x [basic.types]p9)
 690   bool isTrivialType(ASTContext &Context) const;
 691
 692   /// isTriviallyCopyableType - Return true if this is a trivially
 693   /// copyable type (C++0x [basic.types]p9)
 694   bool isTriviallyCopyableType(ASTContext &Context) const;
 695
 696   // Don't promise in the API that anything besides 'const' can be
 697   // easily added.
 698
 699   /// addConst - add the specified type qualifier to this QualType.
 700   void addConst() {
 701     addFastQualifiers(Qualifiers::Const);
 702   }
 703   QualType withConst() const {
 704     return withFastQualifiers(Qualifiers::Const);
 705   }
 706
 707   /// addVolatile - add the specified type qualifier to this QualType.
 708   void addVolatile() {
 709     addFastQualifiers(Qualifiers::Volatile);
 710   }
 711   QualType withVolatile() const {
 712     return withFastQualifiers(Qualifiers::Volatile);
 713   }
 714
 715   /// Add the restrict qualifier to this QualType.
 716   void addRestrict() {
 717     addFastQualifiers(Qualifiers::Restrict);
 718   }
 719   QualType withRestrict() const {
 720     return withFastQualifiers(Qualifiers::Restrict);
 721   }
 722
 723   QualType withCVRQualifiers(unsigned CVR) const {
 724     return withFastQualifiers(CVR);
 725   }
 726
 727   void addFastQualifiers(unsigned TQs) {
 728     assert(!(TQs & ~Qualifiers::FastMask)
 729            && "non-fast qualifier bits set in mask!");
 730     Value.setInt(Value.getInt() | TQs);
 731   }
 732
 733   void removeLocalConst();
 734   void removeLocalVolatile();
 735   void removeLocalRestrict();
 736   void removeLocalCVRQualifiers(unsigned Mask);
 737
 738   void removeLocalFastQualifiers() { Value.setInt(0); }
 739   void removeLocalFastQualifiers(unsigned Mask) {
 740     assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers");
 741     Value.setInt(Value.getInt() & ~Mask);
 742   }
 743
 744   // Creates a type with the given qualifiers in addition to any
 745   // qualifiers already on this type.
 746   QualType withFastQualifiers(unsigned TQs) const {
 747     QualType T = *this;
 748     T.addFastQualifiers(TQs);
 749     return T;
 750   }
 751
 752   // Creates a type with exactly the given fast qualifiers, removing
 753   // any existing fast qualifiers.
 754   QualType withExactLocalFastQualifiers(unsigned TQs) const {
 755     return withoutLocalFastQualifiers().withFastQualifiers(TQs);
 756   }
 757
 758   // Removes fast qualifiers, but leaves any extended qualifiers in place.
 759   QualType withoutLocalFastQualifiers() const {
 760     QualType T = *this;
 761     T.removeLocalFastQualifiers();
 762     return T;
 763   }
 764
 765   QualType getCanonicalType() const;
 766
 767   /// \brief Return this type with all of the instance-specific qualifiers
 768   /// removed, but without removing any qualifiers that may have been applied
 769   /// through typedefs.
 770   QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }
 771
 772   /// \brief Retrieve the unqualified variant of the given type,
 773   /// removing as little sugar as possible.
 774   ///
 775   /// This routine looks through various kinds of sugar to find the
 776   /// least-desugared type that is unqualified. For example, given:
 777   ///
 778   /// \code
 779   /// typedef int Integer;
 780   /// typedef const Integer CInteger;
 781   /// typedef CInteger DifferenceType;
 782   /// \endcode
 783   ///
 784   /// Executing \c getUnqualifiedType() on the type \c DifferenceType will
 785   /// desugar until we hit the type \c Integer, which has no qualifiers on it.
 786   ///
 787   /// The resulting type might still be qualified if it's sugar for an array
 788   /// type.  To strip qualifiers even from within a sugared array type, use
 789   /// ASTContext::getUnqualifiedArrayType.
 790   inline QualType getUnqualifiedType() const;
 791
 792   /// getSplitUnqualifiedType - Retrieve the unqualified variant of the
 793   /// given type, removing as little sugar as possible.
 794   ///
 795   /// Like getUnqualifiedType(), but also returns the set of
 796   /// qualifiers that were built up.
 797   ///
 798   /// The resulting type might still be qualified if it's sugar for an array
 799   /// type.  To strip qualifiers even from within a sugared array type, use
 800   /// ASTContext::getUnqualifiedArrayType.
 801   inline SplitQualType getSplitUnqualifiedType() const;
 802
 803   /// \brief Determine whether this type is more qualified than the other
 804   /// given type, requiring exact equality for non-CVR qualifiers.
 805   bool isMoreQualifiedThan(QualType Other) const;
 806
 807   /// \brief Determine whether this type is at least as qualified as the other
 808   /// given type, requiring exact equality for non-CVR qualifiers.
 809   bool isAtLeastAsQualifiedAs(QualType Other) const;
 810
 811   QualType getNonReferenceType() const;
 812
 813   /// \brief Determine the type of a (typically non-lvalue) expression with the
 814   /// specified result type.
 815   ///
 816   /// This routine should be used for expressions for which the return type is
 817   /// explicitly specified (e.g., in a cast or call) and isn't necessarily
 818   /// an lvalue. It removes a top-level reference (since there are no
 819   /// expressions of reference type) and deletes top-level cvr-qualifiers
 820   /// from non-class types (in C++) or all types (in C).
 821   QualType getNonLValueExprType(ASTContext &Context) const;
 822
 823   /// getDesugaredType - Return the specified type with any "sugar" removed from
 824   /// the type.  This takes off typedefs, typeof's etc.  If the outer level of
 825   /// the type is already concrete, it returns it unmodified.  This is similar
 826   /// to getting the canonical type, but it doesn't remove *all* typedefs.  For
 827   /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
 828   /// concrete.
 829   ///
 830   /// Qualifiers are left in place.
 831   QualType getDesugaredType(const ASTContext &Context) const {
 832     return getDesugaredType(*this, Context);
 833   }
 834
 835   SplitQualType getSplitDesugaredType() const {
 836     return getSplitDesugaredType(*this);
 837   }
 838
 839   /// \brief Return the specified type with one level of "sugar" removed from
 840   /// the type.
 841   ///
 842   /// This routine takes off the first typedef, typeof, etc. If the outer level
 843   /// of the type is already concrete, it returns it unmodified.
 844   QualType getSingleStepDesugaredType(const ASTContext &Context) const {
 845     return getSingleStepDesugaredTypeImpl(*this, Context);
 846   }
 847
 848   /// IgnoreParens - Returns the specified type after dropping any
 849   /// outer-level parentheses.
 850   QualType IgnoreParens() const {
 851     if (isa<ParenType>(*this))
 852       return QualType::IgnoreParens(*this);
 853     return *this;
 854   }
 855
 856   /// operator==/!= - Indicate whether the specified types and qualifiers are
 857   /// identical.
 858   friend bool operator==(const QualType &LHS, const QualType &RHS) {
 859     return LHS.Value == RHS.Value;
 860   }
 861   friend bool operator!=(const QualType &LHS, const QualType &RHS) {
 862     return LHS.Value != RHS.Value;
 863   }
 864   std::string getAsString() const {
 865     return getAsString(split());
 866   }
 867   static std::string getAsString(SplitQualType split) {
 868     return getAsString(split.Ty, split.Quals);
 869   }
 870   static std::string getAsString(const Type *ty, Qualifiers qs);
 871
 872   std::string getAsString(const PrintingPolicy &Policy) const;
 873
 874   void print(raw_ostream &OS, const PrintingPolicy &Policy,
 875              const Twine &PlaceHolder = Twine()) const {
 876     print(split(), OS, Policy, PlaceHolder);
 877   }
 878   static void print(SplitQualType split, raw_ostream &OS,
 879                     const PrintingPolicy &policy, const Twine &PlaceHolder) {
 880     return print(split.Ty, split.Quals, OS, policy, PlaceHolder);
 881   }
 882   static void print(const Type *ty, Qualifiers qs,
 883                     raw_ostream &OS, const PrintingPolicy &policy,
 884                     const Twine &PlaceHolder);
 885
 886   void getAsStringInternal(std::string &Str,
 887                            const PrintingPolicy &Policy) const {
 888     return getAsStringInternal(split(), Str, Policy);
 889   }
 890   static void getAsStringInternal(SplitQualType split, std::string &out,
 891                                   const PrintingPolicy &policy) {
 892     return getAsStringInternal(split.Ty, split.Quals, out, policy);
 893   }
 894   static void getAsStringInternal(const Type *ty, Qualifiers qs,
 895                                   std::string &out,
 896                                   const PrintingPolicy &policy);
 897
 898   class StreamedQualTypeHelper {
 899     const QualType &T;
 900     const PrintingPolicy &Policy;
 901     const Twine &PlaceHolder;
 902   public:
 903     StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
 904                            const Twine &PlaceHolder)
 905       : T(T), Policy(Policy), PlaceHolder(PlaceHolder) { }
 906
 907     friend raw_ostream &operator<<(raw_ostream &OS,
 908                                    const StreamedQualTypeHelper &SQT) {
 909       SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder);
 910       return OS;
 911     }
 912   };
 913
 914   StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
 915                                 const Twine &PlaceHolder = Twine()) const {
 916     return StreamedQualTypeHelper(*this, Policy, PlaceHolder);
 917   }
 918
 919   void dump(const char *s) const;
 920   void dump() const;
 921
 922   void Profile(llvm::FoldingSetNodeID &ID) const {
 923     ID.AddPointer(getAsOpaquePtr());
 924   }
 925
 926   /// getAddressSpace - Return the address space of this type.
 927   inline unsigned getAddressSpace() const;
 928
 929   /// getObjCGCAttr - Returns gc attribute of this type.
 930   inline Qualifiers::GC getObjCGCAttr() const;
 931
 932   /// isObjCGCWeak true when Type is objc's weak.
 933   bool isObjCGCWeak() const {
 934     return getObjCGCAttr() == Qualifiers::Weak;
 935   }
 936
 937   /// isObjCGCStrong true when Type is objc's strong.
 938   bool isObjCGCStrong() const {
 939     return getObjCGCAttr() == Qualifiers::Strong;
 940   }
 941
 942   /// getObjCLifetime - Returns lifetime attribute of this type.
 943   Qualifiers::ObjCLifetime getObjCLifetime() const {
 944     return getQualifiers().getObjCLifetime();
 945   }
 946
 947   bool hasNonTrivialObjCLifetime() const {
 948     return getQualifiers().hasNonTrivialObjCLifetime();
 949   }
 950
 951   bool hasStrongOrWeakObjCLifetime() const {
 952     return getQualifiers().hasStrongOrWeakObjCLifetime();
 953   }
 954
 955   enum DestructionKind {
 956     DK_none,
 957     DK_cxx_destructor,
 958     DK_objc_strong_lifetime,
 959     DK_objc_weak_lifetime
 960   };
 961
 962   /// isDestructedType - nonzero if objects of this type require
 963   /// non-trivial work to clean up after.  Non-zero because it's
 964   /// conceivable that qualifiers (objc_gc(weak)?) could make
 965   /// something require destruction.
 966   DestructionKind isDestructedType() const {
 967     return isDestructedTypeImpl(*this);
 968   }
 969
 970   /// \brief Determine whether expressions of the given type are forbidden
 971   /// from being lvalues in C.
 972   ///
 973   /// The expression types that are forbidden to be lvalues are:
 974   ///   - 'void', but not qualified void
 975   ///   - function types
 976   ///
 977   /// The exact rule here is C99 6.3.2.1:
 978   ///   An lvalue is an expression with an object type or an incomplete
 979   ///   type other than void.
 980   bool isCForbiddenLValueType() const;
 981
 982 private:
 983   // These methods are implemented in a separate translation unit;
 984   // "static"-ize them to avoid creating temporary QualTypes in the
 985   // caller.
 986   static bool isConstant(QualType T, ASTContext& Ctx);
 987   static QualType getDesugaredType(QualType T, const ASTContext &Context);
 988   static SplitQualType getSplitDesugaredType(QualType T);
 989   static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
 990   static QualType getSingleStepDesugaredTypeImpl(QualType type,
 991                                                  const ASTContext &C);
 992   static QualType IgnoreParens(QualType T);
 993   static DestructionKind isDestructedTypeImpl(QualType type);
 994 };
 995
 996 } // end clang.
 997
 998 namespace llvm {
 999 /// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1000 /// to a specific Type class.
1001 template<> struct simplify_type< ::clang::QualType> {
1002   typedef const ::clang::Type *SimpleType;
1003   static SimpleType getSimplifiedValue(::clang::QualType Val) {
1004     return Val.getTypePtr();
1005   }
1006 };
1007
1008 // Teach SmallPtrSet that QualType is "basically a pointer".
1009 template<>
1010 class PointerLikeTypeTraits<clang::QualType> {
1011 public:
1012   static inline void *getAsVoidPointer(clang::QualType P) {
1013     return P.getAsOpaquePtr();
1014   }
1015   static inline clang::QualType getFromVoidPointer(void *P) {
1016     return clang::QualType::getFromOpaquePtr(P);
1017   }
1018   // Various qualifiers go in low bits.
1019   enum { NumLowBitsAvailable = 0 };
1020 };
1021
1022 } // end namespace llvm
1023
1024 namespace clang {
1025
1026 /// \brief Base class that is common to both the \c ExtQuals and \c Type
1027 /// classes, which allows \c QualType to access the common fields between the
1028 /// two.
1029 ///
1030 class ExtQualsTypeCommonBase {
1031   ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
1032     : BaseType(baseType), CanonicalType(canon) {}
1033
1034   /// \brief The "base" type of an extended qualifiers type (\c ExtQuals) or
1035   /// a self-referential pointer (for \c Type).
1036   ///
1037   /// This pointer allows an efficient mapping from a QualType to its
1038   /// underlying type pointer.
1039   const Type *const BaseType;
1040
1041   /// \brief The canonical type of this type.  A QualType.
1042   QualType CanonicalType;
1043
1044   friend class QualType;
1045   friend class Type;
1046   friend class ExtQuals;
1047 };
1048
1049 /// ExtQuals - We can encode up to four bits in the low bits of a
1050 /// type pointer, but there are many more type qualifiers that we want
1051 /// to be able to apply to an arbitrary type.  Therefore we have this
1052 /// struct, intended to be heap-allocated and used by QualType to
1053 /// store qualifiers.
1054 ///
1055 /// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1056 /// in three low bits on the QualType pointer; a fourth bit records whether
1057 /// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1058 /// Objective-C GC attributes) are much more rare.
1059 class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
1060   // NOTE: changing the fast qualifiers should be straightforward as
1061   // long as you don't make 'const' non-fast.
1062   // 1. Qualifiers:
1063   //    a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
1064   //       Fast qualifiers must occupy the low-order bits.
1065   //    b) Update Qualifiers::FastWidth and FastMask.
1066   // 2. QualType:
1067   //    a) Update is{Volatile,Restrict}Qualified(), defined inline.
1068   //    b) Update remove{Volatile,Restrict}, defined near the end of
1069   //       this header.
1070   // 3. ASTContext:
1071   //    a) Update get{Volatile,Restrict}Type.
1072
1073   /// Quals - the immutable set of qualifiers applied by this
1074   /// node;  always contains extended qualifiers.
1075   Qualifiers Quals;
1076
1077   ExtQuals *this_() { return this; }
1078
1079 public:
1080   ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
1081     : ExtQualsTypeCommonBase(baseType,
1082                              canon.isNull() ? QualType(this_(), 0) : canon),
1083       Quals(quals)
1084   {
1085     assert(Quals.hasNonFastQualifiers()
1086            && "ExtQuals created with no fast qualifiers");
1087     assert(!Quals.hasFastQualifiers()
1088            && "ExtQuals created with fast qualifiers");
1089   }
1090
1091   Qualifiers getQualifiers() const { return Quals; }
1092
1093   bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
1094   Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }
1095
1096   bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
1097   Qualifiers::ObjCLifetime getObjCLifetime() const {
1098     return Quals.getObjCLifetime();
1099   }
1100
1101   bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
1102   unsigned getAddressSpace() const { return Quals.getAddressSpace(); }
1103
1104   const Type *getBaseType() const { return BaseType; }
1105
1106 public:
1107   void Profile(llvm::FoldingSetNodeID &ID) const {
1108     Profile(ID, getBaseType(), Quals);
1109   }
1110   static void Profile(llvm::FoldingSetNodeID &ID,
1111                       const Type *BaseType,
1112                       Qualifiers Quals) {
1113     assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!");
1114     ID.AddPointer(BaseType);
1115     Quals.Profile(ID);
1116   }
1117 };
1118
1119 /// \brief The kind of C++0x ref-qualifier associated with a function type,
1120 /// which determines whether a member function's "this" object can be an
1121 /// lvalue, rvalue, or neither.
1122 enum RefQualifierKind {
1123   /// \brief No ref-qualifier was provided.
1124   RQ_None = 0,
1125   /// \brief An lvalue ref-qualifier was provided (\c &).
1126   RQ_LValue,
1127   /// \brief An rvalue ref-qualifier was provided (\c &&).
1128   RQ_RValue
1129 };
1130
1131 /// Type - This is the base class of the type hierarchy.  A central concept
1132 /// with types is that each type always has a canonical type.  A canonical type
1133 /// is the type with any typedef names stripped out of it or the types it
1134 /// references.  For example, consider:
1135 ///
1136 ///  typedef int  foo;
1137 ///  typedef foo* bar;
1138 ///    'int *'    'foo *'    'bar'
1139 ///
1140 /// There will be a Type object created for 'int'.  Since int is canonical, its
1141 /// canonicaltype pointer points to itself.  There is also a Type for 'foo' (a
1142 /// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
1143 /// there is a PointerType that represents 'int*', which, like 'int', is
1144 /// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
1145 /// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1146 /// is also 'int*'.
1147 ///
1148 /// Non-canonical types are useful for emitting diagnostics, without losing
1149 /// information about typedefs being used.  Canonical types are useful for type
1150 /// comparisons (they allow by-pointer equality tests) and useful for reasoning
1151 /// about whether something has a particular form (e.g. is a function type),
1152 /// because they implicitly, recursively, strip all typedefs out of a type.
1153 ///
1154 /// Types, once created, are immutable.
1155 ///
1156 class Type : public ExtQualsTypeCommonBase {
1157 public:
1158   enum TypeClass {
1159 #define TYPE(Class, Base) Class,
1160 #define LAST_TYPE(Class) TypeLast = Class,
1161 #define ABSTRACT_TYPE(Class, Base)
1162 #include "clang/AST/TypeNodes.def"
1163     TagFirst = Record, TagLast = Enum
1164   };
1165
1166 private:
1167   Type(const Type &) LLVM_DELETED_FUNCTION;
1168   void operator=(const Type &) LLVM_DELETED_FUNCTION;
1169
1170   /// Bitfields required by the Type class.
1171   class TypeBitfields {
1172     friend class Type;
1173     template <class T> friend class TypePropertyCache;
1174
1175     /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
1176     unsigned TC : 8;
1177
1178     /// Dependent - Whether this type is a dependent type (C++ [temp.dep.type]).
1179     unsigned Dependent : 1;
1180
1181     /// \brief Whether this type somehow involves a template parameter, even
1182     /// if the resolution of the type does not depend on a template parameter.
1183     unsigned InstantiationDependent : 1;
1184
1185     /// \brief Whether this type is a variably-modified type (C99 6.7.5).
1186     unsigned VariablyModified : 1;
1187
1188     /// \brief Whether this type contains an unexpanded parameter pack
1189     /// (for C++0x variadic templates).
1190     unsigned ContainsUnexpandedParameterPack : 1;
1191
1192     /// \brief True if the cache (i.e. the bitfields here starting with
1193     /// 'Cache') is valid.
1194     mutable unsigned CacheValid : 1;
1195
1196     /// \brief Linkage of this type.
1197     mutable unsigned CachedLinkage : 2;
1198
1199     /// \brief Whether this type involves and local or unnamed types.
1200     mutable unsigned CachedLocalOrUnnamed : 1;
1201
1202     /// \brief FromAST - Whether this type comes from an AST file.
1203     mutable unsigned FromAST : 1;
1204
1205     bool isCacheValid() const {
1206       return CacheValid;
1207     }
1208     Linkage getLinkage() const {
1209       assert(isCacheValid() && "getting linkage from invalid cache");
1210       return static_cast<Linkage>(CachedLinkage);
1211     }
1212     bool hasLocalOrUnnamedType() const {
1213       assert(isCacheValid() && "getting linkage from invalid cache");
1214       return CachedLocalOrUnnamed;
1215     }
1216   };
1217   enum { NumTypeBits = 19 };
1218
1219 protected:
1220   // These classes allow subclasses to somewhat cleanly pack bitfields
1221   // into Type.
1222
1223   class ArrayTypeBitfields {
1224     friend class ArrayType;
1225
1226     unsigned : NumTypeBits;
1227
1228     /// IndexTypeQuals - CVR qualifiers from declarations like
1229     /// 'int X[static restrict 4]'. For function parameters only.
1230     unsigned IndexTypeQuals : 3;
1231
1232     /// SizeModifier - storage class qualifiers from declarations like
1233     /// 'int X[static restrict 4]'. For function parameters only.
1234     /// Actually an ArrayType::ArraySizeModifier.
1235     unsigned SizeModifier : 3;
1236   };
1237
1238   class BuiltinTypeBitfields {
1239     friend class BuiltinType;
1240
1241     unsigned : NumTypeBits;
1242
1243     /// The kind (BuiltinType::Kind) of builtin type this is.
1244     unsigned Kind : 8;
1245   };
1246
1247   class FunctionTypeBitfields {
1248     friend class FunctionType;
1249
1250     unsigned : NumTypeBits;
1251
1252     /// Extra information which affects how the function is called, like
1253     /// regparm and the calling convention.
1254     unsigned ExtInfo : 9;
1255
1256     /// TypeQuals - Used only by FunctionProtoType, put here to pack with the
1257     /// other bitfields.
1258     /// The qualifiers are part of FunctionProtoType because...
1259     ///
1260     /// C++ 8.3.5p4: The return type, the parameter type list and the
1261     /// cv-qualifier-seq, [...], are part of the function type.
1262     unsigned TypeQuals : 3;
1263   };
1264
1265   class ObjCObjectTypeBitfields {
1266     friend class ObjCObjectType;
1267
1268     unsigned : NumTypeBits;
1269
1270     /// NumProtocols - The number of protocols stored directly on this
1271     /// object type.
1272     unsigned NumProtocols : 32 - NumTypeBits;
1273   };
1274
1275   class ReferenceTypeBitfields {
1276     friend class ReferenceType;
1277
1278     unsigned : NumTypeBits;
1279
1280     /// True if the type was originally spelled with an lvalue sigil.
1281     /// This is never true of rvalue references but can also be false
1282     /// on lvalue references because of C++0x [dcl.typedef]p9,
1283     /// as follows:
1284     ///
1285     ///   typedef int &ref;    // lvalue, spelled lvalue
1286     ///   typedef int &&rvref; // rvalue
1287     ///   ref &a;              // lvalue, inner ref, spelled lvalue
1288     ///   ref &&a;             // lvalue, inner ref
1289     ///   rvref &a;            // lvalue, inner ref, spelled lvalue
1290     ///   rvref &&a;           // rvalue, inner ref
1291     unsigned SpelledAsLValue : 1;
1292
1293     /// True if the inner type is a reference type.  This only happens
1294     /// in non-canonical forms.
1295     unsigned InnerRef : 1;
1296   };
1297
1298   class TypeWithKeywordBitfields {
1299     friend class TypeWithKeyword;
1300
1301     unsigned : NumTypeBits;
1302
1303     /// An ElaboratedTypeKeyword.  8 bits for efficient access.
1304     unsigned Keyword : 8;
1305   };
1306
1307   class VectorTypeBitfields {
1308     friend class VectorType;
1309
1310     unsigned : NumTypeBits;
1311
1312     /// VecKind - The kind of vector, either a generic vector type or some
1313     /// target-specific vector type such as for AltiVec or Neon.
1314     unsigned VecKind : 3;
1315
1316     /// NumElements - The number of elements in the vector.
1317     unsigned NumElements : 29 - NumTypeBits;
1318   };
1319
1320   class AttributedTypeBitfields {
1321     friend class AttributedType;
1322
1323     unsigned : NumTypeBits;
1324
1325     /// AttrKind - an AttributedType::Kind
1326     unsigned AttrKind : 32 - NumTypeBits;
1327   };
1328
1329   class AutoTypeBitfields {
1330     friend class AutoType;
1331
1332     unsigned : NumTypeBits;
1333
1334     /// Was this placeholder type spelled as 'decltype(auto)'?
1335     unsigned IsDecltypeAuto : 1;
1336   };
1337
1338   union {
1339     TypeBitfields TypeBits;
1340     ArrayTypeBitfields ArrayTypeBits;
1341     AttributedTypeBitfields AttributedTypeBits;
1342     AutoTypeBitfields AutoTypeBits;
1343     BuiltinTypeBitfields BuiltinTypeBits;
1344     FunctionTypeBitfields FunctionTypeBits;
1345     ObjCObjectTypeBitfields ObjCObjectTypeBits;
1346     ReferenceTypeBitfields ReferenceTypeBits;
1347     TypeWithKeywordBitfields TypeWithKeywordBits;
1348     VectorTypeBitfields VectorTypeBits;
1349   };
1350
1351 private:
1352   /// \brief Set whether this type comes from an AST file.
1353   void setFromAST(bool V = true) const {
1354     TypeBits.FromAST = V;
1355   }
1356
1357   template <class T> friend class TypePropertyCache;
1358
1359 protected:
1360   // silence VC++ warning C4355: 'this' : used in base member initializer list
1361   Type *this_() { return this; }
1362   Type(TypeClass tc, QualType canon, bool Dependent,
1363        bool InstantiationDependent, bool VariablyModified,
1364        bool ContainsUnexpandedParameterPack)
1365     : ExtQualsTypeCommonBase(this,
1366                              canon.isNull() ? QualType(this_(), 0) : canon) {
1367     TypeBits.TC = tc;
1368     TypeBits.Dependent = Dependent;
1369     TypeBits.InstantiationDependent = Dependent || InstantiationDependent;
1370     TypeBits.VariablyModified = VariablyModified;
1371     TypeBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
1372     TypeBits.CacheValid = false;
1373     TypeBits.CachedLocalOrUnnamed = false;
1374     TypeBits.CachedLinkage = NoLinkage;
1375     TypeBits.FromAST = false;
1376   }
1377   friend class ASTContext;
1378
1379   void setDependent(bool D = true) {
1380     TypeBits.Dependent = D;
1381     if (D)
1382       TypeBits.InstantiationDependent = true;
1383   }
1384   void setInstantiationDependent(bool D = true) {
1385     TypeBits.InstantiationDependent = D; }
1386   void setVariablyModified(bool VM = true) { TypeBits.VariablyModified = VM;
1387   }
1388   void setContainsUnexpandedParameterPack(bool PP = true) {
1389     TypeBits.ContainsUnexpandedParameterPack = PP;
1390   }
1391
1392 public:
1393   TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }
1394
1395   /// \brief Whether this type comes from an AST file.
1396   bool isFromAST() const { return TypeBits.FromAST; }
1397
1398   /// \brief Whether this type is or contains an unexpanded parameter
1399   /// pack, used to support C++0x variadic templates.
1400   ///
1401   /// A type that contains a parameter pack shall be expanded by the
1402   /// ellipsis operator at some point. For example, the typedef in the
1403   /// following example contains an unexpanded parameter pack 'T':
1404   ///
1405   /// \code
1406   /// template<typename ...T>
1407   /// struct X {
1408   ///   typedef T* pointer_types; // ill-formed; T is a parameter pack.
1409   /// };
1410   /// \endcode
1411   ///
1412   /// Note that this routine does not specify which
1413   bool containsUnexpandedParameterPack() const {
1414     return TypeBits.ContainsUnexpandedParameterPack;
1415   }
1416
1417   /// Determines if this type would be canonical if it had no further
1418   /// qualification.
1419   bool isCanonicalUnqualified() const {
1420     return CanonicalType == QualType(this, 0);
1421   }
1422
1423   /// Pull a single level of sugar off of this locally-unqualified type.
1424   /// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
1425   /// or QualType::getSingleStepDesugaredType(const ASTContext&).
1426   QualType getLocallyUnqualifiedSingleStepDesugaredType() const;
1427
1428   /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
1429   /// object types, function types, and incomplete types.
1430
1431   /// isIncompleteType - Return true if this is an incomplete type.
1432   /// A type that can describe objects, but which lacks information needed to
1433   /// determine its size (e.g. void, or a fwd declared struct). Clients of this
1434   /// routine will need to determine if the size is actually required.
1435   ///
1436   /// \brief Def If non-NULL, and the type refers to some kind of declaration
1437   /// that can be completed (such as a C struct, C++ class, or Objective-C
1438   /// class), will be set to the declaration.
1439   bool isIncompleteType(NamedDecl **Def = 0) const;
1440
1441   /// isIncompleteOrObjectType - Return true if this is an incomplete or object
1442   /// type, in other words, not a function type.
1443   bool isIncompleteOrObjectType() const {
1444     return !isFunctionType();
1445   }
1446
1447   /// \brief Determine whether this type is an object type.
1448   bool isObjectType() const {
1449     // C++ [basic.types]p8:
1450     //   An object type is a (possibly cv-qualified) type that is not a
1451     //   function type, not a reference type, and not a void type.
1452     return !isReferenceType() && !isFunctionType() && !isVoidType();
1453   }
1454
1455   /// isLiteralType - Return true if this is a literal type
1456   /// (C++11 [basic.types]p10)
1457   bool isLiteralType(ASTContext &Ctx) const;
1458
1459   /// \brief Test if this type is a standard-layout type.
1460   /// (C++0x [basic.type]p9)
1461   bool isStandardLayoutType() const;
1462
1463   /// Helper methods to distinguish type categories. All type predicates
1464   /// operate on the canonical type, ignoring typedefs and qualifiers.
1465
1466   /// isBuiltinType - returns true if the type is a builtin type.
1467   bool isBuiltinType() const;
1468
1469   /// isSpecificBuiltinType - Test for a particular builtin type.
1470   bool isSpecificBuiltinType(unsigned K) const;
1471
1472   /// isPlaceholderType - Test for a type which does not represent an
1473   /// actual type-system type but is instead used as a placeholder for
1474   /// various convenient purposes within Clang.  All such types are
1475   /// BuiltinTypes.
1476   bool isPlaceholderType() const;
1477   const BuiltinType *getAsPlaceholderType() const;
1478
1479   /// isSpecificPlaceholderType - Test for a specific placeholder type.
1480   bool isSpecificPlaceholderType(unsigned K) const;
1481
1482   /// isNonOverloadPlaceholderType - Test for a placeholder type
1483   /// other than Overload;  see BuiltinType::isNonOverloadPlaceholderType.
1484   bool isNonOverloadPlaceholderType() const;
1485
1486   /// isIntegerType() does *not* include complex integers (a GCC extension).
1487   /// isComplexIntegerType() can be used to test for complex integers.
1488   bool isIntegerType() const;     // C99 6.2.5p17 (int, char, bool, enum)
1489   bool isEnumeralType() const;
1490   bool isBooleanType() const;
1491   bool isCharType() const;
1492   bool isWideCharType() const;
1493   bool isChar16Type() const;
1494   bool isChar32Type() const;
1495   bool isAnyCharacterType() const;
1496   bool isIntegralType(ASTContext &Ctx) const;
1497
1498   /// \brief Determine whether this type is an integral or enumeration type.
1499   bool isIntegralOrEnumerationType() const;
1500   /// \brief Determine whether this type is an integral or unscoped enumeration
1501   /// type.
1502   bool isIntegralOrUnscopedEnumerationType() const;
1503
1504   /// Floating point categories.
1505   bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
1506   /// isComplexType() does *not* include complex integers (a GCC extension).
1507   /// isComplexIntegerType() can be used to test for complex integers.
1508   bool isComplexType() const;      // C99 6.2.5p11 (complex)
1509   bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
1510   bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
1511   bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
1512   bool isRealType() const;         // C99 6.2.5p17 (real floating + integer)
1513   bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
1514   bool isVoidType() const;         // C99 6.2.5p19
1515   bool isDerivedType() const;      // C99 6.2.5p20
1516   bool isScalarType() const;       // C99 6.2.5p21 (arithmetic + pointers)
1517   bool isAggregateType() const;
1518   bool isFundamentalType() const;
1519   bool isCompoundType() const;
1520
1521   // Type Predicates: Check to see if this type is structurally the specified
1522   // type, ignoring typedefs and qualifiers.
1523   bool isFunctionType() const;
1524   bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
1525   bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
1526   bool isPointerType() const;
1527   bool isAnyPointerType() const;   // Any C pointer or ObjC object pointer
1528   bool isBlockPointerType() const;
1529   bool isVoidPointerType() const;
1530   bool isReferenceType() const;
1531   bool isLValueReferenceType() const;
1532   bool isRValueReferenceType() const;
1533   bool isFunctionPointerType() const;
1534   bool isMemberPointerType() const;
1535   bool isMemberFunctionPointerType() const;
1536   bool isMemberDataPointerType() const;
1537   bool isArrayType() const;
1538   bool isConstantArrayType() const;
1539   bool isIncompleteArrayType() const;
1540   bool isVariableArrayType() const;
1541   bool isDependentSizedArrayType() const;
1542   bool isRecordType() const;
1543   bool isClassType() const;
1544   bool isStructureType() const;
1545   bool isInterfaceType() const;
1546   bool isStructureOrClassType() const;
1547   bool isUnionType() const;
1548   bool isComplexIntegerType() const;            // GCC _Complex integer type.
1549   bool isVectorType() const;                    // GCC vector type.
1550   bool isExtVectorType() const;                 // Extended vector type.
1551   bool isObjCObjectPointerType() const;         // pointer to ObjC object
1552   bool isObjCRetainableType() const;            // ObjC object or block pointer
1553   bool isObjCLifetimeType() const;              // (array of)* retainable type
1554   bool isObjCIndirectLifetimeType() const;      // (pointer to)* lifetime type
1555   bool isObjCNSObjectType() const;              // __attribute__((NSObject))
1556   // FIXME: change this to 'raw' interface type, so we can used 'interface' type
1557   // for the common case.
1558   bool isObjCObjectType() const;                // NSString or typeof(*(id)0)
1559   bool isObjCQualifiedInterfaceType() const;    // NSString<foo>
1560   bool isObjCQualifiedIdType() const;           // id<foo>
1561   bool isObjCQualifiedClassType() const;        // Class<foo>
1562   bool isObjCObjectOrInterfaceType() const;
1563   bool isObjCIdType() const;                    // id
1564   bool isObjCClassType() const;                 // Class
1565   bool isObjCSelType() const;                 // Class
1566   bool isObjCBuiltinType() const;               // 'id' or 'Class'
1567   bool isObjCARCBridgableType() const;
1568   bool isCARCBridgableType() const;
1569   bool isTemplateTypeParmType() const;          // C++ template type parameter
1570   bool isNullPtrType() const;                   // C++0x nullptr_t
1571   bool isAtomicType() const;                    // C11 _Atomic()
1572
1573   bool isImage1dT() const;                      // OpenCL image1d_t
1574   bool isImage1dArrayT() const;                 // OpenCL image1d_array_t
1575   bool isImage1dBufferT() const;                // OpenCL image1d_buffer_t
1576   bool isImage2dT() const;                      // OpenCL image2d_t
1577   bool isImage2dArrayT() const;                 // OpenCL image2d_array_t
1578   bool isImage3dT() const;                      // OpenCL image3d_t
1579
1580   bool isImageType() const;                     // Any OpenCL image type
1581
1582   bool isSamplerT() const;                      // OpenCL sampler_t
1583   bool isEventT() const;                        // OpenCL event_t
1584
1585   bool isOpenCLSpecificType() const;            // Any OpenCL specific type
1586
1587   /// Determines if this type, which must satisfy
1588   /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
1589   /// than implicitly __strong.
1590   bool isObjCARCImplicitlyUnretainedType() const;
1591
1592   /// Return the implicit lifetime for this type, which must not be dependent.
1593   Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;
1594
1595   enum ScalarTypeKind {
1596     STK_CPointer,
1597     STK_BlockPointer,
1598     STK_ObjCObjectPointer,
1599     STK_MemberPointer,
1600     STK_Bool,
1601     STK_Integral,
1602     STK_Floating,
1603     STK_IntegralComplex,
1604     STK_FloatingComplex
1605   };
1606   /// getScalarTypeKind - Given that this is a scalar type, classify it.
1607   ScalarTypeKind getScalarTypeKind() const;
1608
1609   /// isDependentType - Whether this type is a dependent type, meaning
1610   /// that its definition somehow depends on a template parameter
1611   /// (C++ [temp.dep.type]).
1612   bool isDependentType() const { return TypeBits.Dependent; }
1613
1614   /// \brief Determine whether this type is an instantiation-dependent type,
1615   /// meaning that the type involves a template parameter (even if the
1616   /// definition does not actually depend on the type substituted for that
1617   /// template parameter).
1618   bool isInstantiationDependentType() const {
1619     return TypeBits.InstantiationDependent;
1620   }
1621
1622   /// \brief Determine whether this type is an undeduced type, meaning that
1623   /// it somehow involves a C++11 'auto' type which has not yet been deduced.
1624   bool isUndeducedType() const;
1625
1626   /// \brief Whether this type is a variably-modified type (C99 6.7.5).
1627   bool isVariablyModifiedType() const { return TypeBits.VariablyModified; }
1628
1629   /// \brief Whether this type involves a variable-length array type
1630   /// with a definite size.
1631   bool hasSizedVLAType() const;
1632
1633   /// \brief Whether this type is or contains a local or unnamed type.
1634   bool hasUnnamedOrLocalType() const;
1635
1636   bool isOverloadableType() const;
1637
1638   /// \brief Determine wither this type is a C++ elaborated-type-specifier.
1639   bool isElaboratedTypeSpecifier() const;
1640
1641   bool canDecayToPointerType() const;
1642
1643   /// hasPointerRepresentation - Whether this type is represented
1644   /// natively as a pointer; this includes pointers, references, block
1645   /// pointers, and Objective-C interface, qualified id, and qualified
1646   /// interface types, as well as nullptr_t.
1647   bool hasPointerRepresentation() const;
1648
1649   /// hasObjCPointerRepresentation - Whether this type can represent
1650   /// an objective pointer type for the purpose of GC'ability
1651   bool hasObjCPointerRepresentation() const;
1652
1653   /// \brief Determine whether this type has an integer representation
1654   /// of some sort, e.g., it is an integer type or a vector.
1655   bool hasIntegerRepresentation() const;
1656
1657   /// \brief Determine whether this type has an signed integer representation
1658   /// of some sort, e.g., it is an signed integer type or a vector.
1659   bool hasSignedIntegerRepresentation() const;
1660
1661   /// \brief Determine whether this type has an unsigned integer representation
1662   /// of some sort, e.g., it is an unsigned integer type or a vector.
1663   bool hasUnsignedIntegerRepresentation() const;
1664
1665   /// \brief Determine whether this type has a floating-point representation
1666   /// of some sort, e.g., it is a floating-point type or a vector thereof.
1667   bool hasFloatingRepresentation() const;
1668
1669   // Type Checking Functions: Check to see if this type is structurally the
1670   // specified type, ignoring typedefs and qualifiers, and return a pointer to
1671   // the best type we can.
1672   const RecordType *getAsStructureType() const;
1673   /// NOTE: getAs*ArrayType are methods on ASTContext.
1674   const RecordType *getAsUnionType() const;
1675   const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
1676   // The following is a convenience method that returns an ObjCObjectPointerType
1677   // for object declared using an interface.
1678   const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
1679   const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
1680   const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
1681   const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;
1682
1683   /// \brief Retrieves the CXXRecordDecl that this type refers to, either
1684   /// because the type is a RecordType or because it is the injected-class-name
1685   /// type of a class template or class template partial specialization.
1686   CXXRecordDecl *getAsCXXRecordDecl() const;
1687
1688   /// If this is a pointer or reference to a RecordType, return the
1689   /// CXXRecordDecl that that type refers to.
1690   ///
1691   /// If this is not a pointer or reference, or the type being pointed to does
1692   /// not refer to a CXXRecordDecl, returns NULL.
1693   const CXXRecordDecl *getPointeeCXXRecordDecl() const;
1694
1695   /// \brief Get the AutoType whose type will be deduced for a variable with
1696   /// an initializer of this type. This looks through declarators like pointer
1697   /// types, but not through decltype or typedefs.
1698   AutoType *getContainedAutoType() const;
1699
1700   /// Member-template getAs<specific type>'.  Look through sugar for
1701   /// an instance of \<specific type>.   This scheme will eventually
1702   /// replace the specific getAsXXXX methods above.
1703   ///
1704   /// There are some specializations of this member template listed
1705   /// immediately following this class.
1706   template <typename T> const T *getAs() const;
1707
1708   /// A variant of getAs<> for array types which silently discards
1709   /// qualifiers from the outermost type.
1710   const ArrayType *getAsArrayTypeUnsafe() const;
1711
1712   /// Member-template castAs<specific type>.  Look through sugar for
1713   /// the underlying instance of \<specific type>.
1714   ///
1715   /// This method has the same relationship to getAs<T> as cast<T> has
1716   /// to dyn_cast<T>; which is to say, the underlying type *must*
1717   /// have the intended type, and this method will never return null.
1718   template <typename T> const T *castAs() const;
1719
1720   /// A variant of castAs<> for array type which silently discards
1721   /// qualifiers from the outermost type.
1722   const ArrayType *castAsArrayTypeUnsafe() const;
1723
1724   /// getBaseElementTypeUnsafe - Get the base element type of this
1725   /// type, potentially discarding type qualifiers.  This method
1726   /// should never be used when type qualifiers are meaningful.
1727   const Type *getBaseElementTypeUnsafe() const;
1728
1729   /// getArrayElementTypeNoTypeQual - If this is an array type, return the
1730   /// element type of the array, potentially with type qualifiers missing.
1731   /// This method should never be used when type qualifiers are meaningful.
1732   const Type *getArrayElementTypeNoTypeQual() const;
1733
1734   /// getPointeeType - If this is a pointer, ObjC object pointer, or block
1735   /// pointer, this returns the respective pointee.
1736   QualType getPointeeType() const;
1737
1738   /// getUnqualifiedDesugaredType() - Return the specified type with
1739   /// any "sugar" removed from the type, removing any typedefs,
1740   /// typeofs, etc., as well as any qualifiers.
1741   const Type *getUnqualifiedDesugaredType() const;
1742
1743   /// More type predicates useful for type checking/promotion
1744   bool isPromotableIntegerType() const; // C99 6.3.1.1p2
1745
1746   /// isSignedIntegerType - Return true if this is an integer type that is
1747   /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
1748   /// or an enum decl which has a signed representation.
1749   bool isSignedIntegerType() const;
1750
1751   /// isUnsignedIntegerType - Return true if this is an integer type that is
1752   /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
1753   /// or an enum decl which has an unsigned representation.
1754   bool isUnsignedIntegerType() const;
1755
1756   /// Determines whether this is an integer type that is signed or an
1757   /// enumeration types whose underlying type is a signed integer type.
1758   bool isSignedIntegerOrEnumerationType() const;
1759
1760   /// Determines whether this is an integer type that is unsigned or an
1761   /// enumeration types whose underlying type is a unsigned integer type.
1762   bool isUnsignedIntegerOrEnumerationType() const;
1763
1764   /// isConstantSizeType - Return true if this is not a variable sized type,
1765   /// according to the rules of C99 6.7.5p3.  It is not legal to call this on
1766   /// incomplete types.
1767   bool isConstantSizeType() const;
1768
1769   /// isSpecifierType - Returns true if this type can be represented by some
1770   /// set of type specifiers.
1771   bool isSpecifierType() const;
1772
1773   /// \brief Determine the linkage of this type.
1774   Linkage getLinkage() const;
1775
1776   /// \brief Determine the visibility of this type.
1777   Visibility getVisibility() const {
1778     return getLinkageAndVisibility().getVisibility();
1779   }
1780
1781   /// \brief Return true if the visibility was explicitly set is the code.
1782   bool isVisibilityExplicit() const {
1783     return getLinkageAndVisibility().isVisibilityExplicit();
1784   }
1785
1786   /// \brief Determine the linkage and visibility of this type.
1787   LinkageInfo getLinkageAndVisibility() const;
1788
1789   /// \brief True if the computed linkage is valid. Used for consistency
1790   /// checking. Should always return true.
1791   bool isLinkageValid() const;
1792
1793   const char *getTypeClassName() const;
1794
1795   QualType getCanonicalTypeInternal() const {
1796     return CanonicalType;
1797   }
1798   CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
1799   LLVM_ATTRIBUTE_USED void dump() const;
1800
1801   friend class ASTReader;
1802   friend class ASTWriter;
1803 };
1804
1805 /// \brief This will check for a TypedefType by removing any existing sugar
1806 /// until it reaches a TypedefType or a non-sugared type.
1807 template <> const TypedefType *Type::getAs() const;
1808
1809 /// \brief This will check for a TemplateSpecializationType by removing any
1810 /// existing sugar until it reaches a TemplateSpecializationType or a
1811 /// non-sugared type.
1812 template <> const TemplateSpecializationType *Type::getAs() const;
1813
1814 // We can do canonical leaf types faster, because we don't have to
1815 // worry about preserving child type decoration.
1816 #define TYPE(Class, Base)
1817 #define LEAF_TYPE(Class) \
1818 template <> inline const Class##Type *Type::getAs() const { \
1819   return dyn_cast<Class##Type>(CanonicalType); \
1820 } \
1821 template <> inline const Class##Type *Type::castAs() const { \
1822   return cast<Class##Type>(CanonicalType); \
1823 }
1824 #include "clang/AST/TypeNodes.def"
1825
1826
1827 /// BuiltinType - This class is used for builtin types like 'int'.  Builtin
1828 /// types are always canonical and have a literal name field.
1829 class BuiltinType : public Type {
1830 public:
1831   enum Kind {
1832 #define BUILTIN_TYPE(Id, SingletonId) Id,
1833 #define LAST_BUILTIN_TYPE(Id) LastKind = Id
1834 #include "clang/AST/BuiltinTypes.def"
1835   };
1836
1837 public:
1838   BuiltinType(Kind K)
1839     : Type(Builtin, QualType(), /*Dependent=*/(K == Dependent),
1840            /*InstantiationDependent=*/(K == Dependent),
1841            /*VariablyModified=*/false,
1842            /*Unexpanded paramter pack=*/false) {
1843     BuiltinTypeBits.Kind = K;
1844   }
1845
1846   Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
1847   StringRef getName(const PrintingPolicy &Policy) const;
1848   const char *getNameAsCString(const PrintingPolicy &Policy) const {
1849     // The StringRef is null-terminated.
1850     StringRef str = getName(Policy);
1851     assert(!str.empty() && str.data()[str.size()] == '\0');
1852     return str.data();
1853   }
1854
1855   bool isSugared() const { return false; }
1856   QualType desugar() const { return QualType(this, 0); }
1857
1858   bool isInteger() const {
1859     return getKind() >= Bool && getKind() <= Int128;
1860   }
1861
1862   bool isSignedInteger() const {
1863     return getKind() >= Char_S && getKind() <= Int128;
1864   }
1865
1866   bool isUnsignedInteger() const {
1867     return getKind() >= Bool && getKind() <= UInt128;
1868   }
1869
1870   bool isFloatingPoint() const {
1871     return getKind() >= Half && getKind() <= LongDouble;
1872   }
1873
1874   /// Determines whether the given kind corresponds to a placeholder type.
1875   static bool isPlaceholderTypeKind(Kind K) {
1876     return K >= Overload;
1877   }
1878
1879   /// Determines whether this type is a placeholder type, i.e. a type
1880   /// which cannot appear in arbitrary positions in a fully-formed
1881   /// expression.
1882   bool isPlaceholderType() const {
1883     return isPlaceholderTypeKind(getKind());
1884   }
1885
1886   /// Determines whether this type is a placeholder type other than
1887   /// Overload.  Most placeholder types require only syntactic
1888   /// information about their context in order to be resolved (e.g.
1889   /// whether it is a call expression), which means they can (and
1890   /// should) be resolved in an earlier "phase" of analysis.
1891   /// Overload expressions sometimes pick up further information
1892   /// from their context, like whether the context expects a
1893   /// specific function-pointer type, and so frequently need
1894   /// special treatment.
1895   bool isNonOverloadPlaceholderType() const {
1896     return getKind() > Overload;
1897   }
1898
1899   static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
1900 };
1901
1902 /// ComplexType - C99 6.2.5p11 - Complex values.  This supports the C99 complex
1903 /// types (_Complex float etc) as well as the GCC integer complex extensions.
1904 ///
1905 class ComplexType : public Type, public llvm::FoldingSetNode {
1906   QualType ElementType;
1907   ComplexType(QualType Element, QualType CanonicalPtr) :
1908     Type(Complex, CanonicalPtr, Element->isDependentType(),
1909          Element->isInstantiationDependentType(),
1910          Element->isVariablyModifiedType(),
1911          Element->containsUnexpandedParameterPack()),
1912     ElementType(Element) {
1913   }
1914   friend class ASTContext;  // ASTContext creates these.
1915
1916 public:
1917   QualType getElementType() const { return ElementType; }
1918
1919   bool isSugared() const { return false; }
1920   QualType desugar() const { return QualType(this, 0); }
1921
1922   void Profile(llvm::FoldingSetNodeID &ID) {
1923     Profile(ID, getElementType());
1924   }
1925   static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
1926     ID.AddPointer(Element.getAsOpaquePtr());
1927   }
1928
1929   static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
1930 };
1931
1932 /// ParenType - Sugar for parentheses used when specifying types.
1933 ///
1934 class ParenType : public Type, public llvm::FoldingSetNode {
1935   QualType Inner;
1936
1937   ParenType(QualType InnerType, QualType CanonType) :
1938     Type(Paren, CanonType, InnerType->isDependentType(),
1939          InnerType->isInstantiationDependentType(),
1940          InnerType->isVariablyModifiedType(),
1941          InnerType->containsUnexpandedParameterPack()),
1942     Inner(InnerType) {
1943   }
1944   friend class ASTContext;  // ASTContext creates these.
1945
1946 public:
1947
1948   QualType getInnerType() const { return Inner; }
1949
1950   bool isSugared() const { return true; }
1951   QualType desugar() const { return getInnerType(); }
1952
1953   void Profile(llvm::FoldingSetNodeID &ID) {
1954     Profile(ID, getInnerType());
1955   }
1956   static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
1957     Inner.Profile(ID);
1958   }
1959
1960   static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
1961 };
1962
1963 /// PointerType - C99 6.7.5.1 - Pointer Declarators.
1964 ///
1965 class PointerType : public Type, public llvm::FoldingSetNode {
1966   QualType PointeeType;
1967
1968   PointerType(QualType Pointee, QualType CanonicalPtr) :
1969     Type(Pointer, CanonicalPtr, Pointee->isDependentType(),
1970          Pointee->isInstantiationDependentType(),
1971          Pointee->isVariablyModifiedType(),
1972          Pointee->containsUnexpandedParameterPack()),
1973     PointeeType(Pointee) {
1974   }
1975   friend class ASTContext;  // ASTContext creates these.
1976
1977 public:
1978
1979   QualType getPointeeType() const { return PointeeType; }
1980
1981   bool isSugared() const { return false; }
1982   QualType desugar() const { return QualType(this, 0); }
1983
1984   void Profile(llvm::FoldingSetNodeID &ID) {
1985     Profile(ID, getPointeeType());
1986   }
1987   static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
1988     ID.AddPointer(Pointee.getAsOpaquePtr());
1989   }
1990
1991   static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
1992 };
1993
1994 /// BlockPointerType - pointer to a block type.
1995 /// This type is to represent types syntactically represented as
1996 /// "void (^)(int)", etc. Pointee is required to always be a function type.
1997 ///
1998 class BlockPointerType : public Type, public llvm::FoldingSetNode {
1999   QualType PointeeType;  // Block is some kind of pointer type
2000   BlockPointerType(QualType Pointee, QualType CanonicalCls) :
2001     Type(BlockPointer, CanonicalCls, Pointee->isDependentType(),
2002          Pointee->isInstantiationDependentType(),
2003          Pointee->isVariablyModifiedType(),
2004          Pointee->containsUnexpandedParameterPack()),
2005     PointeeType(Pointee) {
2006   }
2007   friend class ASTContext;  // ASTContext creates these.
2008
2009 public:
2010
2011   // Get the pointee type. Pointee is required to always be a function type.
2012   QualType getPointeeType() const { return PointeeType; }
2013
2014   bool isSugared() const { return false; }
2015   QualType desugar() const { return QualType(this, 0); }
2016
2017   void Profile(llvm::FoldingSetNodeID &ID) {
2018       Profile(ID, getPointeeType());
2019   }
2020   static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
2021       ID.AddPointer(Pointee.getAsOpaquePtr());
2022   }
2023
2024   static bool classof(const Type *T) {
2025     return T->getTypeClass() == BlockPointer;
2026   }
2027 };
2028
2029 /// ReferenceType - Base for LValueReferenceType and RValueReferenceType
2030 ///
2031 class ReferenceType : public Type, public llvm::FoldingSetNode {
2032   QualType PointeeType;
2033
2034 protected:
2035   ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
2036                 bool SpelledAsLValue) :
2037     Type(tc, CanonicalRef, Referencee->isDependentType(),
2038          Referencee->isInstantiationDependentType(),
2039          Referencee->isVariablyModifiedType(),
2040          Referencee->containsUnexpandedParameterPack()),
2041     PointeeType(Referencee)
2042   {
2043     ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
2044     ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
2045   }
2046
2047 public:
2048   bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
2049   bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }
2050
2051   QualType getPointeeTypeAsWritten() const { return PointeeType; }
2052   QualType getPointeeType() const {
2053     // FIXME: this might strip inner qualifiers; okay?
2054     const ReferenceType *T = this;
2055     while (T->isInnerRef())
2056       T = T->PointeeType->castAs<ReferenceType>();
2057     return T->PointeeType;
2058   }
2059
2060   void Profile(llvm::FoldingSetNodeID &ID) {
2061     Profile(ID, PointeeType, isSpelledAsLValue());
2062   }
2063   static void Profile(llvm::FoldingSetNodeID &ID,
2064                       QualType Referencee,
2065                       bool SpelledAsLValue) {
2066     ID.AddPointer(Referencee.getAsOpaquePtr());
2067     ID.AddBoolean(SpelledAsLValue);
2068   }
2069
2070   static bool classof(const Type *T) {
2071     return T->getTypeClass() == LValueReference ||
2072            T->getTypeClass() == RValueReference;
2073   }
2074 };
2075
2076 /// LValueReferenceType - C++ [dcl.ref] - Lvalue reference
2077 ///
2078 class LValueReferenceType : public ReferenceType {
2079   LValueReferenceType(QualType Referencee, QualType CanonicalRef,
2080                       bool SpelledAsLValue) :
2081     ReferenceType(LValueReference, Referencee, CanonicalRef, SpelledAsLValue)
2082   {}
2083   friend class ASTContext; // ASTContext creates these
2084 public:
2085   bool isSugared() const { return false; }
2086   QualType desugar() const { return QualType(this, 0); }
2087
2088   static bool classof(const Type *T) {
2089     return T->getTypeClass() == LValueReference;
2090   }
2091 };
2092
2093 /// RValueReferenceType - C++0x [dcl.ref] - Rvalue reference
2094 ///
2095 class RValueReferenceType : public ReferenceType {
2096   RValueReferenceType(QualType Referencee, QualType CanonicalRef) :
2097     ReferenceType(RValueReference, Referencee, CanonicalRef, false) {
2098   }
2099   friend class ASTContext; // ASTContext creates these
2100 public:
2101   bool isSugared() const { return false; }
2102   QualType desugar() const { return QualType(this, 0); }
2103
2104   static bool classof(const Type *T) {
2105     return T->getTypeClass() == RValueReference;
2106   }
2107 };
2108
2109 /// MemberPointerType - C++ 8.3.3 - Pointers to members
2110 ///
2111 class MemberPointerType : public Type, public llvm::FoldingSetNode {
2112   QualType PointeeType;
2113   /// The class of which the pointee is a member. Must ultimately be a
2114   /// RecordType, but could be a typedef or a template parameter too.
2115   const Type *Class;
2116
2117   MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr) :
2118     Type(MemberPointer, CanonicalPtr,
2119          Cls->isDependentType() || Pointee->isDependentType(),
2120          (Cls->isInstantiationDependentType() ||
2121           Pointee->isInstantiationDependentType()),
2122          Pointee->isVariablyModifiedType(),
2123          (Cls->containsUnexpandedParameterPack() ||
2124           Pointee->containsUnexpandedParameterPack())),
2125     PointeeType(Pointee), Class(Cls) {
2126   }
2127   friend class ASTContext; // ASTContext creates these.
2128
2129 public:
2130   QualType getPointeeType() const { return PointeeType; }
2131
2132   /// Returns true if the member type (i.e. the pointee type) is a
2133   /// function type rather than a data-member type.
2134   bool isMemberFunctionPointer() const {
2135     return PointeeType->isFunctionProtoType();
2136   }
2137
2138   /// Returns true if the member type (i.e. the pointee type) is a
2139   /// data type rather than a function type.
2140   bool isMemberDataPointer() const {
2141     return !PointeeType->isFunctionProtoType();
2142   }
2143
2144   const Type *getClass() const { return Class; }
2145
2146   bool isSugared() const { return false; }
2147   QualType desugar() const { return QualType(this, 0); }
2148
2149   void Profile(llvm::FoldingSetNodeID &ID) {
2150     Profile(ID, getPointeeType(), getClass());
2151   }
2152   static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
2153                       const Type *Class) {
2154     ID.AddPointer(Pointee.getAsOpaquePtr());
2155     ID.AddPointer(Class);
2156   }
2157
2158   static bool classof(const Type *T) {
2159     return T->getTypeClass() == MemberPointer;
2160   }
2161 };
2162
2163 /// ArrayType - C99 6.7.5.2 - Array Declarators.
2164 ///
2165 class ArrayType : public Type, public llvm::FoldingSetNode {
2166 public:
2167   /// ArraySizeModifier - Capture whether this is a normal array (e.g. int X[4])
2168   /// an array with a static size (e.g. int X[static 4]), or an array
2169   /// with a star size (e.g. int X[*]).
2170   /// 'static' is only allowed on function parameters.
2171   enum ArraySizeModifier {
2172     Normal, Static, Star
2173   };
2174 private:
2175   /// ElementType - The element type of the array.
2176   QualType ElementType;
2177
2178 protected:
2179   // C++ [temp.dep.type]p1:
2180   //   A type is dependent if it is...
2181   //     - an array type constructed from any dependent type or whose
2182   //       size is specified by a constant expression that is
2183   //       value-dependent,
2184   ArrayType(TypeClass tc, QualType et, QualType can,
2185             ArraySizeModifier sm, unsigned tq,
2186             bool ContainsUnexpandedParameterPack)
2187     : Type(tc, can, et->isDependentType() || tc == DependentSizedArray,
2188            et->isInstantiationDependentType() || tc == DependentSizedArray,
2189            (tc == VariableArray || et->isVariablyModifiedType()),
2190            ContainsUnexpandedParameterPack),
2191       ElementType(et) {
2192     ArrayTypeBits.IndexTypeQuals = tq;
2193     ArrayTypeBits.SizeModifier = sm;
2194   }
2195
2196   friend class ASTContext;  // ASTContext creates these.
2197
2198 public:
2199   QualType getElementType() const { return ElementType; }
2200   ArraySizeModifier getSizeModifier() const {
2201     return ArraySizeModifier(ArrayTypeBits.SizeModifier);
2202   }
2203   Qualifiers getIndexTypeQualifiers() const {
2204     return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
2205   }
2206   unsigned getIndexTypeCVRQualifiers() const {
2207     return ArrayTypeBits.IndexTypeQuals;
2208   }
2209
2210   static bool classof(const Type *T) {
2211     return T->getTypeClass() == ConstantArray ||
2212            T->getTypeClass() == VariableArray ||
2213            T->getTypeClass() == IncompleteArray ||
2214            T->getTypeClass() == DependentSizedArray;
2215   }
2216 };
2217
2218 /// ConstantArrayType - This class represents the canonical version of
2219 /// C arrays with a specified constant size.  For example, the canonical
2220 /// type for 'int A[4 + 4*100]' is a ConstantArrayType where the element
2221 /// type is 'int' and the size is 404.
2222 class ConstantArrayType : public ArrayType {
2223   llvm::APInt Size; // Allows us to unique the type.
2224
2225   ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
2226                     ArraySizeModifier sm, unsigned tq)
2227     : ArrayType(ConstantArray, et, can, sm, tq,
2228                 et->containsUnexpandedParameterPack()),
2229       Size(size) {}
2230 protected:
2231   ConstantArrayType(TypeClass tc, QualType et, QualType can,
2232                     const llvm::APInt &size, ArraySizeModifier sm, unsigned tq)
2233     : ArrayType(tc, et, can, sm, tq, et->containsUnexpandedParameterPack()),
2234       Size(size) {}
2235   friend class ASTContext;  // ASTContext creates these.
2236 public:
2237   const llvm::APInt &getSize() const { return Size; }
2238   bool isSugared() const { return false; }
2239   QualType desugar() const { return QualType(this, 0); }
2240
2241
2242   /// \brief Determine the number of bits required to address a member of
2243   // an array with the given element type and number of elements.
2244   static unsigned getNumAddressingBits(ASTContext &Context,
2245                                        QualType ElementType,
2246                                        const llvm::APInt &NumElements);
2247
2248   /// \brief Determine the maximum number of active bits that an array's size
2249   /// can require, which limits the maximum size of the array.
2250   static unsigned getMaxSizeBits(ASTContext &Context);
2251
2252   void Profile(llvm::FoldingSetNodeID &ID) {
2253     Profile(ID, getElementType(), getSize(),
2254             getSizeModifier(), getIndexTypeCVRQualifiers());
2255   }
2256   static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
2257                       const llvm::APInt &ArraySize, ArraySizeModifier SizeMod,
2258                       unsigned TypeQuals) {
2259     ID.AddPointer(ET.getAsOpaquePtr());
2260     ID.AddInteger(ArraySize.getZExtValue());
2261     ID.AddInteger(SizeMod);
2262     ID.AddInteger(TypeQuals);
2263   }
2264   static bool classof(const Type *T) {
2265     return T->getTypeClass() == ConstantArray;
2266   }
2267 };
2268
2269 /// IncompleteArrayType - This class represents C arrays with an unspecified
2270 /// size.  For example 'int A[]' has an IncompleteArrayType where the element
2271 /// type is 'int' and the size is unspecified.
2272 class IncompleteArrayType : public ArrayType {
2273
2274   IncompleteArrayType(QualType et, QualType can,
2275                       ArraySizeModifier sm, unsigned tq)
2276     : ArrayType(IncompleteArray, et, can, sm, tq,
2277                 et->containsUnexpandedParameterPack()) {}
2278   friend class ASTContext;  // ASTContext creates these.
2279 public:
2280   bool isSugared() const { return false; }
2281   QualType desugar() const { return QualType(this, 0); }
2282
2283   static bool classof(const Type *T) {
2284     return T->getTypeClass() == IncompleteArray;
2285   }
2286
2287   friend class StmtIteratorBase;
2288
2289   void Profile(llvm::FoldingSetNodeID &ID) {
2290     Profile(ID, getElementType(), getSizeModifier(),
2291             getIndexTypeCVRQualifiers());
2292   }
2293
2294   static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
2295                       ArraySizeModifier SizeMod, unsigned TypeQuals) {
2296     ID.AddPointer(ET.getAsOpaquePtr());
2297     ID.AddInteger(SizeMod);
2298     ID.AddInteger(TypeQuals);
2299   }
2300 };
2301
2302 /// VariableArrayType - This class represents C arrays with a specified size
2303 /// which is not an integer-constant-expression.  For example, 'int s[x+foo()]'.
2304 /// Since the size expression is an arbitrary expression, we store it as such.
2305 ///
2306 /// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
2307 /// should not be: two lexically equivalent variable array types could mean
2308 /// different things, for example, these variables do not have the same type
2309 /// dynamically:
2310 ///
2311 /// void foo(int x) {
2312 ///   int Y[x];
2313 ///   ++x;
2314 ///   int Z[x];
2315 /// }
2316 ///
2317 class VariableArrayType : public ArrayType {
2318   /// SizeExpr - An assignment expression. VLA's are only permitted within
2319   /// a function block.
2320   Stmt *SizeExpr;
2321   /// Brackets - The left and right array brackets.
2322   SourceRange Brackets;
2323
2324   VariableArrayType(QualType et, QualType can, Expr *e,
2325                     ArraySizeModifier sm, unsigned tq,
2326                     SourceRange brackets)
2327     : ArrayType(VariableArray, et, can, sm, tq,
2328                 et->containsUnexpandedParameterPack()),
2329       SizeExpr((Stmt*) e), Brackets(brackets) {}
2330   friend class ASTContext;  // ASTContext creates these.
2331
2332 public:
2333   Expr *getSizeExpr() const {
2334     // We use C-style casts instead of cast<> here because we do not wish
2335     // to have a dependency of Type.h on Stmt.h/Expr.h.
2336     return (Expr*) SizeExpr;
2337   }
2338   SourceRange getBracketsRange() const { return Brackets; }
2339   SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
2340   SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
2341
2342   bool isSugared() const { return false; }
2343   QualType desugar() const { return QualType(this, 0); }
2344
2345   static bool classof(const Type *T) {
2346     return T->getTypeClass() == VariableArray;
2347   }
2348
2349   friend class StmtIteratorBase;
2350
2351   void Profile(llvm::FoldingSetNodeID &ID) {
2352     llvm_unreachable("Cannot unique VariableArrayTypes.");
2353   }
2354 };
2355
2356 /// DependentSizedArrayType - This type represents an array type in
2357 /// C++ whose size is a value-dependent expression. For example:
2358 ///
2359 /// \code
2360 /// template<typename T, int Size>
2361 /// class array {
2362 ///   T data[Size];
2363 /// };
2364 /// \endcode
2365 ///
2366 /// For these types, we won't actually know what the array bound is
2367 /// until template instantiation occurs, at which point this will
2368 /// become either a ConstantArrayType or a VariableArrayType.
2369 class DependentSizedArrayType : public ArrayType {
2370   const ASTContext &Context;
2371
2372   /// \brief An assignment expression that will instantiate to the
2373   /// size of the array.
2374   ///
2375   /// The expression itself might be NULL, in which case the array
2376   /// type will have its size deduced from an initializer.
2377   Stmt *SizeExpr;
2378
2379   /// Brackets - The left and right array brackets.
2380   SourceRange Brackets;
2381
2382   DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
2383                           Expr *e, ArraySizeModifier sm, unsigned tq,
2384                           SourceRange brackets);
2385
2386   friend class ASTContext;  // ASTContext creates these.
2387
2388 public:
2389   Expr *getSizeExpr() const {
2390     // We use C-style casts instead of cast<> here because we do not wish
2391     // to have a dependency of Type.h on Stmt.h/Expr.h.
2392     return (Expr*) SizeExpr;
2393   }
2394   SourceRange getBracketsRange() const { return Brackets; }
2395   SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
2396   SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
2397
2398   bool isSugared() const { return false; }
2399   QualType desugar() const { return QualType(this, 0); }
2400
2401   static bool classof(const Type *T) {
2402     return T->getTypeClass() == DependentSizedArray;
2403   }
2404
2405   friend class StmtIteratorBase;
2406
2407
2408   void Profile(llvm::FoldingSetNodeID &ID) {
2409     Profile(ID, Context, getElementType(),
2410             getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
2411   }
2412
2413   static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
2414                       QualType ET, ArraySizeModifier SizeMod,
2415                       unsigned TypeQuals, Expr *E);
2416 };
2417
2418 /// DependentSizedExtVectorType - This type represent an extended vector type
2419 /// where either the type or size is dependent. For example:
2420 /// @code
2421 /// template<typename T, int Size>
2422 /// class vector {
2423 ///   typedef T __attribute__((ext_vector_type(Size))) type;
2424 /// }
2425 /// @endcode
2426 class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
2427   const ASTContext &Context;
2428   Expr *SizeExpr;
2429   /// ElementType - The element type of the array.
2430   QualType ElementType;
2431   SourceLocation loc;
2432
2433   DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
2434                               QualType can, Expr *SizeExpr, SourceLocation loc);
2435
2436   friend class ASTContext;
2437
2438 public:
2439   Expr *getSizeExpr() const { return SizeExpr; }
2440   QualType getElementType() const { return ElementType; }
2441   SourceLocation getAttributeLoc() const { return loc; }
2442
2443   bool isSugared() const { return false; }
2444   QualType desugar() const { return QualType(this, 0); }
2445
2446   static bool classof(const Type *T) {
2447     return T->getTypeClass() == DependentSizedExtVector;
2448   }
2449
2450   void Profile(llvm::FoldingSetNodeID &ID) {
2451     Profile(ID, Context, getElementType(), getSizeExpr());
2452   }
2453
2454   static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
2455                       QualType ElementType, Expr *SizeExpr);
2456 };
2457
2458
2459 /// VectorType - GCC generic vector type. This type is created using
2460 /// __attribute__((vector_size(n)), where "n" specifies the vector size in
2461 /// bytes; or from an Altivec __vector or vector declaration.
2462 /// Since the constructor takes the number of vector elements, the
2463 /// client is responsible for converting the size into the number of elements.
2464 class VectorType : public Type, public llvm::FoldingSetNode {
2465 public:
2466   enum VectorKind {
2467     GenericVector,  // not a target-specific vector type
2468     AltiVecVector,  // is AltiVec vector
2469     AltiVecPixel,   // is AltiVec 'vector Pixel'
2470     AltiVecBool,    // is AltiVec 'vector bool ...'
2471     NeonVector,     // is ARM Neon vector
2472     NeonPolyVector  // is ARM Neon polynomial vector
2473   };
2474 protected:
2475   /// ElementType - The element type of the vector.
2476   QualType ElementType;
2477
2478   VectorType(QualType vecType, unsigned nElements, QualType canonType,
2479              VectorKind vecKind);
2480
2481   VectorType(TypeClass tc, QualType vecType, unsigned nElements,
2482              QualType canonType, VectorKind vecKind);
2483
2484   friend class ASTContext;  // ASTContext creates these.
2485
2486 public:
2487
2488   QualType getElementType() const { return ElementType; }
2489   unsigned getNumElements() const { return VectorTypeBits.NumElements; }
2490
2491   bool isSugared() const { return false; }
2492   QualType desugar() const { return QualType(this, 0); }
2493
2494   VectorKind getVectorKind() const {
2495     return VectorKind(VectorTypeBits.VecKind);
2496   }
2497
2498   void Profile(llvm::FoldingSetNodeID &ID) {
2499     Profile(ID, getElementType(), getNumElements(),
2500             getTypeClass(), getVectorKind());
2501   }
2502   static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
2503                       unsigned NumElements, TypeClass TypeClass,
2504                       VectorKind VecKind) {
2505     ID.AddPointer(ElementType.getAsOpaquePtr());
2506     ID.AddInteger(NumElements);
2507     ID.AddInteger(TypeClass);
2508     ID.AddInteger(VecKind);
2509   }
2510
2511   static bool classof(const Type *T) {
2512     return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
2513   }
2514 };
2515
2516 /// ExtVectorType - Extended vector type. This type is created using
2517 /// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
2518 /// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
2519 /// class enables syntactic extensions, like Vector Components for accessing
2520 /// points, colors, and textures (modeled after OpenGL Shading Language).
2521 class ExtVectorType : public VectorType {
2522   ExtVectorType(QualType vecType, unsigned nElements, QualType canonType) :
2523     VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}
2524   friend class ASTContext;  // ASTContext creates these.
2525 public:
2526   static int getPointAccessorIdx(char c) {
2527     switch (c) {
2528     default: return -1;
2529     case 'x': return 0;
2530     case 'y': return 1;
2531     case 'z': return 2;
2532     case 'w': return 3;
2533     }
2534   }
2535   static int getNumericAccessorIdx(char c) {
2536     switch (c) {
2537       default: return -1;
2538       case '0': return 0;
2539       case '1': return 1;
2540       case '2': return 2;
2541       case '3': return 3;
2542       case '4': return 4;
2543       case '5': return 5;
2544       case '6': return 6;
2545       case '7': return 7;
2546       case '8': return 8;
2547       case '9': return 9;
2548       case 'A':
2549       case 'a': return 10;
2550       case 'B':
2551       case 'b': return 11;
2552       case 'C':
2553       case 'c': return 12;
2554       case 'D':
2555       case 'd': return 13;
2556       case 'E':
2557       case 'e': return 14;
2558       case 'F':
2559       case 'f': return 15;
2560     }
2561   }
2562
2563   static int getAccessorIdx(char c) {
2564     if (int idx = getPointAccessorIdx(c)+1) return idx-1;
2565     return getNumericAccessorIdx(c);
2566   }
2567
2568   bool isAccessorWithinNumElements(char c) const {
2569     if (int idx = getAccessorIdx(c)+1)
2570       return unsigned(idx-1) < getNumElements();
2571     return false;
2572   }
2573   bool isSugared() const { return false; }
2574   QualType desugar() const { return QualType(this, 0); }
2575
2576   static bool classof(const Type *T) {
2577     return T->getTypeClass() == ExtVector;
2578   }
2579 };
2580
2581 /// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
2582 /// class of FunctionNoProtoType and FunctionProtoType.
2583 ///
2584 class FunctionType : public Type {
2585   // The type returned by the function.
2586   QualType ResultType;
2587
2588  public:
2589   /// ExtInfo - A class which abstracts out some details necessary for
2590   /// making a call.
2591   ///
2592   /// It is not actually used directly for storing this information in
2593   /// a FunctionType, although FunctionType does currently use the
2594   /// same bit-pattern.
2595   ///
2596   // If you add a field (say Foo), other than the obvious places (both,
2597   // constructors, compile failures), what you need to update is
2598   // * Operator==
2599   // * getFoo
2600   // * withFoo
2601   // * functionType. Add Foo, getFoo.
2602   // * ASTContext::getFooType
2603   // * ASTContext::mergeFunctionTypes
2604   // * FunctionNoProtoType::Profile
2605   // * FunctionProtoType::Profile
2606   // * TypePrinter::PrintFunctionProto
2607   // * AST read and write
2608   // * Codegen
2609   class ExtInfo {
2610     // Feel free to rearrange or add bits, but if you go over 9,
2611     // you'll need to adjust both the Bits field below and
2612     // Type::FunctionTypeBitfields.
2613
2614     //   |  CC  |noreturn|produces|regparm|
2615     //   |0 .. 3|   4    |    5   | 6 .. 8|
2616     //
2617     // regparm is either 0 (no regparm attribute) or the regparm value+1.
2618     enum { CallConvMask = 0xF };
2619     enum { NoReturnMask = 0x10 };
2620     enum { ProducesResultMask = 0x20 };
2621     enum { RegParmMask = ~(CallConvMask | NoReturnMask | ProducesResultMask),
2622            RegParmOffset = 6 }; // Assumed to be the last field
2623
2624     uint16_t Bits;
2625
2626     ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
2627
2628     friend class FunctionType;
2629
2630    public:
2631     // Constructor with no defaults. Use this when you know that you
2632     // have all the elements (when reading an AST file for example).
2633     ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
2634             bool producesResult) {
2635       assert((!hasRegParm || regParm < 7) && "Invalid regparm value");
2636       Bits = ((unsigned) cc) |
2637              (noReturn ? NoReturnMask : 0) |
2638              (producesResult ? ProducesResultMask : 0) |
2639              (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0);
2640     }
2641
2642     // Constructor with all defaults. Use when for example creating a
2643     // function know to use defaults.
2644     ExtInfo() : Bits(0) {}
2645
2646     bool getNoReturn() const { return Bits & NoReturnMask; }
2647     bool getProducesResult() const { return Bits & ProducesResultMask; }
2648     bool getHasRegParm() const { return (Bits >> RegParmOffset) != 0; }
2649     unsigned getRegParm() const {
2650       unsigned RegParm = Bits >> RegParmOffset;
2651       if (RegParm > 0)
2652         --RegParm;
2653       return RegParm;
2654     }
2655     CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }
2656
2657     bool operator==(ExtInfo Other) const {
2658       return Bits == Other.Bits;
2659     }
2660     bool operator!=(ExtInfo Other) const {
2661       return Bits != Other.Bits;
2662     }
2663
2664     // Note that we don't have setters. That is by design, use
2665     // the following with methods instead of mutating these objects.
2666
2667     ExtInfo withNoReturn(bool noReturn) const {
2668       if (noReturn)
2669         return ExtInfo(Bits | NoReturnMask);
2670       else
2671         return ExtInfo(Bits & ~NoReturnMask);
2672     }
2673
2674     ExtInfo withProducesResult(bool producesResult) const {
2675       if (producesResult)
2676         return ExtInfo(Bits | ProducesResultMask);
2677       else
2678         return ExtInfo(Bits & ~ProducesResultMask);
2679     }
2680
2681     ExtInfo withRegParm(unsigned RegParm) const {
2682       assert(RegParm < 7 && "Invalid regparm value");
2683       return ExtInfo((Bits & ~RegParmMask) |
2684                      ((RegParm + 1) << RegParmOffset));
2685     }
2686
2687     ExtInfo withCallingConv(CallingConv cc) const {
2688       return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
2689     }
2690
2691     void Profile(llvm::FoldingSetNodeID &ID) const {
2692       ID.AddInteger(Bits);
2693     }
2694   };
2695
2696 protected:
2697   FunctionType(TypeClass tc, QualType res,
2698                unsigned typeQuals, QualType Canonical, bool Dependent,
2699                bool InstantiationDependent,
2700                bool VariablyModified, bool ContainsUnexpandedParameterPack,
2701                ExtInfo Info)
2702     : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified,
2703            ContainsUnexpandedParameterPack),
2704       ResultType(res) {
2705     FunctionTypeBits.ExtInfo = Info.Bits;
2706     FunctionTypeBits.TypeQuals = typeQuals;
2707   }
2708   unsigned getTypeQuals() const { return FunctionTypeBits.TypeQuals; }
2709
2710 public:
2711
2712   QualType getResultType() const { return ResultType; }
2713
2714   bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
2715   unsigned getRegParmType() const { return getExtInfo().getRegParm(); }
2716   /// \brief Determine whether this function type includes the GNU noreturn
2717   /// attribute. The C++11 [[noreturn]] attribute does not affect the function
2718   /// type.
2719   bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }
2720   CallingConv getCallConv() const { return getExtInfo().getCC(); }
2721   ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }
2722   bool isConst() const { return getTypeQuals() & Qualifiers::Const; }
2723   bool isVolatile() const { return getTypeQuals() & Qualifiers::Volatile; }
2724   bool isRestrict() const { return getTypeQuals() & Qualifiers::Restrict; }
2725
2726   /// \brief Determine the type of an expression that calls a function of
2727   /// this type.
2728   QualType getCallResultType(ASTContext &Context) const {
2729     return getResultType().getNonLValueExprType(Context);
2730   }
2731
2732   static StringRef getNameForCallConv(CallingConv CC);
2733
2734   static bool classof(const Type *T) {
2735     return T->getTypeClass() == FunctionNoProto ||
2736            T->getTypeClass() == FunctionProto;
2737   }
2738 };
2739
2740 /// FunctionNoProtoType - Represents a K&R-style 'int foo()' function, which has
2741 /// no information available about its arguments.
2742 class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
2743   FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
2744     : FunctionType(FunctionNoProto, Result, 0, Canonical,
2745                    /*Dependent=*/false, /*InstantiationDependent=*/false,
2746                    Result->isVariablyModifiedType(),
2747                    /*ContainsUnexpandedParameterPack=*/false, Info) {}
2748
2749   friend class ASTContext;  // ASTContext creates these.
2750
2751 public:
2752   // No additional state past what FunctionType provides.
2753
2754   bool isSugared() const { return false; }
2755   QualType desugar() const { return QualType(this, 0); }
2756
2757   void Profile(llvm::FoldingSetNodeID &ID) {
2758     Profile(ID, getResultType(), getExtInfo());
2759   }
2760   static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
2761                       ExtInfo Info) {
2762     Info.Profile(ID);
2763     ID.AddPointer(ResultType.getAsOpaquePtr());
2764   }
2765
2766   static bool classof(const Type *T) {
2767     return T->getTypeClass() == FunctionNoProto;
2768   }
2769 };
2770
2771 /// FunctionProtoType - Represents a prototype with argument type info, e.g.
2772 /// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
2773 /// arguments, not as having a single void argument. Such a type can have an
2774 /// exception specification, but this specification is not part of the canonical
2775 /// type.
2776 class FunctionProtoType : public FunctionType, public llvm::FoldingSetNode {
2777 public:
2778   /// ExtProtoInfo - Extra information about a function prototype.
2779   struct ExtProtoInfo {
2780     ExtProtoInfo() :
2781       Variadic(false), HasTrailingReturn(false), TypeQuals(0),
2782       ExceptionSpecType(EST_None), RefQualifier(RQ_None),
2783       NumExceptions(0), Exceptions(0), NoexceptExpr(0),
2784       ExceptionSpecDecl(0), ExceptionSpecTemplate(0),
2785       ConsumedArguments(0) {}
2786
2787     FunctionType::ExtInfo ExtInfo;
2788     bool Variadic : 1;
2789     bool HasTrailingReturn : 1;
2790     unsigned char TypeQuals;
2791     ExceptionSpecificationType ExceptionSpecType;
2792     RefQualifierKind RefQualifier;
2793     unsigned NumExceptions;
2794     const QualType *Exceptions;
2795     Expr *NoexceptExpr;
2796     FunctionDecl *ExceptionSpecDecl;
2797     FunctionDecl *ExceptionSpecTemplate;
2798     const bool *ConsumedArguments;
2799   };
2800
2801 private:
2802   /// \brief Determine whether there are any argument types that
2803   /// contain an unexpanded parameter pack.
2804   static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
2805                                                  unsigned numArgs) {
2806     for (unsigned Idx = 0; Idx < numArgs; ++Idx)
2807       if (ArgArray[Idx]->containsUnexpandedParameterPack())
2808         return true;
2809
2810     return false;
2811   }
2812
2813   FunctionProtoType(QualType result, ArrayRef<QualType> args,
2814                     QualType canonical, const ExtProtoInfo &epi);
2815
2816   /// NumArgs - The number of arguments this function has, not counting '...'.
2817   unsigned NumArgs : 15;
2818
2819   /// NumExceptions - The number of types in the exception spec, if any.
2820   unsigned NumExceptions : 9;
2821
2822   /// ExceptionSpecType - The type of exception specification this function has.
2823   unsigned ExceptionSpecType : 3;
2824
2825   /// HasAnyConsumedArgs - Whether this function has any consumed arguments.
2826   unsigned HasAnyConsumedArgs : 1;
2827
2828   /// Variadic - Whether the function is variadic.
2829   unsigned Variadic : 1;
2830
2831   /// HasTrailingReturn - Whether this function has a trailing return type.
2832   unsigned HasTrailingReturn : 1;
2833
2834   /// \brief The ref-qualifier associated with a \c FunctionProtoType.
2835   ///
2836   /// This is a value of type \c RefQualifierKind.
2837   unsigned RefQualifier : 2;
2838
2839   // ArgInfo - There is an variable size array after the class in memory that
2840   // holds the argument types.
2841
2842   // Exceptions - There is another variable size array after ArgInfo that
2843   // holds the exception types.
2844
2845   // NoexceptExpr - Instead of Exceptions, there may be a single Expr* pointing
2846   // to the expression in the noexcept() specifier.
2847
2848   // ExceptionSpecDecl, ExceptionSpecTemplate - Instead of Exceptions, there may
2849   // be a pair of FunctionDecl* pointing to the function which should be used to
2850   // instantiate this function type's exception specification, and the function
2851   // from which it should be instantiated.
2852
2853   // ConsumedArgs - A variable size array, following Exceptions
2854   // and of length NumArgs, holding flags indicating which arguments
2855   // are consumed.  This only appears if HasAnyConsumedArgs is true.
2856
2857   friend class ASTContext;  // ASTContext creates these.
2858
2859   const bool *getConsumedArgsBuffer() const {
2860     assert(hasAnyConsumedArgs());
2861
2862     // Find the end of the exceptions.
2863     Expr * const *eh_end = reinterpret_cast<Expr * const *>(arg_type_end());
2864     if (getExceptionSpecType() != EST_ComputedNoexcept)
2865       eh_end += NumExceptions;
2866     else
2867       eh_end += 1; // NoexceptExpr
2868
2869     return reinterpret_cast<const bool*>(eh_end);
2870   }
2871
2872 public:
2873   unsigned getNumArgs() const { return NumArgs; }
2874   QualType getArgType(unsigned i) const {
2875     assert(i < NumArgs && "Invalid argument number!");
2876     return arg_type_begin()[i];
2877   }
2878   ArrayRef<QualType> getArgTypes() const {
2879     return ArrayRef<QualType>(arg_type_begin(), arg_type_end());
2880   }
2881
2882   ExtProtoInfo getExtProtoInfo() const {
2883     ExtProtoInfo EPI;
2884     EPI.ExtInfo = getExtInfo();
2885     EPI.Variadic = isVariadic();
2886     EPI.HasTrailingReturn = hasTrailingReturn();
2887     EPI.ExceptionSpecType = getExceptionSpecType();
2888     EPI.TypeQuals = static_cast<unsigned char>(getTypeQuals());
2889     EPI.RefQualifier = getRefQualifier();
2890     if (EPI.ExceptionSpecType == EST_Dynamic) {
2891       EPI.NumExceptions = NumExceptions;
2892       EPI.Exceptions = exception_begin();
2893     } else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) {
2894       EPI.NoexceptExpr = getNoexceptExpr();
2895     } else if (EPI.ExceptionSpecType == EST_Uninstantiated) {
2896       EPI.ExceptionSpecDecl = getExceptionSpecDecl();
2897       EPI.ExceptionSpecTemplate = getExceptionSpecTemplate();
2898     } else if (EPI.ExceptionSpecType == EST_Unevaluated) {
2899       EPI.ExceptionSpecDecl = getExceptionSpecDecl();
2900     }
2901     if (hasAnyConsumedArgs())
2902       EPI.ConsumedArguments = getConsumedArgsBuffer();
2903     return EPI;
2904   }
2905
2906   /// \brief Get the kind of exception specification on this function.
2907   ExceptionSpecificationType getExceptionSpecType() const {
2908     return static_cast<ExceptionSpecificationType>(ExceptionSpecType);
2909   }
2910   /// \brief Return whether this function has any kind of exception spec.
2911   bool hasExceptionSpec() const {
2912     return getExceptionSpecType() != EST_None;
2913   }
2914   /// \brief Return whether this function has a dynamic (throw) exception spec.
2915   bool hasDynamicExceptionSpec() const {
2916     return isDynamicExceptionSpec(getExceptionSpecType());
2917   }
2918   /// \brief Return whether this function has a noexcept exception spec.
2919   bool hasNoexceptExceptionSpec() const {
2920     return isNoexceptExceptionSpec(getExceptionSpecType());
2921   }
2922   /// \brief Result type of getNoexceptSpec().
2923   enum NoexceptResult {
2924     NR_NoNoexcept,  ///< There is no noexcept specifier.
2925     NR_BadNoexcept, ///< The noexcept specifier has a bad expression.
2926     NR_Dependent,   ///< The noexcept specifier is dependent.
2927     NR_Throw,       ///< The noexcept specifier evaluates to false.
2928     NR_Nothrow      ///< The noexcept specifier evaluates to true.
2929   };
2930   /// \brief Get the meaning of the noexcept spec on this function, if any.
2931   NoexceptResult getNoexceptSpec(ASTContext &Ctx) const;
2932   unsigned getNumExceptions() const { return NumExceptions; }
2933   QualType getExceptionType(unsigned i) const {
2934     assert(i < NumExceptions && "Invalid exception number!");
2935     return exception_begin()[i];
2936   }
2937   Expr *getNoexceptExpr() const {
2938     if (getExceptionSpecType() != EST_ComputedNoexcept)
2939       return 0;
2940     // NoexceptExpr sits where the arguments end.
2941     return *reinterpret_cast<Expr *const *>(arg_type_end());
2942   }
2943   /// \brief If this function type has an exception specification which hasn't
2944   /// been determined yet (either because it has not been evaluated or because
2945   /// it has not been instantiated), this is the function whose exception
2946   /// specification is represented by this type.
2947   FunctionDecl *getExceptionSpecDecl() const {
2948     if (getExceptionSpecType() != EST_Uninstantiated &&
2949         getExceptionSpecType() != EST_Unevaluated)
2950       return 0;
2951     return reinterpret_cast<FunctionDecl * const *>(arg_type_end())[0];
2952   }
2953   /// \brief If this function type has an uninstantiated exception
2954   /// specification, this is the function whose exception specification
2955   /// should be instantiated to find the exception specification for
2956   /// this type.
2957   FunctionDecl *getExceptionSpecTemplate() const {
2958     if (getExceptionSpecType() != EST_Uninstantiated)
2959       return 0;
2960     return reinterpret_cast<FunctionDecl * const *>(arg_type_end())[1];
2961   }
2962   bool isNothrow(ASTContext &Ctx) const {
2963     ExceptionSpecificationType EST = getExceptionSpecType();
2964     assert(EST != EST_Unevaluated && EST != EST_Uninstantiated);
2965     if (EST == EST_DynamicNone || EST == EST_BasicNoexcept)
2966       return true;
2967     if (EST != EST_ComputedNoexcept)
2968       return false;
2969     return getNoexceptSpec(Ctx) == NR_Nothrow;
2970   }
2971
2972   bool isVariadic() const { return Variadic; }
2973
2974   /// \brief Determines whether this function prototype contains a
2975   /// parameter pack at the end.
2976   ///
2977   /// A function template whose last parameter is a parameter pack can be
2978   /// called with an arbitrary number of arguments, much like a variadic
2979   /// function.
2980   bool isTemplateVariadic() const;
2981
2982   bool hasTrailingReturn() const { return HasTrailingReturn; }
2983
2984   unsigned getTypeQuals() const { return FunctionType::getTypeQuals(); }
2985
2986
2987   /// \brief Retrieve the ref-qualifier associated with this function type.
2988   RefQualifierKind getRefQualifier() const {
2989     return static_cast<RefQualifierKind>(RefQualifier);
2990   }
2991
2992   typedef const QualType *arg_type_iterator;
2993   arg_type_iterator arg_type_begin() const {
2994     return reinterpret_cast<const QualType *>(this+1);
2995   }
2996   arg_type_iterator arg_type_end() const { return arg_type_begin()+NumArgs; }
2997
2998   typedef const QualType *exception_iterator;
2999   exception_iterator exception_begin() const {
3000     // exceptions begin where arguments end
3001     return arg_type_end();
3002   }
3003   exception_iterator exception_end() const {
3004     if (getExceptionSpecType() != EST_Dynamic)
3005       return exception_begin();
3006     return exception_begin() + NumExceptions;
3007   }
3008
3009   bool hasAnyConsumedArgs() const {
3010     return HasAnyConsumedArgs;
3011   }
3012   bool isArgConsumed(unsigned I) const {
3013     assert(I < getNumArgs() && "argument index out of range!");
3014     if (hasAnyConsumedArgs())
3015       return getConsumedArgsBuffer()[I];
3016     return false;
3017   }
3018
3019   bool isSugared() const { return false; }
3020   QualType desugar() const { return QualType(this, 0); }
3021
3022   void printExceptionSpecification(raw_ostream &OS,
3023                                    const PrintingPolicy &Policy) const;
3024
3025   static bool classof(const Type *T) {
3026     return T->getTypeClass() == FunctionProto;
3027   }
3028
3029   void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
3030   static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
3031                       arg_type_iterator ArgTys, unsigned NumArgs,
3032                       const ExtProtoInfo &EPI, const ASTContext &Context);
3033 };
3034
3035
3036 /// \brief Represents the dependent type named by a dependently-scoped
3037 /// typename using declaration, e.g.
3038 ///   using typename Base<T>::foo;
3039 /// Template instantiation turns these into the underlying type.
3040 class UnresolvedUsingType : public Type {
3041   UnresolvedUsingTypenameDecl *Decl;
3042
3043   UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
3044     : Type(UnresolvedUsing, QualType(), true, true, false,
3045            /*ContainsUnexpandedParameterPack=*/false),
3046       Decl(const_cast<UnresolvedUsingTypenameDecl*>(D)) {}
3047   friend class ASTContext; // ASTContext creates these.
3048 public:
3049
3050   UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }
3051
3052   bool isSugared() const { return false; }
3053   QualType desugar() const { return QualType(this, 0); }
3054
3055   static bool classof(const Type *T) {
3056     return T->getTypeClass() == UnresolvedUsing;
3057   }
3058
3059   void Profile(llvm::FoldingSetNodeID &ID) {
3060     return Profile(ID, Decl);
3061   }
3062   static void Profile(llvm::FoldingSetNodeID &ID,
3063                       UnresolvedUsingTypenameDecl *D) {
3064     ID.AddPointer(D);
3065   }
3066 };
3067
3068
3069 class TypedefType : public Type {
3070   TypedefNameDecl *Decl;
3071 protected:
3072   TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType can)
3073     : Type(tc, can, can->isDependentType(),
3074            can->isInstantiationDependentType(),
3075            can->isVariablyModifiedType(),
3076            /*ContainsUnexpandedParameterPack=*/false),
3077       Decl(const_cast<TypedefNameDecl*>(D)) {
3078     assert(!isa<TypedefType>(can) && "Invalid canonical type");
3079   }
3080   friend class ASTContext;  // ASTContext creates these.
3081 public:
3082
3083   TypedefNameDecl *getDecl() const { return Decl; }
3084
3085   bool isSugared() const { return true; }
3086   QualType desugar() const;
3087
3088   static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
3089 };
3090
3091 /// TypeOfExprType (GCC extension).
3092 class TypeOfExprType : public Type {
3093   Expr *TOExpr;
3094
3095 protected:
3096   TypeOfExprType(Expr *E, QualType can = QualType());
3097   friend class ASTContext;  // ASTContext creates these.
3098 public:
3099   Expr *getUnderlyingExpr() const { return TOExpr; }
3100
3101   /// \brief Remove a single level of sugar.
3102   QualType desugar() const;
3103
3104   /// \brief Returns whether this type directly provides sugar.
3105   bool isSugared() const;
3106
3107   static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
3108 };
3109
3110 /// \brief Internal representation of canonical, dependent
3111 /// typeof(expr) types.
3112 ///
3113 /// This class is used internally by the ASTContext to manage
3114 /// canonical, dependent types, only. Clients will only see instances
3115 /// of this class via TypeOfExprType nodes.
3116 class DependentTypeOfExprType
3117   : public TypeOfExprType, public llvm::FoldingSetNode {
3118   const ASTContext &Context;
3119
3120 public:
3121   DependentTypeOfExprType(const ASTContext &Context, Expr *E)
3122     : TypeOfExprType(E), Context(Context) { }
3123
3124   void Profile(llvm::FoldingSetNodeID &ID) {
3125     Profile(ID, Context, getUnderlyingExpr());
3126   }
3127
3128   static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3129                       Expr *E);
3130 };
3131
3132 /// TypeOfType (GCC extension).
3133 class TypeOfType : public Type {
3134   QualType TOType;
3135   TypeOfType(QualType T, QualType can)
3136     : Type(TypeOf, can, T->isDependentType(),
3137            T->isInstantiationDependentType(),
3138            T->isVariablyModifiedType(),
3139            T->containsUnexpandedParameterPack()),
3140       TOType(T) {
3141     assert(!isa<TypedefType>(can) && "Invalid canonical type");
3142   }
3143   friend class ASTContext;  // ASTContext creates these.
3144 public:
3145   QualType getUnderlyingType() const { return TOType; }
3146
3147   /// \brief Remove a single level of sugar.
3148   QualType desugar() const { return getUnderlyingType(); }
3149
3150   /// \brief Returns whether this type directly provides sugar.
3151   bool isSugared() const { return true; }
3152
3153   static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
3154 };
3155
3156 /// DecltypeType (C++0x)
3157 class DecltypeType : public Type {
3158   Expr *E;
3159   QualType UnderlyingType;
3160
3161 protected:
3162   DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());
3163   friend class ASTContext;  // ASTContext creates these.
3164 public:
3165   Expr *getUnderlyingExpr() const { return E; }
3166   QualType getUnderlyingType() const { return UnderlyingType; }
3167
3168   /// \brief Remove a single level of sugar.
3169   QualType desugar() const;
3170
3171   /// \brief Returns whether this type directly provides sugar.
3172   bool isSugared() const;
3173
3174   static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
3175 };
3176
3177 /// \brief Internal representation of canonical, dependent
3178 /// decltype(expr) types.
3179 ///
3180 /// This class is used internally by the ASTContext to manage
3181 /// canonical, dependent types, only. Clients will only see instances
3182 /// of this class via DecltypeType nodes.
3183 class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
3184   const ASTContext &Context;
3185
3186 public:
3187   DependentDecltypeType(const ASTContext &Context, Expr *E);
3188
3189   void Profile(llvm::FoldingSetNodeID &ID) {
3190     Profile(ID, Context, getUnderlyingExpr());
3191   }
3192
3193   static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3194                       Expr *E);
3195 };
3196
3197 /// \brief A unary type transform, which is a type constructed from another
3198 class UnaryTransformType : public Type {
3199 public:
3200   enum UTTKind {
3201     EnumUnderlyingType
3202   };
3203
3204 private:
3205   /// The untransformed type.
3206   QualType BaseType;
3207   /// The transformed type if not dependent, otherwise the same as BaseType.
3208   QualType UnderlyingType;
3209
3210   UTTKind UKind;
3211 protected:
3212   UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
3213                      QualType CanonicalTy);
3214   friend class ASTContext;
3215 public:
3216   bool isSugared() const { return !isDependentType(); }
3217   QualType desugar() const { return UnderlyingType; }
3218
3219   QualType getUnderlyingType() const { return UnderlyingType; }
3220   QualType getBaseType() const { return BaseType; }
3221
3222   UTTKind getUTTKind() const { return UKind; }
3223
3224   static bool classof(const Type *T) {
3225     return T->getTypeClass() == UnaryTransform;
3226   }
3227 };
3228
3229 class TagType : public Type {
3230   /// Stores the TagDecl associated with this type. The decl may point to any
3231   /// TagDecl that declares the entity.
3232   TagDecl * decl;
3233
3234   friend class ASTReader;
3235
3236 protected:
3237   TagType(TypeClass TC, const TagDecl *D, QualType can);
3238
3239 public:
3240   TagDecl *getDecl() const;
3241
3242   /// @brief Determines whether this type is in the process of being
3243   /// defined.
3244   bool isBeingDefined() const;
3245
3246   static bool classof(const Type *T) {
3247     return T->getTypeClass() >= TagFirst && T->getTypeClass() <= TagLast;
3248   }
3249 };
3250
3251 /// RecordType - This is a helper class that allows the use of isa/cast/dyncast
3252 /// to detect TagType objects of structs/unions/classes.
3253 class RecordType : public TagType {
3254 protected:
3255   explicit RecordType(const RecordDecl *D)
3256     : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) { }
3257   explicit RecordType(TypeClass TC, RecordDecl *D)
3258     : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) { }
3259   friend class ASTContext;   // ASTContext creates these.
3260 public:
3261
3262   RecordDecl *getDecl() const {
3263     return reinterpret_cast<RecordDecl*>(TagType::getDecl());
3264   }
3265
3266   // FIXME: This predicate is a helper to QualType/Type. It needs to
3267   // recursively check all fields for const-ness. If any field is declared
3268   // const, it needs to return false.
3269   bool hasConstFields() const { return false; }
3270
3271   bool isSugared() const { return false; }
3272   QualType desugar() const { return QualType(this, 0); }
3273
3274   static bool classof(const Type *T) { return T->getTypeClass() == Record; }
3275 };
3276
3277 /// EnumType - This is a helper class that allows the use of isa/cast/dyncast
3278 /// to detect TagType objects of enums.
3279 class EnumType : public TagType {
3280   explicit EnumType(const EnumDecl *D)
3281     : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) { }
3282   friend class ASTContext;   // ASTContext creates these.
3283 public:
3284
3285   EnumDecl *getDecl() const {
3286     return reinterpret_cast<EnumDecl*>(TagType::getDecl());
3287   }
3288
3289   bool isSugared() const { return false; }
3290   QualType desugar() const { return QualType(this, 0); }
3291
3292   static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
3293 };
3294
3295 /// AttributedType - An attributed type is a type to which a type
3296 /// attribute has been applied.  The "modified type" is the
3297 /// fully-sugared type to which the attributed type was applied;
3298 /// generally it is not canonically equivalent to the attributed type.
3299 /// The "equivalent type" is the minimally-desugared type which the
3300 /// type is canonically equivalent to.
3301 ///
3302 /// For example, in the following attributed type:
3303 ///     int32_t __attribute__((vector_size(16)))
3304 ///   - the modified type is the TypedefType for int32_t
3305 ///   - the equivalent type is VectorType(16, int32_t)
3306 ///   - the canonical type is VectorType(16, int)
3307 class AttributedType : public Type, public llvm::FoldingSetNode {
3308 public:
3309   // It is really silly to have yet another attribute-kind enum, but
3310   // clang::attr::Kind doesn't currently cover the pure type attrs.
3311   enum Kind {
3312     // Expression operand.
3313     attr_address_space,
3314     attr_regparm,
3315     attr_vector_size,
3316     attr_neon_vector_type,
3317     attr_neon_polyvector_type,
3318
3319     FirstExprOperandKind = attr_address_space,
3320     LastExprOperandKind = attr_neon_polyvector_type,
3321
3322     // Enumerated operand (string or keyword).
3323     attr_objc_gc,
3324     attr_objc_ownership,
3325     attr_pcs,
3326
3327     FirstEnumOperandKind = attr_objc_gc,
3328     LastEnumOperandKind = attr_pcs,
3329
3330     // No operand.
3331     attr_noreturn,
3332     attr_cdecl,
3333     attr_fastcall,
3334     attr_stdcall,
3335     attr_thiscall,
3336     attr_pascal,
3337     attr_pnaclcall,
3338     attr_inteloclbicc,
3339     attr_ms_abi,
3340     attr_sysv_abi
3341   };
3342
3343 private:
3344   QualType ModifiedType;
3345   QualType EquivalentType;
3346
3347   friend class ASTContext; // creates these
3348
3349   AttributedType(QualType canon, Kind attrKind,
3350                  QualType modified, QualType equivalent)
3351     : Type(Attributed, canon, canon->isDependentType(),
3352            canon->isInstantiationDependentType(),
3353            canon->isVariablyModifiedType(),
3354            canon->containsUnexpandedParameterPack()),
3355       ModifiedType(modified), EquivalentType(equivalent) {
3356     AttributedTypeBits.AttrKind = attrKind;
3357   }
3358
3359 public:
3360   Kind getAttrKind() const {
3361     return static_cast<Kind>(AttributedTypeBits.AttrKind);
3362   }
3363
3364   QualType getModifiedType() const { return ModifiedType; }
3365   QualType getEquivalentType() const { return EquivalentType; }
3366
3367   bool isSugared() const { return true; }
3368   QualType desugar() const { return getEquivalentType(); }
3369
3370   void Profile(llvm::FoldingSetNodeID &ID) {
3371     Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
3372   }
3373
3374   static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
3375                       QualType modified, QualType equivalent) {
3376     ID.AddInteger(attrKind);
3377     ID.AddPointer(modified.getAsOpaquePtr());
3378     ID.AddPointer(equivalent.getAsOpaquePtr());
3379   }
3380
3381   static bool classof(const Type *T) {
3382     return T->getTypeClass() == Attributed;
3383   }
3384 };
3385
3386 class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
3387   // Helper data collector for canonical types.
3388   struct CanonicalTTPTInfo {
3389     unsigned Depth : 15;
3390     unsigned ParameterPack : 1;
3391     unsigned Index : 16;
3392   };
3393
3394   union {
3395     // Info for the canonical type.
3396     CanonicalTTPTInfo CanTTPTInfo;
3397     // Info for the non-canonical type.
3398     TemplateTypeParmDecl *TTPDecl;
3399   };
3400
3401   /// Build a non-canonical type.
3402   TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
3403     : Type(TemplateTypeParm, Canon, /*Dependent=*/true,
3404            /*InstantiationDependent=*/true,
3405            /*VariablyModified=*/false,
3406            Canon->containsUnexpandedParameterPack()),
3407       TTPDecl(TTPDecl) { }
3408
3409   /// Build the canonical type.
3410   TemplateTypeParmType(unsigned D, unsigned I, bool PP)
3411     : Type(TemplateTypeParm, QualType(this, 0),
3412            /*Dependent=*/true,
3413            /*InstantiationDependent=*/true,
3414            /*VariablyModified=*/false, PP) {
3415     CanTTPTInfo.Depth = D;
3416     CanTTPTInfo.Index = I;
3417     CanTTPTInfo.ParameterPack = PP;
3418   }
3419
3420   friend class ASTContext;  // ASTContext creates these
3421
3422   const CanonicalTTPTInfo& getCanTTPTInfo() const {
3423     QualType Can = getCanonicalTypeInternal();
3424     return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
3425   }
3426
3427 public:
3428   unsigned getDepth() const { return getCanTTPTInfo().Depth; }
3429   unsigned getIndex() const { return getCanTTPTInfo().Index; }
3430   bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }
3431
3432   TemplateTypeParmDecl *getDecl() const {
3433     return isCanonicalUnqualified() ? 0 : TTPDecl;
3434   }
3435
3436   IdentifierInfo *getIdentifier() const;
3437
3438   bool isSugared() const { return false; }
3439   QualType desugar() const { return QualType(this, 0); }
3440
3441   void Profile(llvm::FoldingSetNodeID &ID) {
3442     Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
3443   }
3444
3445   static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
3446                       unsigned Index, bool ParameterPack,
3447                       TemplateTypeParmDecl *TTPDecl) {
3448     ID.AddInteger(Depth);
3449     ID.AddInteger(Index);
3450     ID.AddBoolean(ParameterPack);
3451     ID.AddPointer(TTPDecl);
3452   }
3453
3454   static bool classof(const Type *T) {
3455     return T->getTypeClass() == TemplateTypeParm;
3456   }
3457 };
3458
3459 /// \brief Represents the result of substituting a type for a template
3460 /// type parameter.
3461 ///
3462 /// Within an instantiated template, all template type parameters have
3463 /// been replaced with these.  They are used solely to record that a
3464 /// type was originally written as a template type parameter;
3465 /// therefore they are never canonical.
3466 class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
3467   // The original type parameter.
3468   const TemplateTypeParmType *Replaced;
3469
3470   SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
3471     : Type(SubstTemplateTypeParm, Canon, Canon->isDependentType(),
3472            Canon->isInstantiationDependentType(),
3473            Canon->isVariablyModifiedType(),
3474            Canon->containsUnexpandedParameterPack()),
3475       Replaced(Param) { }
3476
3477   friend class ASTContext;
3478
3479 public:
3480   /// Gets the template parameter that was substituted for.
3481   const TemplateTypeParmType *getReplacedParameter() const {
3482     return Replaced;
3483   }
3484
3485   /// Gets the type that was substituted for the template
3486   /// parameter.
3487   QualType getReplacementType() const {
3488     return getCanonicalTypeInternal();
3489   }
3490
3491   bool isSugared() const { return true; }
3492   QualType desugar() const { return getReplacementType(); }
3493
3494   void Profile(llvm::FoldingSetNodeID &ID) {
3495     Profile(ID, getReplacedParameter(), getReplacementType());
3496   }
3497   static void Profile(llvm::FoldingSetNodeID &ID,
3498                       const TemplateTypeParmType *Replaced,
3499                       QualType Replacement) {
3500     ID.AddPointer(Replaced);
3501     ID.AddPointer(Replacement.getAsOpaquePtr());
3502   }
3503
3504   static bool classof(const Type *T) {
3505     return T->getTypeClass() == SubstTemplateTypeParm;
3506   }
3507 };
3508
3509 /// \brief Represents the result of substituting a set of types for a template
3510 /// type parameter pack.
3511 ///
3512 /// When a pack expansion in the source code contains multiple parameter packs
3513 /// and those parameter packs correspond to different levels of template
3514 /// parameter lists, this type node is used to represent a template type
3515 /// parameter pack from an outer level, which has already had its argument pack
3516 /// substituted but that still lives within a pack expansion that itself
3517 /// could not be instantiated. When actually performing a substitution into
3518 /// that pack expansion (e.g., when all template parameters have corresponding
3519 /// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
3520 /// at the current pack substitution index.
3521 class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
3522   /// \brief The original type parameter.
3523   const TemplateTypeParmType *Replaced;
3524
3525   /// \brief A pointer to the set of template arguments that this
3526   /// parameter pack is instantiated with.
3527   const TemplateArgument *Arguments;
3528
3529   /// \brief The number of template arguments in \c Arguments.
3530   unsigned NumArguments;
3531
3532   SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
3533                                 QualType Canon,
3534                                 const TemplateArgument &ArgPack);
3535
3536   friend class ASTContext;
3537
3538 public:
3539   IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }
3540
3541   /// Gets the template parameter that was substituted for.
3542   const TemplateTypeParmType *getReplacedParameter() const {
3543     return Replaced;
3544   }
3545
3546   bool isSugared() const { return false; }
3547   QualType desugar() const { return QualType(this, 0); }
3548
3549   TemplateArgument getArgumentPack() const;
3550
3551   void Profile(llvm::FoldingSetNodeID &ID);
3552   static void Profile(llvm::FoldingSetNodeID &ID,
3553                       const TemplateTypeParmType *Replaced,
3554                       const TemplateArgument &ArgPack);
3555
3556   static bool classof(const Type *T) {
3557     return T->getTypeClass() == SubstTemplateTypeParmPack;
3558   }
3559 };
3560
3561 /// \brief Represents a C++11 auto or C++1y decltype(auto) type.
3562 ///
3563 /// These types are usually a placeholder for a deduced type. However, before
3564 /// the initializer is attached, or if the initializer is type-dependent, there
3565 /// is no deduced type and an auto type is canonical. In the latter case, it is
3566 /// also a dependent type.
3567 class AutoType : public Type, public llvm::FoldingSetNode {
3568   AutoType(QualType DeducedType, bool IsDecltypeAuto, bool IsDependent)
3569     : Type(Auto, DeducedType.isNull() ? QualType(this, 0) : DeducedType,
3570            /*Dependent=*/IsDependent, /*InstantiationDependent=*/IsDependent,
3571            /*VariablyModified=*/false, /*ContainsParameterPack=*/false) {
3572     assert((DeducedType.isNull() || !IsDependent) &&
3573            "auto deduced to dependent type");
3574     AutoTypeBits.IsDecltypeAuto = IsDecltypeAuto;
3575   }
3576
3577   friend class ASTContext;  // ASTContext creates these
3578
3579 public:
3580   bool isDecltypeAuto() const { return AutoTypeBits.IsDecltypeAuto; }
3581
3582   bool isSugared() const { return !isCanonicalUnqualified(); }
3583   QualType desugar() const { return getCanonicalTypeInternal(); }
3584
3585   /// \brief Get the type deduced for this auto type, or null if it's either
3586   /// not been deduced or was deduced to a dependent type.
3587   QualType getDeducedType() const {
3588     return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
3589   }
3590   bool isDeduced() const {
3591     return !isCanonicalUnqualified() || isDependentType();
3592   }
3593
3594   void Profile(llvm::FoldingSetNodeID &ID) {
3595     Profile(ID, getDeducedType(), isDecltypeAuto(), isDependentType());
3596   }
3597
3598   static void Profile(llvm::FoldingSetNodeID &ID, QualType Deduced,
3599                       bool IsDecltypeAuto, bool IsDependent) {
3600     ID.AddPointer(Deduced.getAsOpaquePtr());
3601     ID.AddBoolean(IsDecltypeAuto);
3602     ID.AddBoolean(IsDependent);
3603   }
3604
3605   static bool classof(const Type *T) {
3606     return T->getTypeClass() == Auto;
3607   }
3608 };
3609
3610 /// \brief Represents a type template specialization; the template
3611 /// must be a class template, a type alias template, or a template
3612 /// template parameter.  A template which cannot be resolved to one of
3613 /// these, e.g. because it is written with a dependent scope
3614 /// specifier, is instead represented as a
3615 /// @c DependentTemplateSpecializationType.
3616 ///
3617 /// A non-dependent template specialization type is always "sugar",
3618 /// typically for a @c RecordType.  For example, a class template
3619 /// specialization type of @c vector<int> will refer to a tag type for
3620 /// the instantiation @c std::vector<int, std::allocator<int>>
3621 ///
3622 /// Template specializations are dependent if either the template or
3623 /// any of the template arguments are dependent, in which case the
3624 /// type may also be canonical.
3625 ///
3626 /// Instances of this type are allocated with a trailing array of
3627 /// TemplateArguments, followed by a QualType representing the
3628 /// non-canonical aliased type when the template is a type alias
3629 /// template.
3630 class TemplateSpecializationType
3631   : public Type, public llvm::FoldingSetNode {
3632   /// \brief The name of the template being specialized.  This is
3633   /// either a TemplateName::Template (in which case it is a
3634   /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
3635   /// TypeAliasTemplateDecl*), a
3636   /// TemplateName::SubstTemplateTemplateParmPack, or a
3637   /// TemplateName::SubstTemplateTemplateParm (in which case the
3638   /// replacement must, recursively, be one of these).
3639   TemplateName Template;
3640
3641   /// \brief - The number of template arguments named in this class
3642   /// template specialization.
3643   unsigned NumArgs : 31;
3644
3645   /// \brief Whether this template specialization type is a substituted
3646   /// type alias.
3647   bool TypeAlias : 1;
3648
3649   TemplateSpecializationType(TemplateName T,
3650                              const TemplateArgument *Args,
3651                              unsigned NumArgs, QualType Canon,
3652                              QualType Aliased);
3653
3654   friend class ASTContext;  // ASTContext creates these
3655
3656 public:
3657   /// \brief Determine whether any of the given template arguments are
3658   /// dependent.
3659   static bool anyDependentTemplateArguments(const TemplateArgument *Args,
3660                                             unsigned NumArgs,
3661                                             bool &InstantiationDependent);
3662
3663   static bool anyDependentTemplateArguments(const TemplateArgumentLoc *Args,
3664                                             unsigned NumArgs,
3665                                             bool &InstantiationDependent);
3666
3667   static bool anyDependentTemplateArguments(const TemplateArgumentListInfo &,
3668                                             bool &InstantiationDependent);
3669
3670   /// \brief Print a template argument list, including the '<' and '>'
3671   /// enclosing the template arguments.
3672   static void PrintTemplateArgumentList(raw_ostream &OS,
3673                                         const TemplateArgument *Args,
3674                                         unsigned NumArgs,
3675                                         const PrintingPolicy &Policy,
3676                                         bool SkipBrackets = false);
3677
3678   static void PrintTemplateArgumentList(raw_ostream &OS,
3679                                         const TemplateArgumentLoc *Args,
3680                                         unsigned NumArgs,
3681                                         const PrintingPolicy &Policy);
3682
3683   static void PrintTemplateArgumentList(raw_ostream &OS,
3684                                         const TemplateArgumentListInfo &,
3685                                         const PrintingPolicy &Policy);
3686
3687   /// True if this template specialization type matches a current
3688   /// instantiation in the context in which it is found.
3689   bool isCurrentInstantiation() const {
3690     return isa<InjectedClassNameType>(getCanonicalTypeInternal());
3691   }
3692
3693   /// \brief Determine if this template specialization type is for a type alias
3694   /// template that has been substituted.
3695   ///
3696   /// Nearly every template specialization type whose template is an alias
3697   /// template will be substituted. However, this is not the case when
3698   /// the specialization contains a pack expansion but the template alias
3699   /// does not have a corresponding parameter pack, e.g.,
3700   ///
3701   /// \code
3702   /// template<typename T, typename U, typename V> struct S;
3703   /// template<typename T, typename U> using A = S<T, int, U>;
3704   /// template<typename... Ts> struct X {
3705   ///   typedef A<Ts...> type; // not a type alias
3706   /// };
3707   /// \endcode
3708   bool isTypeAlias() const { return TypeAlias; }
3709
3710   /// Get the aliased type, if this is a specialization of a type alias
3711   /// template.
3712   QualType getAliasedType() const {
3713     assert(isTypeAlias() && "not a type alias template specialization");
3714     return *reinterpret_cast<const QualType*>(end());
3715   }
3716
3717   typedef const TemplateArgument * iterator;
3718
3719   iterator begin() const { return getArgs(); }
3720   iterator end() const; // defined inline in TemplateBase.h
3721
3722   /// \brief Retrieve the name of the template that we are specializing.
3723   TemplateName getTemplateName() const { return Template; }
3724
3725   /// \brief Retrieve the template arguments.
3726   const TemplateArgument *getArgs() const {
3727     return reinterpret_cast<const TemplateArgument *>(this + 1);
3728   }
3729
3730   /// \brief Retrieve the number of template arguments.
3731   unsigned getNumArgs() const { return NumArgs; }
3732
3733   /// \brief Retrieve a specific template argument as a type.
3734   /// \pre @c isArgType(Arg)
3735   const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
3736
3737   bool isSugared() const {
3738     return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
3739   }
3740   QualType desugar() const { return getCanonicalTypeInternal(); }
3741
3742   void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
3743     Profile(ID, Template, getArgs(), NumArgs, Ctx);
3744     if (isTypeAlias())
3745       getAliasedType().Profile(ID);
3746   }
3747
3748   static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
3749                       const TemplateArgument *Args,
3750                       unsigned NumArgs,
3751                       const ASTContext &Context);
3752
3753   static bool classof(const Type *T) {
3754     return T->getTypeClass() == TemplateSpecialization;
3755   }
3756 };
3757
3758 /// \brief The injected class name of a C++ class template or class
3759 /// template partial specialization.  Used to record that a type was
3760 /// spelled with a bare identifier rather than as a template-id; the
3761 /// equivalent for non-templated classes is just RecordType.
3762 ///
3763 /// Injected class name types are always dependent.  Template
3764 /// instantiation turns these into RecordTypes.
3765 ///
3766 /// Injected class name types are always canonical.  This works
3767 /// because it is impossible to compare an injected class name type
3768 /// with the corresponding non-injected template type, for the same
3769 /// reason that it is impossible to directly compare template
3770 /// parameters from different dependent contexts: injected class name
3771 /// types can only occur within the scope of a particular templated
3772 /// declaration, and within that scope every template specialization
3773 /// will canonicalize to the injected class name (when appropriate
3774 /// according to the rules of the language).
3775 class InjectedClassNameType : public Type {
3776   CXXRecordDecl *Decl;
3777
3778   /// The template specialization which this type represents.
3779   /// For example, in
3780   ///   template <class T> class A { ... };
3781   /// this is A<T>, whereas in
3782   ///   template <class X, class Y> class A<B<X,Y> > { ... };
3783   /// this is A<B<X,Y> >.
3784   ///
3785   /// It is always unqualified, always a template specialization type,
3786   /// and always dependent.
3787   QualType InjectedType;
3788
3789   friend class ASTContext; // ASTContext creates these.
3790   friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
3791                           // currently suitable for AST reading, too much
3792                           // interdependencies.
3793   InjectedClassNameType(CXXRecordDecl *D, QualType TST)
3794     : Type(InjectedClassName, QualType(), /*Dependent=*/true,
3795            /*InstantiationDependent=*/true,
3796            /*VariablyModified=*/false,
3797            /*ContainsUnexpandedParameterPack=*/false),
3798       Decl(D), InjectedType(TST) {
3799     assert(isa<TemplateSpecializationType>(TST));
3800     assert(!TST.hasQualifiers());
3801     assert(TST->isDependentType());
3802   }
3803
3804 public:
3805   QualType getInjectedSpecializationType() const { return InjectedType; }
3806   const TemplateSpecializationType *getInjectedTST() const {
3807     return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
3808   }
3809
3810   CXXRecordDecl *getDecl() const;
3811
3812   bool isSugared() const { return false; }
3813   QualType desugar() const { return QualType(this, 0); }
3814
3815   static bool classof(const Type *T) {
3816     return T->getTypeClass() == InjectedClassName;
3817   }
3818 };
3819
3820 /// \brief The kind of a tag type.
3821 enum TagTypeKind {
3822   /// \brief The "struct" keyword.
3823   TTK_Struct,
3824   /// \brief The "__interface" keyword.
3825   TTK_Interface,
3826   /// \brief The "union" keyword.
3827   TTK_Union,
3828   /// \brief The "class" keyword.
3829   TTK_Class,
3830   /// \brief The "enum" keyword.
3831   TTK_Enum
3832 };
3833
3834 /// \brief The elaboration keyword that precedes a qualified type name or
3835 /// introduces an elaborated-type-specifier.
3836 enum ElaboratedTypeKeyword {
3837   /// \brief The "struct" keyword introduces the elaborated-type-specifier.
3838   ETK_Struct,
3839   /// \brief The "__interface" keyword introduces the elaborated-type-specifier.
3840   ETK_Interface,
3841   /// \brief The "union" keyword introduces the elaborated-type-specifier.
3842   ETK_Union,
3843   /// \brief The "class" keyword introduces the elaborated-type-specifier.
3844   ETK_Class,
3845   /// \brief The "enum" keyword introduces the elaborated-type-specifier.
3846   ETK_Enum,
3847   /// \brief The "typename" keyword precedes the qualified type name, e.g.,
3848   /// \c typename T::type.
3849   ETK_Typename,
3850   /// \brief No keyword precedes the qualified type name.
3851   ETK_None
3852 };
3853
3854 /// A helper class for Type nodes having an ElaboratedTypeKeyword.
3855 /// The keyword in stored in the free bits of the base class.
3856 /// Also provides a few static helpers for converting and printing
3857 /// elaborated type keyword and tag type kind enumerations.
3858 class TypeWithKeyword : public Type {
3859 protected:
3860   TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
3861                   QualType Canonical, bool Dependent,
3862                   bool InstantiationDependent, bool VariablyModified,
3863                   bool ContainsUnexpandedParameterPack)
3864   : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified,
3865          ContainsUnexpandedParameterPack) {
3866     TypeWithKeywordBits.Keyword = Keyword;
3867   }
3868
3869 public:
3870   ElaboratedTypeKeyword getKeyword() const {
3871     return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
3872   }
3873
3874   /// getKeywordForTypeSpec - Converts a type specifier (DeclSpec::TST)
3875   /// into an elaborated type keyword.
3876   static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);
3877
3878   /// getTagTypeKindForTypeSpec - Converts a type specifier (DeclSpec::TST)
3879   /// into a tag type kind.  It is an error to provide a type specifier
3880   /// which *isn't* a tag kind here.
3881   static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);
3882
3883   /// getKeywordForTagDeclKind - Converts a TagTypeKind into an
3884   /// elaborated type keyword.
3885   static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);
3886
3887   /// getTagTypeKindForKeyword - Converts an elaborated type keyword into
3888   // a TagTypeKind. It is an error to provide an elaborated type keyword
3889   /// which *isn't* a tag kind here.
3890   static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword);
3891
3892   static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword);
3893
3894   static const char *getKeywordName(ElaboratedTypeKeyword Keyword);
3895
3896   static const char *getTagTypeKindName(TagTypeKind Kind) {
3897     return getKeywordName(getKeywordForTagTypeKind(Kind));
3898   }
3899
3900   class CannotCastToThisType {};
3901   static CannotCastToThisType classof(const Type *);
3902 };
3903
3904 /// \brief Represents a type that was referred to using an elaborated type
3905 /// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
3906 /// or both.
3907 ///
3908 /// This type is used to keep track of a type name as written in the
3909 /// source code, including tag keywords and any nested-name-specifiers.
3910 /// The type itself is always "sugar", used to express what was written
3911 /// in the source code but containing no additional semantic information.
3912 class ElaboratedType : public TypeWithKeyword, public llvm::FoldingSetNode {
3913
3914   /// \brief The nested name specifier containing the qualifier.
3915   NestedNameSpecifier *NNS;
3916
3917   /// \brief The type that this qualified name refers to.
3918   QualType NamedType;
3919
3920   ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
3921                  QualType NamedType, QualType CanonType)
3922     : TypeWithKeyword(Keyword, Elaborated, CanonType,
3923                       NamedType->isDependentType(),
3924                       NamedType->isInstantiationDependentType(),
3925                       NamedType->isVariablyModifiedType(),
3926                       NamedType->containsUnexpandedParameterPack()),
3927       NNS(NNS), NamedType(NamedType) {
3928     assert(!(Keyword == ETK_None && NNS == 0) &&
3929            "ElaboratedType cannot have elaborated type keyword "
3930            "and name qualifier both null.");
3931   }
3932
3933   friend class ASTContext;  // ASTContext creates these
3934
3935 public:
3936   ~ElaboratedType();
3937
3938   /// \brief Retrieve the qualification on this type.
3939   NestedNameSpecifier *getQualifier() const { return NNS; }
3940
3941   /// \brief Retrieve the type named by the qualified-id.
3942   QualType getNamedType() const { return NamedType; }
3943
3944   /// \brief Remove a single level of sugar.
3945   QualType desugar() const { return getNamedType(); }
3946
3947   /// \brief Returns whether this type directly provides sugar.
3948   bool isSugared() const { return true; }
3949
3950   void Profile(llvm::FoldingSetNodeID &ID) {
3951     Profile(ID, getKeyword(), NNS, NamedType);
3952   }
3953
3954   static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
3955                       NestedNameSpecifier *NNS, QualType NamedType) {
3956     ID.AddInteger(Keyword);
3957     ID.AddPointer(NNS);
3958     NamedType.Profile(ID);
3959   }
3960
3961   static bool classof(const Type *T) {
3962     return T->getTypeClass() == Elaborated;
3963   }
3964 };
3965
3966 /// \brief Represents a qualified type name for which the type name is
3967 /// dependent.
3968 ///
3969 /// DependentNameType represents a class of dependent types that involve a
3970 /// dependent nested-name-specifier (e.g., "T::") followed by a (dependent)
3971 /// name of a type. The DependentNameType may start with a "typename" (for a
3972 /// typename-specifier), "class", "struct", "union", or "enum" (for a
3973 /// dependent elaborated-type-specifier), or nothing (in contexts where we
3974 /// know that we must be referring to a type, e.g., in a base class specifier).
3975 class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
3976
3977   /// \brief The nested name specifier containing the qualifier.
3978   NestedNameSpecifier *NNS;
3979
3980   /// \brief The type that this typename specifier refers to.
3981   const IdentifierInfo *Name;
3982
3983   DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
3984                     const IdentifierInfo *Name, QualType CanonType)
3985     : TypeWithKeyword(Keyword, DependentName, CanonType, /*Dependent=*/true,
3986                       /*InstantiationDependent=*/true,
3987                       /*VariablyModified=*/false,
3988                       NNS->containsUnexpandedParameterPack()),
3989       NNS(NNS), Name(Name) {
3990     assert(NNS->isDependent() &&
3991            "DependentNameType requires a dependent nested-name-specifier");
3992   }
3993
3994   friend class ASTContext;  // ASTContext creates these
3995
3996 public:
3997   /// \brief Retrieve the qualification on this type.
3998   NestedNameSpecifier *getQualifier() const { return NNS; }
3999
4000   /// \brief Retrieve the type named by the typename specifier as an
4001   /// identifier.
4002   ///
4003   /// This routine will return a non-NULL identifier pointer when the
4004   /// form of the original typename was terminated by an identifier,
4005   /// e.g., "typename T::type".
4006   const IdentifierInfo *getIdentifier() const {
4007     return Name;
4008   }
4009
4010   bool isSugared() const { return false; }
4011   QualType desugar() const { return QualType(this, 0); }
4012
4013   void Profile(llvm::FoldingSetNodeID &ID) {
4014     Profile(ID, getKeyword(), NNS, Name);
4015   }
4016
4017   static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
4018                       NestedNameSpecifier *NNS, const IdentifierInfo *Name) {
4019     ID.AddInteger(Keyword);
4020     ID.AddPointer(NNS);
4021     ID.AddPointer(Name);
4022   }
4023
4024   static bool classof(const Type *T) {
4025     return T->getTypeClass() == DependentName;
4026   }
4027 };
4028
4029 /// DependentTemplateSpecializationType - Represents a template
4030 /// specialization type whose template cannot be resolved, e.g.
4031 ///   A<T>::template B<T>
4032 class DependentTemplateSpecializationType :
4033   public TypeWithKeyword, public llvm::FoldingSetNode {
4034
4035   /// \brief The nested name specifier containing the qualifier.
4036   NestedNameSpecifier *NNS;
4037
4038   /// \brief The identifier of the template.
4039   const IdentifierInfo *Name;
4040
4041   /// \brief - The number of template arguments named in this class
4042   /// template specialization.
4043   unsigned NumArgs;
4044
4045   const TemplateArgument *getArgBuffer() const {
4046     return reinterpret_cast<const TemplateArgument*>(this+1);
4047   }
4048   TemplateArgument *getArgBuffer() {
4049     return reinterpret_cast<TemplateArgument*>(this+1);
4050   }
4051
4052   DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
4053                                       NestedNameSpecifier *NNS,
4054                                       const IdentifierInfo *Name,
4055                                       unsigned NumArgs,
4056                                       const TemplateArgument *Args,
4057                                       QualType Canon);
4058
4059   friend class ASTContext;  // ASTContext creates these
4060
4061 public:
4062   NestedNameSpecifier *getQualifier() const { return NNS; }
4063   const IdentifierInfo *getIdentifier() const { return Name; }
4064
4065   /// \brief Retrieve the template arguments.
4066   const TemplateArgument *getArgs() const {
4067     return getArgBuffer();
4068   }
4069
4070   /// \brief Retrieve the number of template arguments.
4071   unsigned getNumArgs() const { return NumArgs; }
4072
4073   const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
4074
4075   typedef const TemplateArgument * iterator;
4076   iterator begin() const { return getArgs(); }
4077   iterator end() const; // inline in TemplateBase.h
4078
4079   bool isSugared() const { return false; }
4080   QualType desugar() const { return QualType(this, 0); }
4081
4082   void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
4083     Profile(ID, Context, getKeyword(), NNS, Name, NumArgs, getArgs());
4084   }
4085
4086   static void Profile(llvm::FoldingSetNodeID &ID,
4087                       const ASTContext &Context,
4088                       ElaboratedTypeKeyword Keyword,
4089                       NestedNameSpecifier *Qualifier,
4090                       const IdentifierInfo *Name,
4091                       unsigned NumArgs,
4092                       const TemplateArgument *Args);
4093
4094   static bool classof(const Type *T) {
4095     return T->getTypeClass() == DependentTemplateSpecialization;
4096   }
4097 };
4098
4099 /// \brief Represents a pack expansion of types.
4100 ///
4101 /// Pack expansions are part of C++0x variadic templates. A pack
4102 /// expansion contains a pattern, which itself contains one or more
4103 /// "unexpanded" parameter packs. When instantiated, a pack expansion
4104 /// produces a series of types, each instantiated from the pattern of
4105 /// the expansion, where the Ith instantiation of the pattern uses the
4106 /// Ith arguments bound to each of the unexpanded parameter packs. The
4107 /// pack expansion is considered to "expand" these unexpanded
4108 /// parameter packs.
4109 ///
4110 /// \code
4111 /// template<typename ...Types> struct tuple;
4112 ///
4113 /// template<typename ...Types>
4114 /// struct tuple_of_references {
4115 ///   typedef tuple<Types&...> type;
4116 /// };
4117 /// \endcode
4118 ///
4119 /// Here, the pack expansion \c Types&... is represented via a
4120 /// PackExpansionType whose pattern is Types&.
4121 class PackExpansionType : public Type, public llvm::FoldingSetNode {
4122   /// \brief The pattern of the pack expansion.
4123   QualType Pattern;
4124
4125   /// \brief The number of expansions that this pack expansion will
4126   /// generate when substituted (+1), or indicates that
4127   ///
4128   /// This field will only have a non-zero value when some of the parameter
4129   /// packs that occur within the pattern have been substituted but others have
4130   /// not.
4131   unsigned NumExpansions;
4132
4133   PackExpansionType(QualType Pattern, QualType Canon,
4134                     Optional<unsigned> NumExpansions)
4135     : Type(PackExpansion, Canon, /*Dependent=*/Pattern->isDependentType(),
4136            /*InstantiationDependent=*/true,
4137            /*VariableModified=*/Pattern->isVariablyModifiedType(),
4138            /*ContainsUnexpandedParameterPack=*/false),
4139       Pattern(Pattern),
4140       NumExpansions(NumExpansions? *NumExpansions + 1: 0) { }
4141
4142   friend class ASTContext;  // ASTContext creates these
4143
4144 public:
4145   /// \brief Retrieve the pattern of this pack expansion, which is the
4146   /// type that will be repeatedly instantiated when instantiating the
4147   /// pack expansion itself.
4148   QualType getPattern() const { return Pattern; }
4149
4150   /// \brief Retrieve the number of expansions that this pack expansion will
4151   /// generate, if known.
4152   Optional<unsigned> getNumExpansions() const {
4153     if (NumExpansions)
4154       return NumExpansions - 1;
4155
4156     return None;
4157   }
4158
4159   bool isSugared() const { return false; }
4160   QualType desugar() const { return QualType(this, 0); }
4161
4162   void Profile(llvm::FoldingSetNodeID &ID) {
4163     Profile(ID, getPattern(), getNumExpansions());
4164   }
4165
4166   static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
4167                       Optional<unsigned> NumExpansions) {
4168     ID.AddPointer(Pattern.getAsOpaquePtr());
4169     ID.AddBoolean(NumExpansions.hasValue());
4170     if (NumExpansions)
4171       ID.AddInteger(*NumExpansions);
4172   }
4173
4174   static bool classof(const Type *T) {
4175     return T->getTypeClass() == PackExpansion;
4176   }
4177 };
4178
4179 /// ObjCObjectType - Represents a class type in Objective C.
4180 /// Every Objective C type is a combination of a base type and a
4181 /// list of protocols.
4182 ///
4183 /// Given the following declarations:
4184 /// \code
4185 ///   \@class C;
4186 ///   \@protocol P;
4187 /// \endcode
4188 ///
4189 /// 'C' is an ObjCInterfaceType C.  It is sugar for an ObjCObjectType
4190 /// with base C and no protocols.
4191 ///
4192 /// 'C<P>' is an ObjCObjectType with base C and protocol list [P].
4193 ///
4194 /// 'id' is a TypedefType which is sugar for an ObjCPointerType whose
4195 /// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
4196 /// and no protocols.
4197 ///
4198 /// 'id<P>' is an ObjCPointerType whose pointee is an ObjCObjecType
4199 /// with base BuiltinType::ObjCIdType and protocol list [P].  Eventually
4200 /// this should get its own sugar class to better represent the source.
4201 class ObjCObjectType : public Type {
4202   // ObjCObjectType.NumProtocols - the number of protocols stored
4203   // after the ObjCObjectPointerType node.
4204   //
4205   // These protocols are those written directly on the type.  If
4206   // protocol qualifiers ever become additive, the iterators will need
4207   // to get kindof complicated.
4208   //
4209   // In the canonical object type, these are sorted alphabetically
4210   // and uniqued.
4211
4212   /// Either a BuiltinType or an InterfaceType or sugar for either.
4213   QualType BaseType;
4214
4215   ObjCProtocolDecl * const *getProtocolStorage() const {
4216     return const_cast<ObjCObjectType*>(this)->getProtocolStorage();
4217   }
4218
4219   ObjCProtocolDecl **getProtocolStorage();
4220
4221 protected:
4222   ObjCObjectType(QualType Canonical, QualType Base,
4223                  ObjCProtocolDecl * const *Protocols, unsigned NumProtocols);
4224
4225   enum Nonce_ObjCInterface { Nonce_ObjCInterface };
4226   ObjCObjectType(enum Nonce_ObjCInterface)
4227         : Type(ObjCInterface, QualType(), false, false, false, false),
4228       BaseType(QualType(this_(), 0)) {
4229     ObjCObjectTypeBits.NumProtocols = 0;
4230   }
4231
4232 public:
4233   /// getBaseType - Gets the base type of this object type.  This is
4234   /// always (possibly sugar for) one of:
4235   ///  - the 'id' builtin type (as opposed to the 'id' type visible to the
4236   ///    user, which is a typedef for an ObjCPointerType)
4237   ///  - the 'Class' builtin type (same caveat)
4238   ///  - an ObjCObjectType (currently always an ObjCInterfaceType)
4239   QualType getBaseType() const { return BaseType; }
4240
4241   bool isObjCId() const {
4242     return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
4243   }
4244   bool isObjCClass() const {
4245     return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
4246   }
4247   bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
4248   bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
4249   bool isObjCUnqualifiedIdOrClass() const {
4250     if (!qual_empty()) return false;
4251     if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
4252       return T->getKind() == BuiltinType::ObjCId ||
4253              T->getKind() == BuiltinType::ObjCClass;
4254     return false;
4255   }
4256   bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
4257   bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }
4258
4259   /// Gets the interface declaration for this object type, if the base type
4260   /// really is an interface.
4261   ObjCInterfaceDecl *getInterface() const;
4262
4263   typedef ObjCProtocolDecl * const *qual_iterator;
4264
4265   qual_iterator qual_begin() const { return getProtocolStorage(); }
4266   qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }
4267
4268   bool qual_empty() const { return getNumProtocols() == 0; }
4269
4270   /// getNumProtocols - Return the number of qualifying protocols in this
4271   /// interface type, or 0 if there are none.
4272   unsigned getNumProtocols() const { return ObjCObjectTypeBits.NumProtocols; }
4273
4274   /// \brief Fetch a protocol by index.
4275   ObjCProtocolDecl *getProtocol(unsigned I) const {
4276     assert(I < getNumProtocols() && "Out-of-range protocol access");
4277     return qual_begin()[I];
4278   }
4279
4280   bool isSugared() const { return false; }
4281   QualType desugar() const { return QualType(this, 0); }
4282
4283   static bool classof(const Type *T) {
4284     return T->getTypeClass() == ObjCObject ||
4285            T->getTypeClass() == ObjCInterface;
4286   }
4287 };
4288
4289 /// ObjCObjectTypeImpl - A class providing a concrete implementation
4290 /// of ObjCObjectType, so as to not increase the footprint of
4291 /// ObjCInterfaceType.  Code outside of ASTContext and the core type
4292 /// system should not reference this type.
4293 class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
4294   friend class ASTContext;
4295
4296   // If anyone adds fields here, ObjCObjectType::getProtocolStorage()
4297   // will need to be modified.
4298
4299   ObjCObjectTypeImpl(QualType Canonical, QualType Base,
4300                      ObjCProtocolDecl * const *Protocols,
4301                      unsigned NumProtocols)
4302     : ObjCObjectType(Canonical, Base, Protocols, NumProtocols) {}
4303
4304 public:
4305   void Profile(llvm::FoldingSetNodeID &ID);
4306   static void Profile(llvm::FoldingSetNodeID &ID,
4307                       QualType Base,
4308                       ObjCProtocolDecl *const *protocols,
4309                       unsigned NumProtocols);
4310 };
4311
4312 inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorage() {
4313   return reinterpret_cast<ObjCProtocolDecl**>(
4314             static_cast<ObjCObjectTypeImpl*>(this) + 1);
4315 }
4316
4317 /// ObjCInterfaceType - Interfaces are the core concept in Objective-C for
4318 /// object oriented design.  They basically correspond to C++ classes.  There
4319 /// are two kinds of interface types, normal interfaces like "NSString" and
4320 /// qualified interfaces, which are qualified with a protocol list like
4321 /// "NSString<NSCopyable, NSAmazing>".
4322 ///
4323 /// ObjCInterfaceType guarantees the following properties when considered
4324 /// as a subtype of its superclass, ObjCObjectType:
4325 ///   - There are no protocol qualifiers.  To reinforce this, code which
4326 ///     tries to invoke the protocol methods via an ObjCInterfaceType will
4327 ///     fail to compile.
4328 ///   - It is its own base type.  That is, if T is an ObjCInterfaceType*,
4329 ///     T->getBaseType() == QualType(T, 0).
4330 class ObjCInterfaceType : public ObjCObjectType {
4331   mutable ObjCInterfaceDecl *Decl;
4332
4333   ObjCInterfaceType(const ObjCInterfaceDecl *D)
4334     : ObjCObjectType(Nonce_ObjCInterface),
4335       Decl(const_cast<ObjCInterfaceDecl*>(D)) {}
4336   friend class ASTContext;  // ASTContext creates these.
4337   friend class ASTReader;
4338   friend class ObjCInterfaceDecl;
4339
4340 public:
4341   /// getDecl - Get the declaration of this interface.
4342   ObjCInterfaceDecl *getDecl() const { return Decl; }
4343
4344   bool isSugared() const { return false; }
4345   QualType desugar() const { return QualType(this, 0); }
4346
4347   static bool classof(const Type *T) {
4348     return T->getTypeClass() == ObjCInterface;
4349   }
4350
4351   // Nonsense to "hide" certain members of ObjCObjectType within this
4352   // class.  People asking for protocols on an ObjCInterfaceType are
4353   // not going to get what they want: ObjCInterfaceTypes are
4354   // guaranteed to have no protocols.
4355   enum {
4356     qual_iterator,
4357     qual_begin,
4358     qual_end,
4359     getNumProtocols,
4360     getProtocol
4361   };
4362 };
4363
4364 inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
4365   if (const ObjCInterfaceType *T =
4366         getBaseType()->getAs<ObjCInterfaceType>())
4367     return T->getDecl();
4368   return 0;
4369 }
4370
4371 /// ObjCObjectPointerType - Used to represent a pointer to an
4372 /// Objective C object.  These are constructed from pointer
4373 /// declarators when the pointee type is an ObjCObjectType (or sugar
4374 /// for one).  In addition, the 'id' and 'Class' types are typedefs
4375 /// for these, and the protocol-qualified types 'id<P>' and 'Class<P>'
4376 /// are translated into these.
4377 ///
4378 /// Pointers to pointers to Objective C objects are still PointerTypes;
4379 /// only the first level of pointer gets it own type implementation.
4380 class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
4381   QualType PointeeType;
4382
4383   ObjCObjectPointerType(QualType Canonical, QualType Pointee)
4384     : Type(ObjCObjectPointer, Canonical, false, false, false, false),
4385       PointeeType(Pointee) {}
4386   friend class ASTContext;  // ASTContext creates these.
4387
4388 public:
4389   /// getPointeeType - Gets the type pointed to by this ObjC pointer.
4390   /// The result will always be an ObjCObjectType or sugar thereof.
4391   QualType getPointeeType() const { return PointeeType; }
4392
4393   /// getObjCObjectType - Gets the type pointed to by this ObjC
4394   /// pointer.  This method always returns non-null.
4395   ///
4396   /// This method is equivalent to getPointeeType() except that
4397   /// it discards any typedefs (or other sugar) between this
4398   /// type and the "outermost" object type.  So for:
4399   /// \code
4400   ///   \@class A; \@protocol P; \@protocol Q;
4401   ///   typedef A<P> AP;
4402   ///   typedef A A1;
4403   ///   typedef A1<P> A1P;
4404   ///   typedef A1P<Q> A1PQ;
4405   /// \endcode
4406   /// For 'A*', getObjectType() will return 'A'.
4407   /// For 'A<P>*', getObjectType() will return 'A<P>'.
4408   /// For 'AP*', getObjectType() will return 'A<P>'.
4409   /// For 'A1*', getObjectType() will return 'A'.
4410   /// For 'A1<P>*', getObjectType() will return 'A1<P>'.
4411   /// For 'A1P*', getObjectType() will return 'A1<P>'.
4412   /// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
4413   ///   adding protocols to a protocol-qualified base discards the
4414   ///   old qualifiers (for now).  But if it didn't, getObjectType()
4415   ///   would return 'A1P<Q>' (and we'd have to make iterating over
4416   ///   qualifiers more complicated).
4417   const ObjCObjectType *getObjectType() const {
4418     return PointeeType->castAs<ObjCObjectType>();
4419   }
4420
4421   /// getInterfaceType - If this pointer points to an Objective C
4422   /// \@interface type, gets the type for that interface.  Any protocol
4423   /// qualifiers on the interface are ignored.
4424   ///
4425   /// \return null if the base type for this pointer is 'id' or 'Class'
4426   const ObjCInterfaceType *getInterfaceType() const {
4427     return getObjectType()->getBaseType()->getAs<ObjCInterfaceType>();
4428   }
4429
4430   /// getInterfaceDecl - If this pointer points to an Objective \@interface
4431   /// type, gets the declaration for that interface.
4432   ///
4433   /// \return null if the base type for this pointer is 'id' or 'Class'
4434   ObjCInterfaceDecl *getInterfaceDecl() const {
4435     return getObjectType()->getInterface();
4436   }
4437
4438   /// isObjCIdType - True if this is equivalent to the 'id' type, i.e. if
4439   /// its object type is the primitive 'id' type with no protocols.
4440   bool isObjCIdType() const {
4441     return getObjectType()->isObjCUnqualifiedId();
4442   }
4443
4444   /// isObjCClassType - True if this is equivalent to the 'Class' type,
4445   /// i.e. if its object tive is the primitive 'Class' type with no protocols.
4446   bool isObjCClassType() const {
4447     return getObjectType()->isObjCUnqualifiedClass();
4448   }
4449
4450   /// isObjCQualifiedIdType - True if this is equivalent to 'id<P>' for some
4451   /// non-empty set of protocols.
4452   bool isObjCQualifiedIdType() const {
4453     return getObjectType()->isObjCQualifiedId();
4454   }
4455
4456   /// isObjCQualifiedClassType - True if this is equivalent to 'Class<P>' for
4457   /// some non-empty set of protocols.
4458   bool isObjCQualifiedClassType() const {
4459     return getObjectType()->isObjCQualifiedClass();
4460   }
4461
4462   /// An iterator over the qualifiers on the object type.  Provided
4463   /// for convenience.  This will always iterate over the full set of
4464   /// protocols on a type, not just those provided directly.
4465   typedef ObjCObjectType::qual_iterator qual_iterator;
4466
4467   qual_iterator qual_begin() const {
4468     return getObjectType()->qual_begin();
4469   }
4470   qual_iterator qual_end() const {
4471     return getObjectType()->qual_end();
4472   }
4473   bool qual_empty() const { return getObjectType()->qual_empty(); }
4474
4475   /// getNumProtocols - Return the number of qualifying protocols on
4476   /// the object type.
4477   unsigned getNumProtocols() const {
4478     return getObjectType()->getNumProtocols();
4479   }
4480
4481   /// \brief Retrieve a qualifying protocol by index on the object
4482   /// type.
4483   ObjCProtocolDecl *getProtocol(unsigned I) const {
4484     return getObjectType()->getProtocol(I);
4485   }
4486
4487   bool isSugared() const { return false; }
4488   QualType desugar() const { return QualType(this, 0); }
4489
4490   void Profile(llvm::FoldingSetNodeID &ID) {
4491     Profile(ID, getPointeeType());
4492   }
4493   static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
4494     ID.AddPointer(T.getAsOpaquePtr());
4495   }
4496   static bool classof(const Type *T) {
4497     return T->getTypeClass() == ObjCObjectPointer;
4498   }
4499 };
4500
4501 class AtomicType : public Type, public llvm::FoldingSetNode {
4502   QualType ValueType;
4503
4504   AtomicType(QualType ValTy, QualType Canonical)
4505     : Type(Atomic, Canonical, ValTy->isDependentType(),
4506            ValTy->isInstantiationDependentType(),
4507            ValTy->isVariablyModifiedType(),
4508            ValTy->containsUnexpandedParameterPack()),
4509       ValueType(ValTy) {}
4510   friend class ASTContext;  // ASTContext creates these.
4511
4512   public:
4513   /// getValueType - Gets the type contained by this atomic type, i.e.
4514   /// the type returned by performing an atomic load of this atomic type.
4515   QualType getValueType() const { return ValueType; }
4516
4517   bool isSugared() const { return false; }
4518   QualType desugar() const { return QualType(this, 0); }
4519
4520   void Profile(llvm::FoldingSetNodeID &ID) {
4521     Profile(ID, getValueType());
4522   }
4523   static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
4524     ID.AddPointer(T.getAsOpaquePtr());
4525   }
4526   static bool classof(const Type *T) {
4527     return T->getTypeClass() == Atomic;
4528   }
4529 };
4530
4531 /// A qualifier set is used to build a set of qualifiers.
4532 class QualifierCollector : public Qualifiers {
4533 public:
4534   QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}
4535
4536   /// Collect any qualifiers on the given type and return an
4537   /// unqualified type.  The qualifiers are assumed to be consistent
4538   /// with those already in the type.
4539   const Type *strip(QualType type) {
4540     addFastQualifiers(type.getLocalFastQualifiers());
4541     if (!type.hasLocalNonFastQualifiers())
4542       return type.getTypePtrUnsafe();
4543
4544     const ExtQuals *extQuals = type.getExtQualsUnsafe();
4545     addConsistentQualifiers(extQuals->getQualifiers());
4546     return extQuals->getBaseType();
4547   }
4548
4549   /// Apply the collected qualifiers to the given type.
4550   QualType apply(const ASTContext &Context, QualType QT) const;
4551
4552   /// Apply the collected qualifiers to the given type.
4553   QualType apply(const ASTContext &Context, const Type* T) const;
4554 };
4555
4556
4557 // Inline function definitions.
4558
4559 inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
4560   SplitQualType desugar =
4561     Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
4562   desugar.Quals.addConsistentQualifiers(Quals);
4563   return desugar;
4564 }
4565
4566 inline const Type *QualType::getTypePtr() const {
4567   return getCommonPtr()->BaseType;
4568 }
4569
4570 inline const Type *QualType::getTypePtrOrNull() const {
4571   return (isNull() ? 0 : getCommonPtr()->BaseType);
4572 }
4573
4574 inline SplitQualType QualType::split() const {
4575   if (!hasLocalNonFastQualifiers())
4576     return SplitQualType(getTypePtrUnsafe(),
4577                          Qualifiers::fromFastMask(getLocalFastQualifiers()));
4578
4579   const ExtQuals *eq = getExtQualsUnsafe();
4580   Qualifiers qs = eq->getQualifiers();
4581   qs.addFastQualifiers(getLocalFastQualifiers());
4582   return SplitQualType(eq->getBaseType(), qs);
4583 }
4584
4585 inline Qualifiers QualType::getLocalQualifiers() const {
4586   Qualifiers Quals;
4587   if (hasLocalNonFastQualifiers())
4588     Quals = getExtQualsUnsafe()->getQualifiers();
4589   Quals.addFastQualifiers(getLocalFastQualifiers());
4590   return Quals;
4591 }
4592
4593 inline Qualifiers QualType::getQualifiers() const {
4594   Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
4595   quals.addFastQualifiers(getLocalFastQualifiers());
4596   return quals;
4597 }
4598
4599 inline unsigned QualType::getCVRQualifiers() const {
4600   unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
4601   cvr |= getLocalCVRQualifiers();
4602   return cvr;
4603 }
4604
4605 inline QualType QualType::getCanonicalType() const {
4606   QualType canon = getCommonPtr()->CanonicalType;
4607   return canon.withFastQualifiers(getLocalFastQualifiers());
4608 }
4609
4610 inline bool QualType::isCanonical() const {
4611   return getTypePtr()->isCanonicalUnqualified();
4612 }
4613
4614 inline bool QualType::isCanonicalAsParam() const {
4615   if (!isCanonical()) return false;
4616   if (hasLocalQualifiers()) return false;
4617
4618   const Type *T = getTypePtr();
4619   if (T->isVariablyModifiedType() && T->hasSizedVLAType())
4620     return false;
4621
4622   return !isa<FunctionType>(T) && !isa<ArrayType>(T);
4623 }
4624
4625 inline bool QualType::isConstQualified() const {
4626   return isLocalConstQualified() ||
4627          getCommonPtr()->CanonicalType.isLocalConstQualified();
4628 }
4629
4630 inline bool QualType::isRestrictQualified() const {
4631   return isLocalRestrictQualified() ||
4632          getCommonPtr()->CanonicalType.isLocalRestrictQualified();
4633 }
4634
4635
4636 inline bool QualType::isVolatileQualified() const {
4637   return isLocalVolatileQualified() ||
4638          getCommonPtr()->CanonicalType.isLocalVolatileQualified();
4639 }
4640
4641 inline bool QualType::hasQualifiers() const {
4642   return hasLocalQualifiers() ||
4643          getCommonPtr()->CanonicalType.hasLocalQualifiers();
4644 }
4645
4646 inline QualType QualType::getUnqualifiedType() const {
4647   if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
4648     return QualType(getTypePtr(), 0);
4649
4650   return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
4651 }
4652
4653 inline SplitQualType QualType::getSplitUnqualifiedType() const {
4654   if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
4655     return split();
4656
4657   return getSplitUnqualifiedTypeImpl(*this);
4658 }
4659
4660 inline void QualType::removeLocalConst() {
4661   removeLocalFastQualifiers(Qualifiers::Const);
4662 }
4663
4664 inline void QualType::removeLocalRestrict() {
4665   removeLocalFastQualifiers(Qualifiers::Restrict);
4666 }
4667
4668 inline void QualType::removeLocalVolatile() {
4669   removeLocalFastQualifiers(Qualifiers::Volatile);
4670 }
4671
4672 inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
4673   assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits");
4674   assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask);
4675
4676   // Fast path: we don't need to touch the slow qualifiers.
4677   removeLocalFastQualifiers(Mask);
4678 }
4679
4680 /// getAddressSpace - Return the address space of this type.
4681 inline unsigned QualType::getAddressSpace() const {
4682   return getQualifiers().getAddressSpace();
4683 }
4684
4685 /// getObjCGCAttr - Return the gc attribute of this type.
4686 inline Qualifiers::GC QualType::getObjCGCAttr() const {
4687   return getQualifiers().getObjCGCAttr();
4688 }
4689
4690 inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
4691   if (const PointerType *PT = t.getAs<PointerType>()) {
4692     if (const FunctionType *FT = PT->getPointeeType()->getAs<FunctionType>())
4693       return FT->getExtInfo();
4694   } else if (const FunctionType *FT = t.getAs<FunctionType>())
4695     return FT->getExtInfo();
4696
4697   return FunctionType::ExtInfo();
4698 }
4699
4700 inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
4701   return getFunctionExtInfo(*t);
4702 }
4703
4704 /// isMoreQualifiedThan - Determine whether this type is more
4705 /// qualified than the Other type. For example, "const volatile int"
4706 /// is more qualified than "const int", "volatile int", and
4707 /// "int". However, it is not more qualified than "const volatile
4708 /// int".
4709 inline bool QualType::isMoreQualifiedThan(QualType other) const {
4710   Qualifiers myQuals = getQualifiers();
4711   Qualifiers otherQuals = other.getQualifiers();
4712   return (myQuals != otherQuals && myQuals.compatiblyIncludes(otherQuals));
4713 }
4714
4715 /// isAtLeastAsQualifiedAs - Determine whether this type is at last
4716 /// as qualified as the Other type. For example, "const volatile
4717 /// int" is at least as qualified as "const int", "volatile int",
4718 /// "int", and "const volatile int".
4719 inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
4720   return getQualifiers().compatiblyIncludes(other.getQualifiers());
4721 }
4722
4723 /// getNonReferenceType - If Type is a reference type (e.g., const
4724 /// int&), returns the type that the reference refers to ("const
4725 /// int"). Otherwise, returns the type itself. This routine is used
4726 /// throughout Sema to implement C++ 5p6:
4727 ///
4728 ///   If an expression initially has the type "reference to T" (8.3.2,
4729 ///   8.5.3), the type is adjusted to "T" prior to any further
4730 ///   analysis, the expression designates the object or function
4731 ///   denoted by the reference, and the expression is an lvalue.
4732 inline QualType QualType::getNonReferenceType() const {
4733   if (const ReferenceType *RefType = (*this)->getAs<ReferenceType>())
4734     return RefType->getPointeeType();
4735   else
4736     return *this;
4737 }
4738
4739 inline bool QualType::isCForbiddenLValueType() const {
4740   return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
4741           getTypePtr()->isFunctionType());
4742 }
4743
4744 /// \brief Tests whether the type is categorized as a fundamental type.
4745 ///
4746 /// \returns True for types specified in C++0x [basic.fundamental].
4747 inline bool Type::isFundamentalType() const {
4748   return isVoidType() ||
4749          // FIXME: It's really annoying that we don't have an
4750          // 'isArithmeticType()' which agrees with the standard definition.
4751          (isArithmeticType() && !isEnumeralType());
4752 }
4753
4754 /// \brief Tests whether the type is categorized as a compound type.
4755 ///
4756 /// \returns True for types specified in C++0x [basic.compound].
4757 inline bool Type::isCompoundType() const {
4758   // C++0x [basic.compound]p1:
4759   //   Compound types can be constructed in the following ways:
4760   //    -- arrays of objects of a given type [...];
4761   return isArrayType() ||
4762   //    -- functions, which have parameters of given types [...];
4763          isFunctionType() ||
4764   //    -- pointers to void or objects or functions [...];
4765          isPointerType() ||
4766   //    -- references to objects or functions of a given type. [...]
4767          isReferenceType() ||
4768   //    -- classes containing a sequence of objects of various types, [...];
4769          isRecordType() ||
4770   //    -- unions, which are classes capable of containing objects of different
4771   //               types at different times;
4772          isUnionType() ||
4773   //    -- enumerations, which comprise a set of named constant values. [...];
4774          isEnumeralType() ||
4775   //    -- pointers to non-static class members, [...].
4776          isMemberPointerType();
4777 }
4778
4779 inline bool Type::isFunctionType() const {
4780   return isa<FunctionType>(CanonicalType);
4781 }
4782 inline bool Type::isPointerType() const {
4783   return isa<PointerType>(CanonicalType);
4784 }
4785 inline bool Type::isAnyPointerType() const {
4786   return isPointerType() || isObjCObjectPointerType();
4787 }
4788 inline bool Type::isBlockPointerType() const {
4789   return isa<BlockPointerType>(CanonicalType);
4790 }
4791 inline bool Type::isReferenceType() const {
4792   return isa<ReferenceType>(CanonicalType);
4793 }
4794 inline bool Type::isLValueReferenceType() const {
4795   return isa<LValueReferenceType>(CanonicalType);
4796 }
4797 inline bool Type::isRValueReferenceType() const {
4798   return isa<RValueReferenceType>(CanonicalType);
4799 }
4800 inline bool Type::isFunctionPointerType() const {
4801   if (const PointerType *T = getAs<PointerType>())
4802     return T->getPointeeType()->isFunctionType();
4803   else
4804     return false;
4805 }
4806 inline bool Type::isMemberPointerType() const {
4807   return isa<MemberPointerType>(CanonicalType);
4808 }
4809 inline bool Type::isMemberFunctionPointerType() const {
4810   if (const MemberPointerType* T = getAs<MemberPointerType>())
4811     return T->isMemberFunctionPointer();
4812   else
4813     return false;
4814 }
4815 inline bool Type::isMemberDataPointerType() const {
4816   if (const MemberPointerType* T = getAs<MemberPointerType>())
4817     return T->isMemberDataPointer();
4818   else
4819     return false;
4820 }
4821 inline bool Type::isArrayType() const {
4822   return isa<ArrayType>(CanonicalType);
4823 }
4824 inline bool Type::isConstantArrayType() const {
4825   return isa<ConstantArrayType>(CanonicalType);
4826 }
4827 inline bool Type::isIncompleteArrayType() const {
4828   return isa<IncompleteArrayType>(CanonicalType);
4829 }
4830 inline bool Type::isVariableArrayType() const {
4831   return isa<VariableArrayType>(CanonicalType);
4832 }
4833 inline bool Type::isDependentSizedArrayType() const {
4834   return isa<DependentSizedArrayType>(CanonicalType);
4835 }
4836 inline bool Type::isBuiltinType() const {
4837   return isa<BuiltinType>(CanonicalType);
4838 }
4839 inline bool Type::isRecordType() const {
4840   return isa<RecordType>(CanonicalType);
4841 }
4842 inline bool Type::isEnumeralType() const {
4843   return isa<EnumType>(CanonicalType);
4844 }
4845 inline bool Type::isAnyComplexType() const {
4846   return isa<ComplexType>(CanonicalType);
4847 }
4848 inline bool Type::isVectorType() const {
4849   return isa<VectorType>(CanonicalType);
4850 }
4851 inline bool Type::isExtVectorType() const {
4852   return isa<ExtVectorType>(CanonicalType);
4853 }
4854 inline bool Type::isObjCObjectPointerType() const {
4855   return isa<ObjCObjectPointerType>(CanonicalType);
4856 }
4857 inline bool Type::isObjCObjectType() const {
4858   return isa<ObjCObjectType>(CanonicalType);
4859 }
4860 inline bool Type::isObjCObjectOrInterfaceType() const {
4861   return isa<ObjCInterfaceType>(CanonicalType) ||
4862     isa<ObjCObjectType>(CanonicalType);
4863 }
4864 inline bool Type::isAtomicType() const {
4865   return isa<AtomicType>(CanonicalType);
4866 }
4867
4868 inline bool Type::isObjCQualifiedIdType() const {
4869   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>())
4870     return OPT->isObjCQualifiedIdType();
4871   return false;
4872 }
4873 inline bool Type::isObjCQualifiedClassType() const {
4874   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>())
4875     return OPT->isObjCQualifiedClassType();
4876   return false;
4877 }
4878 inline bool Type::isObjCIdType() const {
4879   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>())
4880     return OPT->isObjCIdType();
4881   return false;
4882 }
4883 inline bool Type::isObjCClassType() const {
4884   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>())
4885     return OPT->isObjCClassType();
4886   return false;
4887 }
4888 inline bool Type::isObjCSelType() const {
4889   if (const PointerType *OPT = getAs<PointerType>())
4890     return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
4891   return false;
4892 }
4893 inline bool Type::isObjCBuiltinType() const {
4894   return isObjCIdType() || isObjCClassType() || isObjCSelType();
4895 }
4896
4897 inline bool Type::isImage1dT() const {
4898   return isSpecificBuiltinType(BuiltinType::OCLImage1d);
4899 }
4900
4901 inline bool Type::isImage1dArrayT() const {
4902   return isSpecificBuiltinType(BuiltinType::OCLImage1dArray);
4903 }
4904
4905 inline bool Type::isImage1dBufferT() const {
4906   return isSpecificBuiltinType(BuiltinType::OCLImage1dBuffer);
4907 }
4908
4909 inline bool Type::isImage2dT() const {
4910   return isSpecificBuiltinType(BuiltinType::OCLImage2d);
4911 }
4912
4913 inline bool Type::isImage2dArrayT() const {
4914   return isSpecificBuiltinType(BuiltinType::OCLImage2dArray);
4915 }
4916
4917 inline bool Type::isImage3dT() const {
4918   return isSpecificBuiltinType(BuiltinType::OCLImage3d);
4919 }
4920
4921 inline bool Type::isSamplerT() const {
4922   return isSpecificBuiltinType(BuiltinType::OCLSampler);
4923 }
4924
4925 inline bool Type::isEventT() const {
4926   return isSpecificBuiltinType(BuiltinType::OCLEvent);
4927 }
4928
4929 inline bool Type::isImageType() const {
4930   return isImage3dT() ||
4931          isImage2dT() || isImage2dArrayT() ||
4932          isImage1dT() || isImage1dArrayT() || isImage1dBufferT();
4933 }
4934
4935 inline bool Type::isOpenCLSpecificType() const {
4936   return isSamplerT() || isEventT() || isImageType();
4937 }
4938
4939 inline bool Type::isTemplateTypeParmType() const {
4940   return isa<TemplateTypeParmType>(CanonicalType);
4941 }
4942
4943 inline bool Type::isSpecificBuiltinType(unsigned K) const {
4944   if (const BuiltinType *BT = getAs<BuiltinType>())
4945     if (BT->getKind() == (BuiltinType::Kind) K)
4946       return true;
4947   return false;
4948 }
4949
4950 inline bool Type::isPlaceholderType() const {
4951   if (const BuiltinType *BT = dyn_cast<BuiltinType>(this))
4952     return BT->isPlaceholderType();
4953   return false;
4954 }
4955
4956 inline const BuiltinType *Type::getAsPlaceholderType() const {
4957   if (const BuiltinType *BT = dyn_cast<BuiltinType>(this))
4958     if (BT->isPlaceholderType())
4959       return BT;
4960   return 0;
4961 }
4962
4963 inline bool Type::isSpecificPlaceholderType(unsigned K) const {
4964   assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K));
4965   if (const BuiltinType *BT = dyn_cast<BuiltinType>(this))
4966     return (BT->getKind() == (BuiltinType::Kind) K);
4967   return false;
4968 }
4969
4970 inline bool Type::isNonOverloadPlaceholderType() const {
4971   if (const BuiltinType *BT = dyn_cast<BuiltinType>(this))
4972     return BT->isNonOverloadPlaceholderType();
4973   return false;
4974 }
4975
4976 inline bool Type::isVoidType() const {
4977   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
4978     return BT->getKind() == BuiltinType::Void;
4979   return false;
4980 }
4981
4982 inline bool Type::isHalfType() const {
4983   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
4984     return BT->getKind() == BuiltinType::Half;
4985   // FIXME: Should we allow complex __fp16? Probably not.
4986   return false;
4987 }
4988
4989 inline bool Type::isNullPtrType() const {
4990   if (const BuiltinType *BT = getAs<BuiltinType>())
4991     return BT->getKind() == BuiltinType::NullPtr;
4992   return false;
4993 }
4994
4995 extern bool IsEnumDeclComplete(EnumDecl *);
4996 extern bool IsEnumDeclScoped(EnumDecl *);
4997
4998 inline bool Type::isIntegerType() const {
4999   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
5000     return BT->getKind() >= BuiltinType::Bool &&
5001            BT->getKind() <= BuiltinType::Int128;
5002   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
5003     // Incomplete enum types are not treated as integer types.
5004     // FIXME: In C++, enum types are never integer types.
5005     return IsEnumDeclComplete(ET->getDecl()) &&
5006       !IsEnumDeclScoped(ET->getDecl());
5007   }
5008   return false;
5009 }
5010
5011 inline bool Type::isScalarType() const {
5012   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
5013     return BT->getKind() > BuiltinType::Void &&
5014            BT->getKind() <= BuiltinType::NullPtr;
5015   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
5016     // Enums are scalar types, but only if they are defined.  Incomplete enums
5017     // are not treated as scalar types.
5018     return IsEnumDeclComplete(ET->getDecl());
5019   return isa<PointerType>(CanonicalType) ||
5020          isa<BlockPointerType>(CanonicalType) ||
5021          isa<MemberPointerType>(CanonicalType) ||
5022          isa<ComplexType>(CanonicalType) ||
5023          isa<ObjCObjectPointerType>(CanonicalType);
5024 }
5025
5026 inline bool Type::isIntegralOrEnumerationType() const {
5027   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
5028     return BT->getKind() >= BuiltinType::Bool &&
5029            BT->getKind() <= BuiltinType::Int128;
5030
5031   // Check for a complete enum type; incomplete enum types are not properly an
5032   // enumeration type in the sense required here.
5033   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
5034     return IsEnumDeclComplete(ET->getDecl());
5035
5036   return false;
5037 }
5038
5039 inline bool Type::isBooleanType() const {
5040   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
5041     return BT->getKind() == BuiltinType::Bool;
5042   return false;
5043 }
5044
5045 inline bool Type::isUndeducedType() const {
5046   const AutoType *AT = getContainedAutoType();
5047   return AT && !AT->isDeduced();
5048 }
5049
5050 /// \brief Determines whether this is a type for which one can define
5051 /// an overloaded operator.
5052 inline bool Type::isOverloadableType() const {
5053   return isDependentType() || isRecordType() || isEnumeralType();
5054 }
5055
5056 /// \brief Determines whether this type can decay to a pointer type.
5057 inline bool Type::canDecayToPointerType() const {
5058   return isFunctionType() || isArrayType();
5059 }
5060
5061 inline bool Type::hasPointerRepresentation() const {
5062   return (isPointerType() || isReferenceType() || isBlockPointerType() ||
5063           isObjCObjectPointerType() || isNullPtrType());
5064 }
5065
5066 inline bool Type::hasObjCPointerRepresentation() const {
5067   return isObjCObjectPointerType();
5068 }
5069
5070 inline const Type *Type::getBaseElementTypeUnsafe() const {
5071   const Type *type = this;
5072   while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
5073     type = arrayType->getElementType().getTypePtr();
5074   return type;
5075 }
5076
5077 /// Insertion operator for diagnostics.  This allows sending QualType's into a
5078 /// diagnostic with <<.
5079 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
5080                                            QualType T) {
5081   DB.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
5082                   DiagnosticsEngine::ak_qualtype);
5083   return DB;
5084 }
5085
5086 /// Insertion operator for partial diagnostics.  This allows sending QualType's
5087 /// into a diagnostic with <<.
5088 inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
5089                                            QualType T) {
5090   PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
5091                   DiagnosticsEngine::ak_qualtype);
5092   return PD;
5093 }
5094
5095 // Helper class template that is used by Type::getAs to ensure that one does
5096 // not try to look through a qualified type to get to an array type.
5097 template<typename T,
5098          bool isArrayType = (llvm::is_same<T, ArrayType>::value ||
5099                              llvm::is_base_of<ArrayType, T>::value)>
5100 struct ArrayType_cannot_be_used_with_getAs { };
5101
5102 template<typename T>
5103 struct ArrayType_cannot_be_used_with_getAs<T, true>;
5104
5105 // Member-template getAs<specific type>'.
5106 template <typename T> const T *Type::getAs() const {
5107   ArrayType_cannot_be_used_with_getAs<T> at;
5108   (void)at;
5109
5110   // If this is directly a T type, return it.
5111   if (const T *Ty = dyn_cast<T>(this))
5112     return Ty;
5113
5114   // If the canonical form of this type isn't the right kind, reject it.
5115   if (!isa<T>(CanonicalType))
5116     return 0;
5117
5118   // If this is a typedef for the type, strip the typedef off without
5119   // losing all typedef information.
5120   return cast<T>(getUnqualifiedDesugaredType());
5121 }
5122
5123 inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
5124   // If this is directly an array type, return it.
5125   if (const ArrayType *arr = dyn_cast<ArrayType>(this))
5126     return arr;
5127
5128   // If the canonical form of this type isn't the right kind, reject it.
5129   if (!isa<ArrayType>(CanonicalType))
5130     return 0;
5131
5132   // If this is a typedef for the type, strip the typedef off without
5133   // losing all typedef information.
5134   return cast<ArrayType>(getUnqualifiedDesugaredType());
5135 }
5136
5137 template <typename T> const T *Type::castAs() const {
5138   ArrayType_cannot_be_used_with_getAs<T> at;
5139   (void) at;
5140
5141   assert(isa<T>(CanonicalType));
5142   if (const T *ty = dyn_cast<T>(this)) return ty;
5143   return cast<T>(getUnqualifiedDesugaredType());
5144 }
5145
5146 inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
5147   assert(isa<ArrayType>(CanonicalType));
5148   if (const ArrayType *arr = dyn_cast<ArrayType>(this)) return arr;
5149   return cast<ArrayType>(getUnqualifiedDesugaredType());
5150 }
5151
5152 }  // end namespace clang
5153
5154 #endif