contrib/llvm/tools/clang/lib/AST/Type.cpp

   1 //===--- Type.cpp - Type representation and manipulation ------------------===//
   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 implements type-related functionality.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/ASTContext.h"
  15 #include "clang/AST/Attr.h"
  16 #include "clang/AST/CharUnits.h"
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/DeclObjC.h"
  19 #include "clang/AST/DeclTemplate.h"
  20 #include "clang/AST/Expr.h"
  21 #include "clang/AST/PrettyPrinter.h"
  22 #include "clang/AST/Type.h"
  23 #include "clang/AST/TypeVisitor.h"
  24 #include "clang/Basic/Specifiers.h"
  25 #include "llvm/ADT/APSInt.h"
  26 #include "llvm/ADT/StringExtras.h"
  27 #include "llvm/Support/raw_ostream.h"
  28 #include <algorithm>
  29 using namespace clang;
  30
  31 bool Qualifiers::isStrictSupersetOf(Qualifiers Other) const {
  32   return (*this != Other) &&
  33     // CVR qualifiers superset
  34     (((Mask & CVRMask) | (Other.Mask & CVRMask)) == (Mask & CVRMask)) &&
  35     // ObjC GC qualifiers superset
  36     ((getObjCGCAttr() == Other.getObjCGCAttr()) ||
  37      (hasObjCGCAttr() && !Other.hasObjCGCAttr())) &&
  38     // Address space superset.
  39     ((getAddressSpace() == Other.getAddressSpace()) ||
  40      (hasAddressSpace()&& !Other.hasAddressSpace())) &&
  41     // Lifetime qualifier superset.
  42     ((getObjCLifetime() == Other.getObjCLifetime()) ||
  43      (hasObjCLifetime() && !Other.hasObjCLifetime()));
  44 }
  45
  46 const IdentifierInfo* QualType::getBaseTypeIdentifier() const {
  47   const Type* ty = getTypePtr();
  48   NamedDecl *ND = nullptr;
  49   if (ty->isPointerType() || ty->isReferenceType())
  50     return ty->getPointeeType().getBaseTypeIdentifier();
  51   else if (ty->isRecordType())
  52     ND = ty->getAs<RecordType>()->getDecl();
  53   else if (ty->isEnumeralType())
  54     ND = ty->getAs<EnumType>()->getDecl();
  55   else if (ty->getTypeClass() == Type::Typedef)
  56     ND = ty->getAs<TypedefType>()->getDecl();
  57   else if (ty->isArrayType())
  58     return ty->castAsArrayTypeUnsafe()->
  59         getElementType().getBaseTypeIdentifier();
  60
  61   if (ND)
  62     return ND->getIdentifier();
  63   return nullptr;
  64 }
  65
  66 bool QualType::isConstant(QualType T, ASTContext &Ctx) {
  67   if (T.isConstQualified())
  68     return true;
  69
  70   if (const ArrayType *AT = Ctx.getAsArrayType(T))
  71     return AT->getElementType().isConstant(Ctx);
  72
  73   return T.getAddressSpace() == LangAS::opencl_constant;
  74 }
  75
  76 unsigned ConstantArrayType::getNumAddressingBits(ASTContext &Context,
  77                                                  QualType ElementType,
  78                                                const llvm::APInt &NumElements) {
  79   uint64_t ElementSize = Context.getTypeSizeInChars(ElementType).getQuantity();
  80
  81   // Fast path the common cases so we can avoid the conservative computation
  82   // below, which in common cases allocates "large" APSInt values, which are
  83   // slow.
  84
  85   // If the element size is a power of 2, we can directly compute the additional
  86   // number of addressing bits beyond those required for the element count.
  87   if (llvm::isPowerOf2_64(ElementSize)) {
  88     return NumElements.getActiveBits() + llvm::Log2_64(ElementSize);
  89   }
  90
  91   // If both the element count and element size fit in 32-bits, we can do the
  92   // computation directly in 64-bits.
  93   if ((ElementSize >> 32) == 0 && NumElements.getBitWidth() <= 64 &&
  94       (NumElements.getZExtValue() >> 32) == 0) {
  95     uint64_t TotalSize = NumElements.getZExtValue() * ElementSize;
  96     return 64 - llvm::countLeadingZeros(TotalSize);
  97   }
  98
  99   // Otherwise, use APSInt to handle arbitrary sized values.
 100   llvm::APSInt SizeExtended(NumElements, true);
 101   unsigned SizeTypeBits = Context.getTypeSize(Context.getSizeType());
 102   SizeExtended = SizeExtended.extend(std::max(SizeTypeBits,
 103                                               SizeExtended.getBitWidth()) * 2);
 104
 105   llvm::APSInt TotalSize(llvm::APInt(SizeExtended.getBitWidth(), ElementSize));
 106   TotalSize *= SizeExtended;
 107
 108   return TotalSize.getActiveBits();
 109 }
 110
 111 unsigned ConstantArrayType::getMaxSizeBits(ASTContext &Context) {
 112   unsigned Bits = Context.getTypeSize(Context.getSizeType());
 113
 114   // Limit the number of bits in size_t so that maximal bit size fits 64 bit
 115   // integer (see PR8256).  We can do this as currently there is no hardware
 116   // that supports full 64-bit virtual space.
 117   if (Bits > 61)
 118     Bits = 61;
 119
 120   return Bits;
 121 }
 122
 123 DependentSizedArrayType::DependentSizedArrayType(const ASTContext &Context,
 124                                                  QualType et, QualType can,
 125                                                  Expr *e, ArraySizeModifier sm,
 126                                                  unsigned tq,
 127                                                  SourceRange brackets)
 128     : ArrayType(DependentSizedArray, et, can, sm, tq,
 129                 (et->containsUnexpandedParameterPack() ||
 130                  (e && e->containsUnexpandedParameterPack()))),
 131       Context(Context), SizeExpr((Stmt*) e), Brackets(brackets)
 132 {
 133 }
 134
 135 void DependentSizedArrayType::Profile(llvm::FoldingSetNodeID &ID,
 136                                       const ASTContext &Context,
 137                                       QualType ET,
 138                                       ArraySizeModifier SizeMod,
 139                                       unsigned TypeQuals,
 140                                       Expr *E) {
 141   ID.AddPointer(ET.getAsOpaquePtr());
 142   ID.AddInteger(SizeMod);
 143   ID.AddInteger(TypeQuals);
 144   E->Profile(ID, Context, true);
 145 }
 146
 147 DependentSizedExtVectorType::DependentSizedExtVectorType(const
 148                                                          ASTContext &Context,
 149                                                          QualType ElementType,
 150                                                          QualType can,
 151                                                          Expr *SizeExpr,
 152                                                          SourceLocation loc)
 153     : Type(DependentSizedExtVector, can, /*Dependent=*/true,
 154            /*InstantiationDependent=*/true,
 155            ElementType->isVariablyModifiedType(),
 156            (ElementType->containsUnexpandedParameterPack() ||
 157             (SizeExpr && SizeExpr->containsUnexpandedParameterPack()))),
 158       Context(Context), SizeExpr(SizeExpr), ElementType(ElementType),
 159       loc(loc)
 160 {
 161 }
 162
 163 void
 164 DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID,
 165                                      const ASTContext &Context,
 166                                      QualType ElementType, Expr *SizeExpr) {
 167   ID.AddPointer(ElementType.getAsOpaquePtr());
 168   SizeExpr->Profile(ID, Context, true);
 169 }
 170
 171 VectorType::VectorType(QualType vecType, unsigned nElements, QualType canonType,
 172                        VectorKind vecKind)
 173     : VectorType(Vector, vecType, nElements, canonType, vecKind) {}
 174
 175 VectorType::VectorType(TypeClass tc, QualType vecType, unsigned nElements,
 176                        QualType canonType, VectorKind vecKind)
 177   : Type(tc, canonType, vecType->isDependentType(),
 178          vecType->isInstantiationDependentType(),
 179          vecType->isVariablyModifiedType(),
 180          vecType->containsUnexpandedParameterPack()),
 181     ElementType(vecType)
 182 {
 183   VectorTypeBits.VecKind = vecKind;
 184   VectorTypeBits.NumElements = nElements;
 185 }
 186
 187 /// getArrayElementTypeNoTypeQual - If this is an array type, return the
 188 /// element type of the array, potentially with type qualifiers missing.
 189 /// This method should never be used when type qualifiers are meaningful.
 190 const Type *Type::getArrayElementTypeNoTypeQual() const {
 191   // If this is directly an array type, return it.
 192   if (const ArrayType *ATy = dyn_cast<ArrayType>(this))
 193     return ATy->getElementType().getTypePtr();
 194
 195   // If the canonical form of this type isn't the right kind, reject it.
 196   if (!isa<ArrayType>(CanonicalType))
 197     return nullptr;
 198
 199   // If this is a typedef for an array type, strip the typedef off without
 200   // losing all typedef information.
 201   return cast<ArrayType>(getUnqualifiedDesugaredType())
 202     ->getElementType().getTypePtr();
 203 }
 204
 205 /// getDesugaredType - Return the specified type with any "sugar" removed from
 206 /// the type.  This takes off typedefs, typeof's etc.  If the outer level of
 207 /// the type is already concrete, it returns it unmodified.  This is similar
 208 /// to getting the canonical type, but it doesn't remove *all* typedefs.  For
 209 /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
 210 /// concrete.
 211 QualType QualType::getDesugaredType(QualType T, const ASTContext &Context) {
 212   SplitQualType split = getSplitDesugaredType(T);
 213   return Context.getQualifiedType(split.Ty, split.Quals);
 214 }
 215
 216 QualType QualType::getSingleStepDesugaredTypeImpl(QualType type,
 217                                                   const ASTContext &Context) {
 218   SplitQualType split = type.split();
 219   QualType desugar = split.Ty->getLocallyUnqualifiedSingleStepDesugaredType();
 220   return Context.getQualifiedType(desugar, split.Quals);
 221 }
 222
 223 QualType Type::getLocallyUnqualifiedSingleStepDesugaredType() const {
 224   switch (getTypeClass()) {
 225 #define ABSTRACT_TYPE(Class, Parent)
 226 #define TYPE(Class, Parent) \
 227   case Type::Class: { \
 228     const Class##Type *ty = cast<Class##Type>(this); \
 229     if (!ty->isSugared()) return QualType(ty, 0); \
 230     return ty->desugar(); \
 231   }
 232 #include "clang/AST/TypeNodes.def"
 233   }
 234   llvm_unreachable("bad type kind!");
 235 }
 236
 237 SplitQualType QualType::getSplitDesugaredType(QualType T) {
 238   QualifierCollector Qs;
 239
 240   QualType Cur = T;
 241   while (true) {
 242     const Type *CurTy = Qs.strip(Cur);
 243     switch (CurTy->getTypeClass()) {
 244 #define ABSTRACT_TYPE(Class, Parent)
 245 #define TYPE(Class, Parent) \
 246     case Type::Class: { \
 247       const Class##Type *Ty = cast<Class##Type>(CurTy); \
 248       if (!Ty->isSugared()) \
 249         return SplitQualType(Ty, Qs); \
 250       Cur = Ty->desugar(); \
 251       break; \
 252     }
 253 #include "clang/AST/TypeNodes.def"
 254     }
 255   }
 256 }
 257
 258 SplitQualType QualType::getSplitUnqualifiedTypeImpl(QualType type) {
 259   SplitQualType split = type.split();
 260
 261   // All the qualifiers we've seen so far.
 262   Qualifiers quals = split.Quals;
 263
 264   // The last type node we saw with any nodes inside it.
 265   const Type *lastTypeWithQuals = split.Ty;
 266
 267   while (true) {
 268     QualType next;
 269
 270     // Do a single-step desugar, aborting the loop if the type isn't
 271     // sugared.
 272     switch (split.Ty->getTypeClass()) {
 273 #define ABSTRACT_TYPE(Class, Parent)
 274 #define TYPE(Class, Parent) \
 275     case Type::Class: { \
 276       const Class##Type *ty = cast<Class##Type>(split.Ty); \
 277       if (!ty->isSugared()) goto done; \
 278       next = ty->desugar(); \
 279       break; \
 280     }
 281 #include "clang/AST/TypeNodes.def"
 282     }
 283
 284     // Otherwise, split the underlying type.  If that yields qualifiers,
 285     // update the information.
 286     split = next.split();
 287     if (!split.Quals.empty()) {
 288       lastTypeWithQuals = split.Ty;
 289       quals.addConsistentQualifiers(split.Quals);
 290     }
 291   }
 292
 293  done:
 294   return SplitQualType(lastTypeWithQuals, quals);
 295 }
 296
 297 QualType QualType::IgnoreParens(QualType T) {
 298   // FIXME: this seems inherently un-qualifiers-safe.
 299   while (const ParenType *PT = T->getAs<ParenType>())
 300     T = PT->getInnerType();
 301   return T;
 302 }
 303
 304 /// \brief This will check for a T (which should be a Type which can act as
 305 /// sugar, such as a TypedefType) by removing any existing sugar until it
 306 /// reaches a T or a non-sugared type.
 307 template<typename T> static const T *getAsSugar(const Type *Cur) {
 308   while (true) {
 309     if (const T *Sugar = dyn_cast<T>(Cur))
 310       return Sugar;
 311     switch (Cur->getTypeClass()) {
 312 #define ABSTRACT_TYPE(Class, Parent)
 313 #define TYPE(Class, Parent) \
 314     case Type::Class: { \
 315       const Class##Type *Ty = cast<Class##Type>(Cur); \
 316       if (!Ty->isSugared()) return 0; \
 317       Cur = Ty->desugar().getTypePtr(); \
 318       break; \
 319     }
 320 #include "clang/AST/TypeNodes.def"
 321     }
 322   }
 323 }
 324
 325 template <> const TypedefType *Type::getAs() const {
 326   return getAsSugar<TypedefType>(this);
 327 }
 328
 329 template <> const TemplateSpecializationType *Type::getAs() const {
 330   return getAsSugar<TemplateSpecializationType>(this);
 331 }
 332
 333 template <> const AttributedType *Type::getAs() const {
 334   return getAsSugar<AttributedType>(this);
 335 }
 336
 337 /// getUnqualifiedDesugaredType - Pull any qualifiers and syntactic
 338 /// sugar off the given type.  This should produce an object of the
 339 /// same dynamic type as the canonical type.
 340 const Type *Type::getUnqualifiedDesugaredType() const {
 341   const Type *Cur = this;
 342
 343   while (true) {
 344     switch (Cur->getTypeClass()) {
 345 #define ABSTRACT_TYPE(Class, Parent)
 346 #define TYPE(Class, Parent) \
 347     case Class: { \
 348       const Class##Type *Ty = cast<Class##Type>(Cur); \
 349       if (!Ty->isSugared()) return Cur; \
 350       Cur = Ty->desugar().getTypePtr(); \
 351       break; \
 352     }
 353 #include "clang/AST/TypeNodes.def"
 354     }
 355   }
 356 }
 357 bool Type::isClassType() const {
 358   if (const RecordType *RT = getAs<RecordType>())
 359     return RT->getDecl()->isClass();
 360   return false;
 361 }
 362 bool Type::isStructureType() const {
 363   if (const RecordType *RT = getAs<RecordType>())
 364     return RT->getDecl()->isStruct();
 365   return false;
 366 }
 367 bool Type::isInterfaceType() const {
 368   if (const RecordType *RT = getAs<RecordType>())
 369     return RT->getDecl()->isInterface();
 370   return false;
 371 }
 372 bool Type::isStructureOrClassType() const {
 373   if (const RecordType *RT = getAs<RecordType>()) {
 374     RecordDecl *RD = RT->getDecl();
 375     return RD->isStruct() || RD->isClass() || RD->isInterface();
 376   }
 377   return false;
 378 }
 379 bool Type::isVoidPointerType() const {
 380   if (const PointerType *PT = getAs<PointerType>())
 381     return PT->getPointeeType()->isVoidType();
 382   return false;
 383 }
 384
 385 bool Type::isUnionType() const {
 386   if (const RecordType *RT = getAs<RecordType>())
 387     return RT->getDecl()->isUnion();
 388   return false;
 389 }
 390
 391 bool Type::isComplexType() const {
 392   if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType))
 393     return CT->getElementType()->isFloatingType();
 394   return false;
 395 }
 396
 397 bool Type::isComplexIntegerType() const {
 398   // Check for GCC complex integer extension.
 399   return getAsComplexIntegerType();
 400 }
 401
 402 const ComplexType *Type::getAsComplexIntegerType() const {
 403   if (const ComplexType *Complex = getAs<ComplexType>())
 404     if (Complex->getElementType()->isIntegerType())
 405       return Complex;
 406   return nullptr;
 407 }
 408
 409 QualType Type::getPointeeType() const {
 410   if (const PointerType *PT = getAs<PointerType>())
 411     return PT->getPointeeType();
 412   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>())
 413     return OPT->getPointeeType();
 414   if (const BlockPointerType *BPT = getAs<BlockPointerType>())
 415     return BPT->getPointeeType();
 416   if (const ReferenceType *RT = getAs<ReferenceType>())
 417     return RT->getPointeeType();
 418   if (const MemberPointerType *MPT = getAs<MemberPointerType>())
 419     return MPT->getPointeeType();
 420   if (const DecayedType *DT = getAs<DecayedType>())
 421     return DT->getPointeeType();
 422   return QualType();
 423 }
 424
 425 const RecordType *Type::getAsStructureType() const {
 426   // If this is directly a structure type, return it.
 427   if (const RecordType *RT = dyn_cast<RecordType>(this)) {
 428     if (RT->getDecl()->isStruct())
 429       return RT;
 430   }
 431
 432   // If the canonical form of this type isn't the right kind, reject it.
 433   if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) {
 434     if (!RT->getDecl()->isStruct())
 435       return nullptr;
 436
 437     // If this is a typedef for a structure type, strip the typedef off without
 438     // losing all typedef information.
 439     return cast<RecordType>(getUnqualifiedDesugaredType());
 440   }
 441   return nullptr;
 442 }
 443
 444 const RecordType *Type::getAsUnionType() const {
 445   // If this is directly a union type, return it.
 446   if (const RecordType *RT = dyn_cast<RecordType>(this)) {
 447     if (RT->getDecl()->isUnion())
 448       return RT;
 449   }
 450
 451   // If the canonical form of this type isn't the right kind, reject it.
 452   if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) {
 453     if (!RT->getDecl()->isUnion())
 454       return nullptr;
 455
 456     // If this is a typedef for a union type, strip the typedef off without
 457     // losing all typedef information.
 458     return cast<RecordType>(getUnqualifiedDesugaredType());
 459   }
 460
 461   return nullptr;
 462 }
 463
 464 ObjCObjectType::ObjCObjectType(QualType Canonical, QualType Base,
 465                                ObjCProtocolDecl * const *Protocols,
 466                                unsigned NumProtocols)
 467   : Type(ObjCObject, Canonical, false, false, false, false),
 468     BaseType(Base)
 469 {
 470   ObjCObjectTypeBits.NumProtocols = NumProtocols;
 471   assert(getNumProtocols() == NumProtocols &&
 472          "bitfield overflow in protocol count");
 473   if (NumProtocols)
 474     memcpy(getProtocolStorage(), Protocols,
 475            NumProtocols * sizeof(ObjCProtocolDecl*));
 476 }
 477
 478 const ObjCObjectType *Type::getAsObjCQualifiedInterfaceType() const {
 479   // There is no sugar for ObjCObjectType's, just return the canonical
 480   // type pointer if it is the right class.  There is no typedef information to
 481   // return and these cannot be Address-space qualified.
 482   if (const ObjCObjectType *T = getAs<ObjCObjectType>())
 483     if (T->getNumProtocols() && T->getInterface())
 484       return T;
 485   return nullptr;
 486 }
 487
 488 bool Type::isObjCQualifiedInterfaceType() const {
 489   return getAsObjCQualifiedInterfaceType() != nullptr;
 490 }
 491
 492 const ObjCObjectPointerType *Type::getAsObjCQualifiedIdType() const {
 493   // There is no sugar for ObjCQualifiedIdType's, just return the canonical
 494   // type pointer if it is the right class.
 495   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) {
 496     if (OPT->isObjCQualifiedIdType())
 497       return OPT;
 498   }
 499   return nullptr;
 500 }
 501
 502 const ObjCObjectPointerType *Type::getAsObjCQualifiedClassType() const {
 503   // There is no sugar for ObjCQualifiedClassType's, just return the canonical
 504   // type pointer if it is the right class.
 505   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) {
 506     if (OPT->isObjCQualifiedClassType())
 507       return OPT;
 508   }
 509   return nullptr;
 510 }
 511
 512 const ObjCObjectPointerType *Type::getAsObjCInterfacePointerType() const {
 513   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) {
 514     if (OPT->getInterfaceType())
 515       return OPT;
 516   }
 517   return nullptr;
 518 }
 519
 520 const CXXRecordDecl *Type::getPointeeCXXRecordDecl() const {
 521   QualType PointeeType;
 522   if (const PointerType *PT = getAs<PointerType>())
 523     PointeeType = PT->getPointeeType();
 524   else if (const ReferenceType *RT = getAs<ReferenceType>())
 525     PointeeType = RT->getPointeeType();
 526   else
 527     return nullptr;
 528
 529   if (const RecordType *RT = PointeeType->getAs<RecordType>())
 530     return dyn_cast<CXXRecordDecl>(RT->getDecl());
 531
 532   return nullptr;
 533 }
 534
 535 CXXRecordDecl *Type::getAsCXXRecordDecl() const {
 536   return dyn_cast_or_null<CXXRecordDecl>(getAsTagDecl());
 537 }
 538
 539 TagDecl *Type::getAsTagDecl() const {
 540   if (const auto *TT = getAs<TagType>())
 541     return cast<TagDecl>(TT->getDecl());
 542   if (const auto *Injected = getAs<InjectedClassNameType>())
 543     return Injected->getDecl();
 544
 545   return nullptr;
 546 }
 547
 548 namespace {
 549   class GetContainedAutoVisitor :
 550     public TypeVisitor<GetContainedAutoVisitor, AutoType*> {
 551   public:
 552     using TypeVisitor<GetContainedAutoVisitor, AutoType*>::Visit;
 553     AutoType *Visit(QualType T) {
 554       if (T.isNull())
 555         return nullptr;
 556       return Visit(T.getTypePtr());
 557     }
 558
 559     // The 'auto' type itself.
 560     AutoType *VisitAutoType(const AutoType *AT) {
 561       return const_cast<AutoType*>(AT);
 562     }
 563
 564     // Only these types can contain the desired 'auto' type.
 565     AutoType *VisitPointerType(const PointerType *T) {
 566       return Visit(T->getPointeeType());
 567     }
 568     AutoType *VisitBlockPointerType(const BlockPointerType *T) {
 569       return Visit(T->getPointeeType());
 570     }
 571     AutoType *VisitReferenceType(const ReferenceType *T) {
 572       return Visit(T->getPointeeTypeAsWritten());
 573     }
 574     AutoType *VisitMemberPointerType(const MemberPointerType *T) {
 575       return Visit(T->getPointeeType());
 576     }
 577     AutoType *VisitArrayType(const ArrayType *T) {
 578       return Visit(T->getElementType());
 579     }
 580     AutoType *VisitDependentSizedExtVectorType(
 581       const DependentSizedExtVectorType *T) {
 582       return Visit(T->getElementType());
 583     }
 584     AutoType *VisitVectorType(const VectorType *T) {
 585       return Visit(T->getElementType());
 586     }
 587     AutoType *VisitFunctionType(const FunctionType *T) {
 588       return Visit(T->getReturnType());
 589     }
 590     AutoType *VisitParenType(const ParenType *T) {
 591       return Visit(T->getInnerType());
 592     }
 593     AutoType *VisitAttributedType(const AttributedType *T) {
 594       return Visit(T->getModifiedType());
 595     }
 596     AutoType *VisitAdjustedType(const AdjustedType *T) {
 597       return Visit(T->getOriginalType());
 598     }
 599   };
 600 }
 601
 602 AutoType *Type::getContainedAutoType() const {
 603   return GetContainedAutoVisitor().Visit(this);
 604 }
 605
 606 bool Type::hasIntegerRepresentation() const {
 607   if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
 608     return VT->getElementType()->isIntegerType();
 609   else
 610     return isIntegerType();
 611 }
 612
 613 /// \brief Determine whether this type is an integral type.
 614 ///
 615 /// This routine determines whether the given type is an integral type per
 616 /// C++ [basic.fundamental]p7. Although the C standard does not define the
 617 /// term "integral type", it has a similar term "integer type", and in C++
 618 /// the two terms are equivalent. However, C's "integer type" includes
 619 /// enumeration types, while C++'s "integer type" does not. The \c ASTContext
 620 /// parameter is used to determine whether we should be following the C or
 621 /// C++ rules when determining whether this type is an integral/integer type.
 622 ///
 623 /// For cases where C permits "an integer type" and C++ permits "an integral
 624 /// type", use this routine.
 625 ///
 626 /// For cases where C permits "an integer type" and C++ permits "an integral
 627 /// or enumeration type", use \c isIntegralOrEnumerationType() instead.
 628 ///
 629 /// \param Ctx The context in which this type occurs.
 630 ///
 631 /// \returns true if the type is considered an integral type, false otherwise.
 632 bool Type::isIntegralType(ASTContext &Ctx) const {
 633   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
 634     return BT->getKind() >= BuiltinType::Bool &&
 635            BT->getKind() <= BuiltinType::Int128;
 636
 637   // Complete enum types are integral in C.
 638   if (!Ctx.getLangOpts().CPlusPlus)
 639     if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
 640       return ET->getDecl()->isComplete();
 641
 642   return false;
 643 }
 644
 645
 646 bool Type::isIntegralOrUnscopedEnumerationType() const {
 647   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
 648     return BT->getKind() >= BuiltinType::Bool &&
 649            BT->getKind() <= BuiltinType::Int128;
 650
 651   // Check for a complete enum type; incomplete enum types are not properly an
 652   // enumeration type in the sense required here.
 653   // C++0x: However, if the underlying type of the enum is fixed, it is
 654   // considered complete.
 655   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
 656     return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
 657
 658   return false;
 659 }
 660
 661
 662
 663 bool Type::isCharType() const {
 664   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
 665     return BT->getKind() == BuiltinType::Char_U ||
 666            BT->getKind() == BuiltinType::UChar ||
 667            BT->getKind() == BuiltinType::Char_S ||
 668            BT->getKind() == BuiltinType::SChar;
 669   return false;
 670 }
 671
 672 bool Type::isWideCharType() const {
 673   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
 674     return BT->getKind() == BuiltinType::WChar_S ||
 675            BT->getKind() == BuiltinType::WChar_U;
 676   return false;
 677 }
 678
 679 bool Type::isChar16Type() const {
 680   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
 681     return BT->getKind() == BuiltinType::Char16;
 682   return false;
 683 }
 684
 685 bool Type::isChar32Type() const {
 686   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
 687     return BT->getKind() == BuiltinType::Char32;
 688   return false;
 689 }
 690
 691 /// \brief Determine whether this type is any of the built-in character
 692 /// types.
 693 bool Type::isAnyCharacterType() const {
 694   const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType);
 695   if (!BT) return false;
 696   switch (BT->getKind()) {
 697   default: return false;
 698   case BuiltinType::Char_U:
 699   case BuiltinType::UChar:
 700   case BuiltinType::WChar_U:
 701   case BuiltinType::Char16:
 702   case BuiltinType::Char32:
 703   case BuiltinType::Char_S:
 704   case BuiltinType::SChar:
 705   case BuiltinType::WChar_S:
 706     return true;
 707   }
 708 }
 709
 710 /// isSignedIntegerType - Return true if this is an integer type that is
 711 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
 712 /// an enum decl which has a signed representation
 713 bool Type::isSignedIntegerType() const {
 714   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
 715     return BT->getKind() >= BuiltinType::Char_S &&
 716            BT->getKind() <= BuiltinType::Int128;
 717   }
 718
 719   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
 720     // Incomplete enum types are not treated as integer types.
 721     // FIXME: In C++, enum types are never integer types.
 722     if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
 723       return ET->getDecl()->getIntegerType()->isSignedIntegerType();
 724   }
 725
 726   return false;
 727 }
 728
 729 bool Type::isSignedIntegerOrEnumerationType() const {
 730   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
 731     return BT->getKind() >= BuiltinType::Char_S &&
 732            BT->getKind() <= BuiltinType::Int128;
 733   }
 734
 735   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
 736     if (ET->getDecl()->isComplete())
 737       return ET->getDecl()->getIntegerType()->isSignedIntegerType();
 738   }
 739
 740   return false;
 741 }
 742
 743 bool Type::hasSignedIntegerRepresentation() const {
 744   if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
 745     return VT->getElementType()->isSignedIntegerOrEnumerationType();
 746   else
 747     return isSignedIntegerOrEnumerationType();
 748 }
 749
 750 /// isUnsignedIntegerType - Return true if this is an integer type that is
 751 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum
 752 /// decl which has an unsigned representation
 753 bool Type::isUnsignedIntegerType() const {
 754   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
 755     return BT->getKind() >= BuiltinType::Bool &&
 756            BT->getKind() <= BuiltinType::UInt128;
 757   }
 758
 759   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
 760     // Incomplete enum types are not treated as integer types.
 761     // FIXME: In C++, enum types are never integer types.
 762     if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
 763       return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
 764   }
 765
 766   return false;
 767 }
 768
 769 bool Type::isUnsignedIntegerOrEnumerationType() const {
 770   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
 771     return BT->getKind() >= BuiltinType::Bool &&
 772     BT->getKind() <= BuiltinType::UInt128;
 773   }
 774
 775   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
 776     if (ET->getDecl()->isComplete())
 777       return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
 778   }
 779
 780   return false;
 781 }
 782
 783 bool Type::hasUnsignedIntegerRepresentation() const {
 784   if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
 785     return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
 786   else
 787     return isUnsignedIntegerOrEnumerationType();
 788 }
 789
 790 bool Type::isFloatingType() const {
 791   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
 792     return BT->getKind() >= BuiltinType::Half &&
 793            BT->getKind() <= BuiltinType::LongDouble;
 794   if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType))
 795     return CT->getElementType()->isFloatingType();
 796   return false;
 797 }
 798
 799 bool Type::hasFloatingRepresentation() const {
 800   if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
 801     return VT->getElementType()->isFloatingType();
 802   else
 803     return isFloatingType();
 804 }
 805
 806 bool Type::isRealFloatingType() const {
 807   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
 808     return BT->isFloatingPoint();
 809   return false;
 810 }
 811
 812 bool Type::isRealType() const {
 813   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
 814     return BT->getKind() >= BuiltinType::Bool &&
 815            BT->getKind() <= BuiltinType::LongDouble;
 816   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
 817       return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
 818   return false;
 819 }
 820
 821 bool Type::isArithmeticType() const {
 822   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
 823     return BT->getKind() >= BuiltinType::Bool &&
 824            BT->getKind() <= BuiltinType::LongDouble;
 825   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
 826     // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2).
 827     // If a body isn't seen by the time we get here, return false.
 828     //
 829     // C++0x: Enumerations are not arithmetic types. For now, just return
 830     // false for scoped enumerations since that will disable any
 831     // unwanted implicit conversions.
 832     return !ET->getDecl()->isScoped() && ET->getDecl()->isComplete();
 833   return isa<ComplexType>(CanonicalType);
 834 }
 835
 836 Type::ScalarTypeKind Type::getScalarTypeKind() const {
 837   assert(isScalarType());
 838
 839   const Type *T = CanonicalType.getTypePtr();
 840   if (const BuiltinType *BT = dyn_cast<BuiltinType>(T)) {
 841     if (BT->getKind() == BuiltinType::Bool) return STK_Bool;
 842     if (BT->getKind() == BuiltinType::NullPtr) return STK_CPointer;
 843     if (BT->isInteger()) return STK_Integral;
 844     if (BT->isFloatingPoint()) return STK_Floating;
 845     llvm_unreachable("unknown scalar builtin type");
 846   } else if (isa<PointerType>(T)) {
 847     return STK_CPointer;
 848   } else if (isa<BlockPointerType>(T)) {
 849     return STK_BlockPointer;
 850   } else if (isa<ObjCObjectPointerType>(T)) {
 851     return STK_ObjCObjectPointer;
 852   } else if (isa<MemberPointerType>(T)) {
 853     return STK_MemberPointer;
 854   } else if (isa<EnumType>(T)) {
 855     assert(cast<EnumType>(T)->getDecl()->isComplete());
 856     return STK_Integral;
 857   } else if (const ComplexType *CT = dyn_cast<ComplexType>(T)) {
 858     if (CT->getElementType()->isRealFloatingType())
 859       return STK_FloatingComplex;
 860     return STK_IntegralComplex;
 861   }
 862
 863   llvm_unreachable("unknown scalar type");
 864 }
 865
 866 /// \brief Determines whether the type is a C++ aggregate type or C
 867 /// aggregate or union type.
 868 ///
 869 /// An aggregate type is an array or a class type (struct, union, or
 870 /// class) that has no user-declared constructors, no private or
 871 /// protected non-static data members, no base classes, and no virtual
 872 /// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type
 873 /// subsumes the notion of C aggregates (C99 6.2.5p21) because it also
 874 /// includes union types.
 875 bool Type::isAggregateType() const {
 876   if (const RecordType *Record = dyn_cast<RecordType>(CanonicalType)) {
 877     if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl()))
 878       return ClassDecl->isAggregate();
 879
 880     return true;
 881   }
 882
 883   return isa<ArrayType>(CanonicalType);
 884 }
 885
 886 /// isConstantSizeType - Return true if this is not a variable sized type,
 887 /// according to the rules of C99 6.7.5p3.  It is not legal to call this on
 888 /// incomplete types or dependent types.
 889 bool Type::isConstantSizeType() const {
 890   assert(!isIncompleteType() && "This doesn't make sense for incomplete types");
 891   assert(!isDependentType() && "This doesn't make sense for dependent types");
 892   // The VAT must have a size, as it is known to be complete.
 893   return !isa<VariableArrayType>(CanonicalType);
 894 }
 895
 896 /// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1)
 897 /// - a type that can describe objects, but which lacks information needed to
 898 /// determine its size.
 899 bool Type::isIncompleteType(NamedDecl **Def) const {
 900   if (Def)
 901     *Def = nullptr;
 902
 903   switch (CanonicalType->getTypeClass()) {
 904   default: return false;
 905   case Builtin:
 906     // Void is the only incomplete builtin type.  Per C99 6.2.5p19, it can never
 907     // be completed.
 908     return isVoidType();
 909   case Enum: {
 910     EnumDecl *EnumD = cast<EnumType>(CanonicalType)->getDecl();
 911     if (Def)
 912       *Def = EnumD;
 913
 914     // An enumeration with fixed underlying type is complete (C++0x 7.2p3).
 915     if (EnumD->isFixed())
 916       return false;
 917
 918     return !EnumD->isCompleteDefinition();
 919   }
 920   case Record: {
 921     // A tagged type (struct/union/enum/class) is incomplete if the decl is a
 922     // forward declaration, but not a full definition (C99 6.2.5p22).
 923     RecordDecl *Rec = cast<RecordType>(CanonicalType)->getDecl();
 924     if (Def)
 925       *Def = Rec;
 926     return !Rec->isCompleteDefinition();
 927   }
 928   case ConstantArray:
 929     // An array is incomplete if its element type is incomplete
 930     // (C++ [dcl.array]p1).
 931     // We don't handle variable arrays (they're not allowed in C++) or
 932     // dependent-sized arrays (dependent types are never treated as incomplete).
 933     return cast<ArrayType>(CanonicalType)->getElementType()
 934              ->isIncompleteType(Def);
 935   case IncompleteArray:
 936     // An array of unknown size is an incomplete type (C99 6.2.5p22).
 937     return true;
 938   case ObjCObject:
 939     return cast<ObjCObjectType>(CanonicalType)->getBaseType()
 940              ->isIncompleteType(Def);
 941   case ObjCInterface: {
 942     // ObjC interfaces are incomplete if they are @class, not @interface.
 943     ObjCInterfaceDecl *Interface
 944       = cast<ObjCInterfaceType>(CanonicalType)->getDecl();
 945     if (Def)
 946       *Def = Interface;
 947     return !Interface->hasDefinition();
 948   }
 949   }
 950 }
 951
 952 bool QualType::isPODType(ASTContext &Context) const {
 953   // C++11 has a more relaxed definition of POD.
 954   if (Context.getLangOpts().CPlusPlus11)
 955     return isCXX11PODType(Context);
 956
 957   return isCXX98PODType(Context);
 958 }
 959
 960 bool QualType::isCXX98PODType(ASTContext &Context) const {
 961   // The compiler shouldn't query this for incomplete types, but the user might.
 962   // We return false for that case. Except for incomplete arrays of PODs, which
 963   // are PODs according to the standard.
 964   if (isNull())
 965     return 0;
 966
 967   if ((*this)->isIncompleteArrayType())
 968     return Context.getBaseElementType(*this).isCXX98PODType(Context);
 969
 970   if ((*this)->isIncompleteType())
 971     return false;
 972
 973   if (Context.getLangOpts().ObjCAutoRefCount) {
 974     switch (getObjCLifetime()) {
 975     case Qualifiers::OCL_ExplicitNone:
 976       return true;
 977
 978     case Qualifiers::OCL_Strong:
 979     case Qualifiers::OCL_Weak:
 980     case Qualifiers::OCL_Autoreleasing:
 981       return false;
 982
 983     case Qualifiers::OCL_None:
 984       break;
 985     }
 986   }
 987
 988   QualType CanonicalType = getTypePtr()->CanonicalType;
 989   switch (CanonicalType->getTypeClass()) {
 990     // Everything not explicitly mentioned is not POD.
 991   default: return false;
 992   case Type::VariableArray:
 993   case Type::ConstantArray:
 994     // IncompleteArray is handled above.
 995     return Context.getBaseElementType(*this).isCXX98PODType(Context);
 996
 997   case Type::ObjCObjectPointer:
 998   case Type::BlockPointer:
 999   case Type::Builtin:
1000   case Type::Complex:
1001   case Type::Pointer:
1002   case Type::MemberPointer:
1003   case Type::Vector:
1004   case Type::ExtVector:
1005     return true;
1006
1007   case Type::Enum:
1008     return true;
1009
1010   case Type::Record:
1011     if (CXXRecordDecl *ClassDecl
1012           = dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl()))
1013       return ClassDecl->isPOD();
1014
1015     // C struct/union is POD.
1016     return true;
1017   }
1018 }
1019
1020 bool QualType::isTrivialType(ASTContext &Context) const {
1021   // The compiler shouldn't query this for incomplete types, but the user might.
1022   // We return false for that case. Except for incomplete arrays of PODs, which
1023   // are PODs according to the standard.
1024   if (isNull())
1025     return 0;
1026
1027   if ((*this)->isArrayType())
1028     return Context.getBaseElementType(*this).isTrivialType(Context);
1029
1030   // Return false for incomplete types after skipping any incomplete array
1031   // types which are expressly allowed by the standard and thus our API.
1032   if ((*this)->isIncompleteType())
1033     return false;
1034
1035   if (Context.getLangOpts().ObjCAutoRefCount) {
1036     switch (getObjCLifetime()) {
1037     case Qualifiers::OCL_ExplicitNone:
1038       return true;
1039
1040     case Qualifiers::OCL_Strong:
1041     case Qualifiers::OCL_Weak:
1042     case Qualifiers::OCL_Autoreleasing:
1043       return false;
1044
1045     case Qualifiers::OCL_None:
1046       if ((*this)->isObjCLifetimeType())
1047         return false;
1048       break;
1049     }
1050   }
1051
1052   QualType CanonicalType = getTypePtr()->CanonicalType;
1053   if (CanonicalType->isDependentType())
1054     return false;
1055
1056   // C++0x [basic.types]p9:
1057   //   Scalar types, trivial class types, arrays of such types, and
1058   //   cv-qualified versions of these types are collectively called trivial
1059   //   types.
1060
1061   // As an extension, Clang treats vector types as Scalar types.
1062   if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
1063     return true;
1064   if (const RecordType *RT = CanonicalType->getAs<RecordType>()) {
1065     if (const CXXRecordDecl *ClassDecl =
1066         dyn_cast<CXXRecordDecl>(RT->getDecl())) {
1067       // C++11 [class]p6:
1068       //   A trivial class is a class that has a default constructor,
1069       //   has no non-trivial default constructors, and is trivially
1070       //   copyable.
1071       return ClassDecl->hasDefaultConstructor() &&
1072              !ClassDecl->hasNonTrivialDefaultConstructor() &&
1073              ClassDecl->isTriviallyCopyable();
1074     }
1075
1076     return true;
1077   }
1078
1079   // No other types can match.
1080   return false;
1081 }
1082
1083 bool QualType::isTriviallyCopyableType(ASTContext &Context) const {
1084   if ((*this)->isArrayType())
1085     return Context.getBaseElementType(*this).isTriviallyCopyableType(Context);
1086
1087   if (Context.getLangOpts().ObjCAutoRefCount) {
1088     switch (getObjCLifetime()) {
1089     case Qualifiers::OCL_ExplicitNone:
1090       return true;
1091
1092     case Qualifiers::OCL_Strong:
1093     case Qualifiers::OCL_Weak:
1094     case Qualifiers::OCL_Autoreleasing:
1095       return false;
1096
1097     case Qualifiers::OCL_None:
1098       if ((*this)->isObjCLifetimeType())
1099         return false;
1100       break;
1101     }
1102   }
1103
1104   // C++11 [basic.types]p9
1105   //   Scalar types, trivially copyable class types, arrays of such types, and
1106   //   non-volatile const-qualified versions of these types are collectively
1107   //   called trivially copyable types.
1108
1109   QualType CanonicalType = getCanonicalType();
1110   if (CanonicalType->isDependentType())
1111     return false;
1112
1113   if (CanonicalType.isVolatileQualified())
1114     return false;
1115
1116   // Return false for incomplete types after skipping any incomplete array types
1117   // which are expressly allowed by the standard and thus our API.
1118   if (CanonicalType->isIncompleteType())
1119     return false;
1120
1121   // As an extension, Clang treats vector types as Scalar types.
1122   if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
1123     return true;
1124
1125   if (const RecordType *RT = CanonicalType->getAs<RecordType>()) {
1126     if (const CXXRecordDecl *ClassDecl =
1127           dyn_cast<CXXRecordDecl>(RT->getDecl())) {
1128       if (!ClassDecl->isTriviallyCopyable()) return false;
1129     }
1130
1131     return true;
1132   }
1133
1134   // No other types can match.
1135   return false;
1136 }
1137
1138
1139
1140 bool Type::isLiteralType(const ASTContext &Ctx) const {
1141   if (isDependentType())
1142     return false;
1143
1144   // C++1y [basic.types]p10:
1145   //   A type is a literal type if it is:
1146   //   -- cv void; or
1147   if (Ctx.getLangOpts().CPlusPlus14 && isVoidType())
1148     return true;
1149
1150   // C++11 [basic.types]p10:
1151   //   A type is a literal type if it is:
1152   //   [...]
1153   //   -- an array of literal type other than an array of runtime bound; or
1154   if (isVariableArrayType())
1155     return false;
1156   const Type *BaseTy = getBaseElementTypeUnsafe();
1157   assert(BaseTy && "NULL element type");
1158
1159   // Return false for incomplete types after skipping any incomplete array
1160   // types; those are expressly allowed by the standard and thus our API.
1161   if (BaseTy->isIncompleteType())
1162     return false;
1163
1164   // C++11 [basic.types]p10:
1165   //   A type is a literal type if it is:
1166   //    -- a scalar type; or
1167   // As an extension, Clang treats vector types and complex types as
1168   // literal types.
1169   if (BaseTy->isScalarType() || BaseTy->isVectorType() ||
1170       BaseTy->isAnyComplexType())
1171     return true;
1172   //    -- a reference type; or
1173   if (BaseTy->isReferenceType())
1174     return true;
1175   //    -- a class type that has all of the following properties:
1176   if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
1177     //    -- a trivial destructor,
1178     //    -- every constructor call and full-expression in the
1179     //       brace-or-equal-initializers for non-static data members (if any)
1180     //       is a constant expression,
1181     //    -- it is an aggregate type or has at least one constexpr
1182     //       constructor or constructor template that is not a copy or move
1183     //       constructor, and
1184     //    -- all non-static data members and base classes of literal types
1185     //
1186     // We resolve DR1361 by ignoring the second bullet.
1187     if (const CXXRecordDecl *ClassDecl =
1188         dyn_cast<CXXRecordDecl>(RT->getDecl()))
1189       return ClassDecl->isLiteral();
1190
1191     return true;
1192   }
1193
1194   // We treat _Atomic T as a literal type if T is a literal type.
1195   if (const AtomicType *AT = BaseTy->getAs<AtomicType>())
1196     return AT->getValueType()->isLiteralType(Ctx);
1197
1198   // If this type hasn't been deduced yet, then conservatively assume that
1199   // it'll work out to be a literal type.
1200   if (isa<AutoType>(BaseTy->getCanonicalTypeInternal()))
1201     return true;
1202
1203   return false;
1204 }
1205
1206 bool Type::isStandardLayoutType() const {
1207   if (isDependentType())
1208     return false;
1209
1210   // C++0x [basic.types]p9:
1211   //   Scalar types, standard-layout class types, arrays of such types, and
1212   //   cv-qualified versions of these types are collectively called
1213   //   standard-layout types.
1214   const Type *BaseTy = getBaseElementTypeUnsafe();
1215   assert(BaseTy && "NULL element type");
1216
1217   // Return false for incomplete types after skipping any incomplete array
1218   // types which are expressly allowed by the standard and thus our API.
1219   if (BaseTy->isIncompleteType())
1220     return false;
1221
1222   // As an extension, Clang treats vector types as Scalar types.
1223   if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
1224   if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
1225     if (const CXXRecordDecl *ClassDecl =
1226         dyn_cast<CXXRecordDecl>(RT->getDecl()))
1227       if (!ClassDecl->isStandardLayout())
1228         return false;
1229
1230     // Default to 'true' for non-C++ class types.
1231     // FIXME: This is a bit dubious, but plain C structs should trivially meet
1232     // all the requirements of standard layout classes.
1233     return true;
1234   }
1235
1236   // No other types can match.
1237   return false;
1238 }
1239
1240 // This is effectively the intersection of isTrivialType and
1241 // isStandardLayoutType. We implement it directly to avoid redundant
1242 // conversions from a type to a CXXRecordDecl.
1243 bool QualType::isCXX11PODType(ASTContext &Context) const {
1244   const Type *ty = getTypePtr();
1245   if (ty->isDependentType())
1246     return false;
1247
1248   if (Context.getLangOpts().ObjCAutoRefCount) {
1249     switch (getObjCLifetime()) {
1250     case Qualifiers::OCL_ExplicitNone:
1251       return true;
1252
1253     case Qualifiers::OCL_Strong:
1254     case Qualifiers::OCL_Weak:
1255     case Qualifiers::OCL_Autoreleasing:
1256       return false;
1257
1258     case Qualifiers::OCL_None:
1259       break;
1260     }
1261   }
1262
1263   // C++11 [basic.types]p9:
1264   //   Scalar types, POD classes, arrays of such types, and cv-qualified
1265   //   versions of these types are collectively called trivial types.
1266   const Type *BaseTy = ty->getBaseElementTypeUnsafe();
1267   assert(BaseTy && "NULL element type");
1268
1269   // Return false for incomplete types after skipping any incomplete array
1270   // types which are expressly allowed by the standard and thus our API.
1271   if (BaseTy->isIncompleteType())
1272     return false;
1273
1274   // As an extension, Clang treats vector types as Scalar types.
1275   if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
1276   if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
1277     if (const CXXRecordDecl *ClassDecl =
1278         dyn_cast<CXXRecordDecl>(RT->getDecl())) {
1279       // C++11 [class]p10:
1280       //   A POD struct is a non-union class that is both a trivial class [...]
1281       if (!ClassDecl->isTrivial()) return false;
1282
1283       // C++11 [class]p10:
1284       //   A POD struct is a non-union class that is both a trivial class and
1285       //   a standard-layout class [...]
1286       if (!ClassDecl->isStandardLayout()) return false;
1287
1288       // C++11 [class]p10:
1289       //   A POD struct is a non-union class that is both a trivial class and
1290       //   a standard-layout class, and has no non-static data members of type
1291       //   non-POD struct, non-POD union (or array of such types). [...]
1292       //
1293       // We don't directly query the recursive aspect as the requiremets for
1294       // both standard-layout classes and trivial classes apply recursively
1295       // already.
1296     }
1297
1298     return true;
1299   }
1300
1301   // No other types can match.
1302   return false;
1303 }
1304
1305 bool Type::isPromotableIntegerType() const {
1306   if (const BuiltinType *BT = getAs<BuiltinType>())
1307     switch (BT->getKind()) {
1308     case BuiltinType::Bool:
1309     case BuiltinType::Char_S:
1310     case BuiltinType::Char_U:
1311     case BuiltinType::SChar:
1312     case BuiltinType::UChar:
1313     case BuiltinType::Short:
1314     case BuiltinType::UShort:
1315     case BuiltinType::WChar_S:
1316     case BuiltinType::WChar_U:
1317     case BuiltinType::Char16:
1318     case BuiltinType::Char32:
1319       return true;
1320     default:
1321       return false;
1322     }
1323
1324   // Enumerated types are promotable to their compatible integer types
1325   // (C99 6.3.1.1) a.k.a. its underlying type (C++ [conv.prom]p2).
1326   if (const EnumType *ET = getAs<EnumType>()){
1327     if (this->isDependentType() || ET->getDecl()->getPromotionType().isNull()
1328         || ET->getDecl()->isScoped())
1329       return false;
1330
1331     return true;
1332   }
1333
1334   return false;
1335 }
1336
1337 bool Type::isSpecifierType() const {
1338   // Note that this intentionally does not use the canonical type.
1339   switch (getTypeClass()) {
1340   case Builtin:
1341   case Record:
1342   case Enum:
1343   case Typedef:
1344   case Complex:
1345   case TypeOfExpr:
1346   case TypeOf:
1347   case TemplateTypeParm:
1348   case SubstTemplateTypeParm:
1349   case TemplateSpecialization:
1350   case Elaborated:
1351   case DependentName:
1352   case DependentTemplateSpecialization:
1353   case ObjCInterface:
1354   case ObjCObject:
1355   case ObjCObjectPointer: // FIXME: object pointers aren't really specifiers
1356     return true;
1357   default:
1358     return false;
1359   }
1360 }
1361
1362 ElaboratedTypeKeyword
1363 TypeWithKeyword::getKeywordForTypeSpec(unsigned TypeSpec) {
1364   switch (TypeSpec) {
1365   default: return ETK_None;
1366   case TST_typename: return ETK_Typename;
1367   case TST_class: return ETK_Class;
1368   case TST_struct: return ETK_Struct;
1369   case TST_interface: return ETK_Interface;
1370   case TST_union: return ETK_Union;
1371   case TST_enum: return ETK_Enum;
1372   }
1373 }
1374
1375 TagTypeKind
1376 TypeWithKeyword::getTagTypeKindForTypeSpec(unsigned TypeSpec) {
1377   switch(TypeSpec) {
1378   case TST_class: return TTK_Class;
1379   case TST_struct: return TTK_Struct;
1380   case TST_interface: return TTK_Interface;
1381   case TST_union: return TTK_Union;
1382   case TST_enum: return TTK_Enum;
1383   }
1384
1385   llvm_unreachable("Type specifier is not a tag type kind.");
1386 }
1387
1388 ElaboratedTypeKeyword
1389 TypeWithKeyword::getKeywordForTagTypeKind(TagTypeKind Kind) {
1390   switch (Kind) {
1391   case TTK_Class: return ETK_Class;
1392   case TTK_Struct: return ETK_Struct;
1393   case TTK_Interface: return ETK_Interface;
1394   case TTK_Union: return ETK_Union;
1395   case TTK_Enum: return ETK_Enum;
1396   }
1397   llvm_unreachable("Unknown tag type kind.");
1398 }
1399
1400 TagTypeKind
1401 TypeWithKeyword::getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword) {
1402   switch (Keyword) {
1403   case ETK_Class: return TTK_Class;
1404   case ETK_Struct: return TTK_Struct;
1405   case ETK_Interface: return TTK_Interface;
1406   case ETK_Union: return TTK_Union;
1407   case ETK_Enum: return TTK_Enum;
1408   case ETK_None: // Fall through.
1409   case ETK_Typename:
1410     llvm_unreachable("Elaborated type keyword is not a tag type kind.");
1411   }
1412   llvm_unreachable("Unknown elaborated type keyword.");
1413 }
1414
1415 bool
1416 TypeWithKeyword::KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword) {
1417   switch (Keyword) {
1418   case ETK_None:
1419   case ETK_Typename:
1420     return false;
1421   case ETK_Class:
1422   case ETK_Struct:
1423   case ETK_Interface:
1424   case ETK_Union:
1425   case ETK_Enum:
1426     return true;
1427   }
1428   llvm_unreachable("Unknown elaborated type keyword.");
1429 }
1430
1431 StringRef TypeWithKeyword::getKeywordName(ElaboratedTypeKeyword Keyword) {
1432   switch (Keyword) {
1433   case ETK_None: return "";
1434   case ETK_Typename: return "typename";
1435   case ETK_Class:  return "class";
1436   case ETK_Struct: return "struct";
1437   case ETK_Interface: return "__interface";
1438   case ETK_Union:  return "union";
1439   case ETK_Enum:   return "enum";
1440   }
1441
1442   llvm_unreachable("Unknown elaborated type keyword.");
1443 }
1444
1445 DependentTemplateSpecializationType::DependentTemplateSpecializationType(
1446                          ElaboratedTypeKeyword Keyword,
1447                          NestedNameSpecifier *NNS, const IdentifierInfo *Name,
1448                          unsigned NumArgs, const TemplateArgument *Args,
1449                          QualType Canon)
1450   : TypeWithKeyword(Keyword, DependentTemplateSpecialization, Canon, true, true,
1451                     /*VariablyModified=*/false,
1452                     NNS && NNS->containsUnexpandedParameterPack()),
1453     NNS(NNS), Name(Name), NumArgs(NumArgs) {
1454   assert((!NNS || NNS->isDependent()) &&
1455          "DependentTemplateSpecializatonType requires dependent qualifier");
1456   for (unsigned I = 0; I != NumArgs; ++I) {
1457     if (Args[I].containsUnexpandedParameterPack())
1458       setContainsUnexpandedParameterPack();
1459
1460     new (&getArgBuffer()[I]) TemplateArgument(Args[I]);
1461   }
1462 }
1463
1464 void
1465 DependentTemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
1466                                              const ASTContext &Context,
1467                                              ElaboratedTypeKeyword Keyword,
1468                                              NestedNameSpecifier *Qualifier,
1469                                              const IdentifierInfo *Name,
1470                                              unsigned NumArgs,
1471                                              const TemplateArgument *Args) {
1472   ID.AddInteger(Keyword);
1473   ID.AddPointer(Qualifier);
1474   ID.AddPointer(Name);
1475   for (unsigned Idx = 0; Idx < NumArgs; ++Idx)
1476     Args[Idx].Profile(ID, Context);
1477 }
1478
1479 bool Type::isElaboratedTypeSpecifier() const {
1480   ElaboratedTypeKeyword Keyword;
1481   if (const ElaboratedType *Elab = dyn_cast<ElaboratedType>(this))
1482     Keyword = Elab->getKeyword();
1483   else if (const DependentNameType *DepName = dyn_cast<DependentNameType>(this))
1484     Keyword = DepName->getKeyword();
1485   else if (const DependentTemplateSpecializationType *DepTST =
1486              dyn_cast<DependentTemplateSpecializationType>(this))
1487     Keyword = DepTST->getKeyword();
1488   else
1489     return false;
1490
1491   return TypeWithKeyword::KeywordIsTagTypeKind(Keyword);
1492 }
1493
1494 const char *Type::getTypeClassName() const {
1495   switch (TypeBits.TC) {
1496 #define ABSTRACT_TYPE(Derived, Base)
1497 #define TYPE(Derived, Base) case Derived: return #Derived;
1498 #include "clang/AST/TypeNodes.def"
1499   }
1500
1501   llvm_unreachable("Invalid type class.");
1502 }
1503
1504 StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
1505   switch (getKind()) {
1506   case Void:              return "void";
1507   case Bool:              return Policy.Bool ? "bool" : "_Bool";
1508   case Char_S:            return "char";
1509   case Char_U:            return "char";
1510   case SChar:             return "signed char";
1511   case Short:             return "short";
1512   case Int:               return "int";
1513   case Long:              return "long";
1514   case LongLong:          return "long long";
1515   case Int128:            return "__int128";
1516   case UChar:             return "unsigned char";
1517   case UShort:            return "unsigned short";
1518   case UInt:              return "unsigned int";
1519   case ULong:             return "unsigned long";
1520   case ULongLong:         return "unsigned long long";
1521   case UInt128:           return "unsigned __int128";
1522   case Half:              return Policy.Half ? "half" : "__fp16";
1523   case Float:             return "float";
1524   case Double:            return "double";
1525   case LongDouble:        return "long double";
1526   case WChar_S:
1527   case WChar_U:           return Policy.MSWChar ? "__wchar_t" : "wchar_t";
1528   case Char16:            return "char16_t";
1529   case Char32:            return "char32_t";
1530   case NullPtr:           return "nullptr_t";
1531   case Overload:          return "<overloaded function type>";
1532   case BoundMember:       return "<bound member function type>";
1533   case PseudoObject:      return "<pseudo-object type>";
1534   case Dependent:         return "<dependent type>";
1535   case UnknownAny:        return "<unknown type>";
1536   case ARCUnbridgedCast:  return "<ARC unbridged cast type>";
1537   case BuiltinFn:         return "<builtin fn type>";
1538   case ObjCId:            return "id";
1539   case ObjCClass:         return "Class";
1540   case ObjCSel:           return "SEL";
1541   case OCLImage1d:        return "image1d_t";
1542   case OCLImage1dArray:   return "image1d_array_t";
1543   case OCLImage1dBuffer:  return "image1d_buffer_t";
1544   case OCLImage2d:        return "image2d_t";
1545   case OCLImage2dArray:   return "image2d_array_t";
1546   case OCLImage3d:        return "image3d_t";
1547   case OCLSampler:        return "sampler_t";
1548   case OCLEvent:          return "event_t";
1549   }
1550
1551   llvm_unreachable("Invalid builtin type.");
1552 }
1553
1554 QualType QualType::getNonLValueExprType(const ASTContext &Context) const {
1555   if (const ReferenceType *RefType = getTypePtr()->getAs<ReferenceType>())
1556     return RefType->getPointeeType();
1557
1558   // C++0x [basic.lval]:
1559   //   Class prvalues can have cv-qualified types; non-class prvalues always
1560   //   have cv-unqualified types.
1561   //
1562   // See also C99 6.3.2.1p2.
1563   if (!Context.getLangOpts().CPlusPlus ||
1564       (!getTypePtr()->isDependentType() && !getTypePtr()->isRecordType()))
1565     return getUnqualifiedType();
1566
1567   return *this;
1568 }
1569
1570 StringRef FunctionType::getNameForCallConv(CallingConv CC) {
1571   switch (CC) {
1572   case CC_C: return "cdecl";
1573   case CC_X86StdCall: return "stdcall";
1574   case CC_X86FastCall: return "fastcall";
1575   case CC_X86ThisCall: return "thiscall";
1576   case CC_X86Pascal: return "pascal";
1577   case CC_X86VectorCall: return "vectorcall";
1578   case CC_X86_64Win64: return "ms_abi";
1579   case CC_X86_64SysV: return "sysv_abi";
1580   case CC_AAPCS: return "aapcs";
1581   case CC_AAPCS_VFP: return "aapcs-vfp";
1582   case CC_IntelOclBicc: return "intel_ocl_bicc";
1583   case CC_SpirFunction: return "spir_function";
1584   case CC_SpirKernel: return "spir_kernel";
1585   }
1586
1587   llvm_unreachable("Invalid calling convention.");
1588 }
1589
1590 FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
1591                                      QualType canonical,
1592                                      const ExtProtoInfo &epi)
1593     : FunctionType(FunctionProto, result, canonical,
1594                    result->isDependentType(),
1595                    result->isInstantiationDependentType(),
1596                    result->isVariablyModifiedType(),
1597                    result->containsUnexpandedParameterPack(), epi.ExtInfo),
1598       NumParams(params.size()),
1599       NumExceptions(epi.ExceptionSpec.Exceptions.size()),
1600       ExceptionSpecType(epi.ExceptionSpec.Type),
1601       HasAnyConsumedParams(epi.ConsumedParameters != nullptr),
1602       Variadic(epi.Variadic), HasTrailingReturn(epi.HasTrailingReturn) {
1603   assert(NumParams == params.size() && "function has too many parameters");
1604
1605   FunctionTypeBits.TypeQuals = epi.TypeQuals;
1606   FunctionTypeBits.RefQualifier = epi.RefQualifier;
1607
1608   // Fill in the trailing argument array.
1609   QualType *argSlot = reinterpret_cast<QualType*>(this+1);
1610   for (unsigned i = 0; i != NumParams; ++i) {
1611     if (params[i]->isDependentType())
1612       setDependent();
1613     else if (params[i]->isInstantiationDependentType())
1614       setInstantiationDependent();
1615
1616     if (params[i]->containsUnexpandedParameterPack())
1617       setContainsUnexpandedParameterPack();
1618
1619     argSlot[i] = params[i];
1620   }
1621
1622   if (getExceptionSpecType() == EST_Dynamic) {
1623     // Fill in the exception array.
1624     QualType *exnSlot = argSlot + NumParams;
1625     unsigned I = 0;
1626     for (QualType ExceptionType : epi.ExceptionSpec.Exceptions) {
1627       // Note that a dependent exception specification does *not* make
1628       // a type dependent; it's not even part of the C++ type system.
1629       if (ExceptionType->isInstantiationDependentType())
1630         setInstantiationDependent();
1631
1632       if (ExceptionType->containsUnexpandedParameterPack())
1633         setContainsUnexpandedParameterPack();
1634
1635       exnSlot[I++] = ExceptionType;
1636     }
1637   } else if (getExceptionSpecType() == EST_ComputedNoexcept) {
1638     // Store the noexcept expression and context.
1639     Expr **noexSlot = reinterpret_cast<Expr **>(argSlot + NumParams);
1640     *noexSlot = epi.ExceptionSpec.NoexceptExpr;
1641
1642     if (epi.ExceptionSpec.NoexceptExpr) {
1643       if (epi.ExceptionSpec.NoexceptExpr->isValueDependent() ||
1644           epi.ExceptionSpec.NoexceptExpr->isInstantiationDependent())
1645         setInstantiationDependent();
1646
1647       if (epi.ExceptionSpec.NoexceptExpr->containsUnexpandedParameterPack())
1648         setContainsUnexpandedParameterPack();
1649     }
1650   } else if (getExceptionSpecType() == EST_Uninstantiated) {
1651     // Store the function decl from which we will resolve our
1652     // exception specification.
1653     FunctionDecl **slot =
1654         reinterpret_cast<FunctionDecl **>(argSlot + NumParams);
1655     slot[0] = epi.ExceptionSpec.SourceDecl;
1656     slot[1] = epi.ExceptionSpec.SourceTemplate;
1657     // This exception specification doesn't make the type dependent, because
1658     // it's not instantiated as part of instantiating the type.
1659   } else if (getExceptionSpecType() == EST_Unevaluated) {
1660     // Store the function decl from which we will resolve our
1661     // exception specification.
1662     FunctionDecl **slot =
1663         reinterpret_cast<FunctionDecl **>(argSlot + NumParams);
1664     slot[0] = epi.ExceptionSpec.SourceDecl;
1665   }
1666
1667   if (epi.ConsumedParameters) {
1668     bool *consumedParams = const_cast<bool *>(getConsumedParamsBuffer());
1669     for (unsigned i = 0; i != NumParams; ++i)
1670       consumedParams[i] = epi.ConsumedParameters[i];
1671   }
1672 }
1673
1674 bool FunctionProtoType::hasDependentExceptionSpec() const {
1675   if (Expr *NE = getNoexceptExpr())
1676     return NE->isValueDependent();
1677   for (QualType ET : exceptions())
1678     // A pack expansion with a non-dependent pattern is still dependent,
1679     // because we don't know whether the pattern is in the exception spec
1680     // or not (that depends on whether the pack has 0 expansions).
1681     if (ET->isDependentType() || ET->getAs<PackExpansionType>())
1682       return true;
1683   return false;
1684 }
1685
1686 FunctionProtoType::NoexceptResult
1687 FunctionProtoType::getNoexceptSpec(const ASTContext &ctx) const {
1688   ExceptionSpecificationType est = getExceptionSpecType();
1689   if (est == EST_BasicNoexcept)
1690     return NR_Nothrow;
1691
1692   if (est != EST_ComputedNoexcept)
1693     return NR_NoNoexcept;
1694
1695   Expr *noexceptExpr = getNoexceptExpr();
1696   if (!noexceptExpr)
1697     return NR_BadNoexcept;
1698   if (noexceptExpr->isValueDependent())
1699     return NR_Dependent;
1700
1701   llvm::APSInt value;
1702   bool isICE = noexceptExpr->isIntegerConstantExpr(value, ctx, nullptr,
1703                                                    /*evaluated*/false);
1704   (void)isICE;
1705   assert(isICE && "AST should not contain bad noexcept expressions.");
1706
1707   return value.getBoolValue() ? NR_Nothrow : NR_Throw;
1708 }
1709
1710 bool FunctionProtoType::isNothrow(const ASTContext &Ctx,
1711                                   bool ResultIfDependent) const {
1712   ExceptionSpecificationType EST = getExceptionSpecType();
1713   assert(EST != EST_Unevaluated && EST != EST_Uninstantiated);
1714   if (EST == EST_DynamicNone || EST == EST_BasicNoexcept)
1715     return true;
1716
1717   if (EST == EST_Dynamic && ResultIfDependent) {
1718     // A dynamic exception specification is throwing unless every exception
1719     // type is an (unexpanded) pack expansion type.
1720     for (unsigned I = 0, N = NumExceptions; I != N; ++I)
1721       if (!getExceptionType(I)->getAs<PackExpansionType>())
1722         return false;
1723     return ResultIfDependent;
1724   }
1725
1726   if (EST != EST_ComputedNoexcept)
1727     return false;
1728
1729   NoexceptResult NR = getNoexceptSpec(Ctx);
1730   if (NR == NR_Dependent)
1731     return ResultIfDependent;
1732   return NR == NR_Nothrow;
1733 }
1734
1735 bool FunctionProtoType::isTemplateVariadic() const {
1736   for (unsigned ArgIdx = getNumParams(); ArgIdx; --ArgIdx)
1737     if (isa<PackExpansionType>(getParamType(ArgIdx - 1)))
1738       return true;
1739
1740   return false;
1741 }
1742
1743 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
1744                                 const QualType *ArgTys, unsigned NumParams,
1745                                 const ExtProtoInfo &epi,
1746                                 const ASTContext &Context) {
1747
1748   // We have to be careful not to get ambiguous profile encodings.
1749   // Note that valid type pointers are never ambiguous with anything else.
1750   //
1751   // The encoding grammar begins:
1752   //      type type* bool int bool
1753   // If that final bool is true, then there is a section for the EH spec:
1754   //      bool type*
1755   // This is followed by an optional "consumed argument" section of the
1756   // same length as the first type sequence:
1757   //      bool*
1758   // Finally, we have the ext info and trailing return type flag:
1759   //      int bool
1760   //
1761   // There is no ambiguity between the consumed arguments and an empty EH
1762   // spec because of the leading 'bool' which unambiguously indicates
1763   // whether the following bool is the EH spec or part of the arguments.
1764
1765   ID.AddPointer(Result.getAsOpaquePtr());
1766   for (unsigned i = 0; i != NumParams; ++i)
1767     ID.AddPointer(ArgTys[i].getAsOpaquePtr());
1768   // This method is relatively performance sensitive, so as a performance
1769   // shortcut, use one AddInteger call instead of four for the next four
1770   // fields.
1771   assert(!(unsigned(epi.Variadic) & ~1) &&
1772          !(unsigned(epi.TypeQuals) & ~255) &&
1773          !(unsigned(epi.RefQualifier) & ~3) &&
1774          !(unsigned(epi.ExceptionSpec.Type) & ~15) &&
1775          "Values larger than expected.");
1776   ID.AddInteger(unsigned(epi.Variadic) +
1777                 (epi.TypeQuals << 1) +
1778                 (epi.RefQualifier << 9) +
1779                 (epi.ExceptionSpec.Type << 11));
1780   if (epi.ExceptionSpec.Type == EST_Dynamic) {
1781     for (QualType Ex : epi.ExceptionSpec.Exceptions)
1782       ID.AddPointer(Ex.getAsOpaquePtr());
1783   } else if (epi.ExceptionSpec.Type == EST_ComputedNoexcept &&
1784              epi.ExceptionSpec.NoexceptExpr) {
1785     epi.ExceptionSpec.NoexceptExpr->Profile(ID, Context, false);
1786   } else if (epi.ExceptionSpec.Type == EST_Uninstantiated ||
1787              epi.ExceptionSpec.Type == EST_Unevaluated) {
1788     ID.AddPointer(epi.ExceptionSpec.SourceDecl->getCanonicalDecl());
1789   }
1790   if (epi.ConsumedParameters) {
1791     for (unsigned i = 0; i != NumParams; ++i)
1792       ID.AddBoolean(epi.ConsumedParameters[i]);
1793   }
1794   epi.ExtInfo.Profile(ID);
1795   ID.AddBoolean(epi.HasTrailingReturn);
1796 }
1797
1798 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID,
1799                                 const ASTContext &Ctx) {
1800   Profile(ID, getReturnType(), param_type_begin(), NumParams, getExtProtoInfo(),
1801           Ctx);
1802 }
1803
1804 QualType TypedefType::desugar() const {
1805   return getDecl()->getUnderlyingType();
1806 }
1807
1808 TypeOfExprType::TypeOfExprType(Expr *E, QualType can)
1809   : Type(TypeOfExpr, can, E->isTypeDependent(),
1810          E->isInstantiationDependent(),
1811          E->getType()->isVariablyModifiedType(),
1812          E->containsUnexpandedParameterPack()),
1813     TOExpr(E) {
1814 }
1815
1816 bool TypeOfExprType::isSugared() const {
1817   return !TOExpr->isTypeDependent();
1818 }
1819
1820 QualType TypeOfExprType::desugar() const {
1821   if (isSugared())
1822     return getUnderlyingExpr()->getType();
1823
1824   return QualType(this, 0);
1825 }
1826
1827 void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID,
1828                                       const ASTContext &Context, Expr *E) {
1829   E->Profile(ID, Context, true);
1830 }
1831
1832 DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can)
1833   // C++11 [temp.type]p2: "If an expression e involves a template parameter,
1834   // decltype(e) denotes a unique dependent type." Hence a decltype type is
1835   // type-dependent even if its expression is only instantiation-dependent.
1836   : Type(Decltype, can, E->isInstantiationDependent(),
1837          E->isInstantiationDependent(),
1838          E->getType()->isVariablyModifiedType(),
1839          E->containsUnexpandedParameterPack()),
1840     E(E),
1841   UnderlyingType(underlyingType) {
1842 }
1843
1844 bool DecltypeType::isSugared() const { return !E->isInstantiationDependent(); }
1845
1846 QualType DecltypeType::desugar() const {
1847   if (isSugared())
1848     return getUnderlyingType();
1849
1850   return QualType(this, 0);
1851 }
1852
1853 DependentDecltypeType::DependentDecltypeType(const ASTContext &Context, Expr *E)
1854   : DecltypeType(E, Context.DependentTy), Context(Context) { }
1855
1856 void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID,
1857                                     const ASTContext &Context, Expr *E) {
1858   E->Profile(ID, Context, true);
1859 }
1860
1861 TagType::TagType(TypeClass TC, const TagDecl *D, QualType can)
1862   : Type(TC, can, D->isDependentType(),
1863          /*InstantiationDependent=*/D->isDependentType(),
1864          /*VariablyModified=*/false,
1865          /*ContainsUnexpandedParameterPack=*/false),
1866     decl(const_cast<TagDecl*>(D)) {}
1867
1868 static TagDecl *getInterestingTagDecl(TagDecl *decl) {
1869   for (auto I : decl->redecls()) {
1870     if (I->isCompleteDefinition() || I->isBeingDefined())
1871       return I;
1872   }
1873   // If there's no definition (not even in progress), return what we have.
1874   return decl;
1875 }
1876
1877 UnaryTransformType::UnaryTransformType(QualType BaseType,
1878                                        QualType UnderlyingType,
1879                                        UTTKind UKind,
1880                                        QualType CanonicalType)
1881   : Type(UnaryTransform, CanonicalType, UnderlyingType->isDependentType(),
1882          UnderlyingType->isInstantiationDependentType(),
1883          UnderlyingType->isVariablyModifiedType(),
1884          BaseType->containsUnexpandedParameterPack())
1885   , BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind)
1886 {}
1887
1888 TagDecl *TagType::getDecl() const {
1889   return getInterestingTagDecl(decl);
1890 }
1891
1892 bool TagType::isBeingDefined() const {
1893   return getDecl()->isBeingDefined();
1894 }
1895
1896 bool AttributedType::isMSTypeSpec() const {
1897   switch (getAttrKind()) {
1898   default:  return false;
1899   case attr_ptr32:
1900   case attr_ptr64:
1901   case attr_sptr:
1902   case attr_uptr:
1903     return true;
1904   }
1905   llvm_unreachable("invalid attr kind");
1906 }
1907
1908 bool AttributedType::isCallingConv() const {
1909   switch (getAttrKind()) {
1910   case attr_ptr32:
1911   case attr_ptr64:
1912   case attr_sptr:
1913   case attr_uptr:
1914   case attr_address_space:
1915   case attr_regparm:
1916   case attr_vector_size:
1917   case attr_neon_vector_type:
1918   case attr_neon_polyvector_type:
1919   case attr_objc_gc:
1920   case attr_objc_ownership:
1921   case attr_noreturn:
1922       return false;
1923   case attr_pcs:
1924   case attr_pcs_vfp:
1925   case attr_cdecl:
1926   case attr_fastcall:
1927   case attr_stdcall:
1928   case attr_thiscall:
1929   case attr_vectorcall:
1930   case attr_pascal:
1931   case attr_ms_abi:
1932   case attr_sysv_abi:
1933   case attr_inteloclbicc:
1934     return true;
1935   }
1936   llvm_unreachable("invalid attr kind");
1937 }
1938
1939 CXXRecordDecl *InjectedClassNameType::getDecl() const {
1940   return cast<CXXRecordDecl>(getInterestingTagDecl(Decl));
1941 }
1942
1943 IdentifierInfo *TemplateTypeParmType::getIdentifier() const {
1944   return isCanonicalUnqualified() ? nullptr : getDecl()->getIdentifier();
1945 }
1946
1947 SubstTemplateTypeParmPackType::
1948 SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
1949                               QualType Canon,
1950                               const TemplateArgument &ArgPack)
1951   : Type(SubstTemplateTypeParmPack, Canon, true, true, false, true),
1952     Replaced(Param),
1953     Arguments(ArgPack.pack_begin()), NumArguments(ArgPack.pack_size())
1954 {
1955 }
1956
1957 TemplateArgument SubstTemplateTypeParmPackType::getArgumentPack() const {
1958   return TemplateArgument(Arguments, NumArguments);
1959 }
1960
1961 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
1962   Profile(ID, getReplacedParameter(), getArgumentPack());
1963 }
1964
1965 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
1966                                            const TemplateTypeParmType *Replaced,
1967                                             const TemplateArgument &ArgPack) {
1968   ID.AddPointer(Replaced);
1969   ID.AddInteger(ArgPack.pack_size());
1970   for (const auto &P : ArgPack.pack_elements())
1971     ID.AddPointer(P.getAsType().getAsOpaquePtr());
1972 }
1973
1974 bool TemplateSpecializationType::
1975 anyDependentTemplateArguments(const TemplateArgumentListInfo &Args,
1976                               bool &InstantiationDependent) {
1977   return anyDependentTemplateArguments(Args.getArgumentArray(), Args.size(),
1978                                        InstantiationDependent);
1979 }
1980
1981 bool TemplateSpecializationType::
1982 anyDependentTemplateArguments(const TemplateArgumentLoc *Args, unsigned N,
1983                               bool &InstantiationDependent) {
1984   for (unsigned i = 0; i != N; ++i) {
1985     if (Args[i].getArgument().isDependent()) {
1986       InstantiationDependent = true;
1987       return true;
1988     }
1989
1990     if (Args[i].getArgument().isInstantiationDependent())
1991       InstantiationDependent = true;
1992   }
1993   return false;
1994 }
1995
1996 TemplateSpecializationType::
1997 TemplateSpecializationType(TemplateName T,
1998                            const TemplateArgument *Args, unsigned NumArgs,
1999                            QualType Canon, QualType AliasedType)
2000   : Type(TemplateSpecialization,
2001          Canon.isNull()? QualType(this, 0) : Canon,
2002          Canon.isNull()? true : Canon->isDependentType(),
2003          Canon.isNull()? true : Canon->isInstantiationDependentType(),
2004          false,
2005          T.containsUnexpandedParameterPack()),
2006     Template(T), NumArgs(NumArgs), TypeAlias(!AliasedType.isNull()) {
2007   assert(!T.getAsDependentTemplateName() &&
2008          "Use DependentTemplateSpecializationType for dependent template-name");
2009   assert((T.getKind() == TemplateName::Template ||
2010           T.getKind() == TemplateName::SubstTemplateTemplateParm ||
2011           T.getKind() == TemplateName::SubstTemplateTemplateParmPack) &&
2012          "Unexpected template name for TemplateSpecializationType");
2013
2014   TemplateArgument *TemplateArgs
2015     = reinterpret_cast<TemplateArgument *>(this + 1);
2016   for (unsigned Arg = 0; Arg < NumArgs; ++Arg) {
2017     // Update instantiation-dependent and variably-modified bits.
2018     // If the canonical type exists and is non-dependent, the template
2019     // specialization type can be non-dependent even if one of the type
2020     // arguments is. Given:
2021     //   template<typename T> using U = int;
2022     // U<T> is always non-dependent, irrespective of the type T.
2023     // However, U<Ts> contains an unexpanded parameter pack, even though
2024     // its expansion (and thus its desugared type) doesn't.
2025     if (Args[Arg].isInstantiationDependent())
2026       setInstantiationDependent();
2027     if (Args[Arg].getKind() == TemplateArgument::Type &&
2028         Args[Arg].getAsType()->isVariablyModifiedType())
2029       setVariablyModified();
2030     if (Args[Arg].containsUnexpandedParameterPack())
2031       setContainsUnexpandedParameterPack();
2032     new (&TemplateArgs[Arg]) TemplateArgument(Args[Arg]);
2033   }
2034
2035   // Store the aliased type if this is a type alias template specialization.
2036   if (TypeAlias) {
2037     TemplateArgument *Begin = reinterpret_cast<TemplateArgument *>(this + 1);
2038     *reinterpret_cast<QualType*>(Begin + getNumArgs()) = AliasedType;
2039   }
2040 }
2041
2042 void
2043 TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
2044                                     TemplateName T,
2045                                     const TemplateArgument *Args,
2046                                     unsigned NumArgs,
2047                                     const ASTContext &Context) {
2048   T.Profile(ID);
2049   for (unsigned Idx = 0; Idx < NumArgs; ++Idx)
2050     Args[Idx].Profile(ID, Context);
2051 }
2052
2053 QualType
2054 QualifierCollector::apply(const ASTContext &Context, QualType QT) const {
2055   if (!hasNonFastQualifiers())
2056     return QT.withFastQualifiers(getFastQualifiers());
2057
2058   return Context.getQualifiedType(QT, *this);
2059 }
2060
2061 QualType
2062 QualifierCollector::apply(const ASTContext &Context, const Type *T) const {
2063   if (!hasNonFastQualifiers())
2064     return QualType(T, getFastQualifiers());
2065
2066   return Context.getQualifiedType(T, *this);
2067 }
2068
2069 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID,
2070                                  QualType BaseType,
2071                                  ObjCProtocolDecl * const *Protocols,
2072                                  unsigned NumProtocols) {
2073   ID.AddPointer(BaseType.getAsOpaquePtr());
2074   for (unsigned i = 0; i != NumProtocols; i++)
2075     ID.AddPointer(Protocols[i]);
2076 }
2077
2078 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) {
2079   Profile(ID, getBaseType(), qual_begin(), getNumProtocols());
2080 }
2081
2082 namespace {
2083
2084 /// \brief The cached properties of a type.
2085 class CachedProperties {
2086   Linkage L;
2087   bool local;
2088
2089 public:
2090   CachedProperties(Linkage L, bool local) : L(L), local(local) {}
2091
2092   Linkage getLinkage() const { return L; }
2093   bool hasLocalOrUnnamedType() const { return local; }
2094
2095   friend CachedProperties merge(CachedProperties L, CachedProperties R) {
2096     Linkage MergedLinkage = minLinkage(L.L, R.L);
2097     return CachedProperties(MergedLinkage,
2098                          L.hasLocalOrUnnamedType() | R.hasLocalOrUnnamedType());
2099   }
2100 };
2101 }
2102
2103 static CachedProperties computeCachedProperties(const Type *T);
2104
2105 namespace clang {
2106 /// The type-property cache.  This is templated so as to be
2107 /// instantiated at an internal type to prevent unnecessary symbol
2108 /// leakage.
2109 template <class Private> class TypePropertyCache {
2110 public:
2111   static CachedProperties get(QualType T) {
2112     return get(T.getTypePtr());
2113   }
2114
2115   static CachedProperties get(const Type *T) {
2116     ensure(T);
2117     return CachedProperties(T->TypeBits.getLinkage(),
2118                             T->TypeBits.hasLocalOrUnnamedType());
2119   }
2120
2121   static void ensure(const Type *T) {
2122     // If the cache is valid, we're okay.
2123     if (T->TypeBits.isCacheValid()) return;
2124
2125     // If this type is non-canonical, ask its canonical type for the
2126     // relevant information.
2127     if (!T->isCanonicalUnqualified()) {
2128       const Type *CT = T->getCanonicalTypeInternal().getTypePtr();
2129       ensure(CT);
2130       T->TypeBits.CacheValid = true;
2131       T->TypeBits.CachedLinkage = CT->TypeBits.CachedLinkage;
2132       T->TypeBits.CachedLocalOrUnnamed = CT->TypeBits.CachedLocalOrUnnamed;
2133       return;
2134     }
2135
2136     // Compute the cached properties and then set the cache.
2137     CachedProperties Result = computeCachedProperties(T);
2138     T->TypeBits.CacheValid = true;
2139     T->TypeBits.CachedLinkage = Result.getLinkage();
2140     T->TypeBits.CachedLocalOrUnnamed = Result.hasLocalOrUnnamedType();
2141   }
2142 };
2143 }
2144
2145 // Instantiate the friend template at a private class.  In a
2146 // reasonable implementation, these symbols will be internal.
2147 // It is terrible that this is the best way to accomplish this.
2148 namespace { class Private {}; }
2149 typedef TypePropertyCache<Private> Cache;
2150
2151 static CachedProperties computeCachedProperties(const Type *T) {
2152   switch (T->getTypeClass()) {
2153 #define TYPE(Class,Base)
2154 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
2155 #include "clang/AST/TypeNodes.def"
2156     llvm_unreachable("didn't expect a non-canonical type here");
2157
2158 #define TYPE(Class,Base)
2159 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
2160 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
2161 #include "clang/AST/TypeNodes.def"
2162     // Treat instantiation-dependent types as external.
2163     assert(T->isInstantiationDependentType());
2164     return CachedProperties(ExternalLinkage, false);
2165
2166   case Type::Auto:
2167     // Give non-deduced 'auto' types external linkage. We should only see them
2168     // here in error recovery.
2169     return CachedProperties(ExternalLinkage, false);
2170
2171   case Type::Builtin:
2172     // C++ [basic.link]p8:
2173     //   A type is said to have linkage if and only if:
2174     //     - it is a fundamental type (3.9.1); or
2175     return CachedProperties(ExternalLinkage, false);
2176
2177   case Type::Record:
2178   case Type::Enum: {
2179     const TagDecl *Tag = cast<TagType>(T)->getDecl();
2180
2181     // C++ [basic.link]p8:
2182     //     - it is a class or enumeration type that is named (or has a name
2183     //       for linkage purposes (7.1.3)) and the name has linkage; or
2184     //     -  it is a specialization of a class template (14); or
2185     Linkage L = Tag->getLinkageInternal();
2186     bool IsLocalOrUnnamed =
2187       Tag->getDeclContext()->isFunctionOrMethod() ||
2188       !Tag->hasNameForLinkage();
2189     return CachedProperties(L, IsLocalOrUnnamed);
2190   }
2191
2192     // C++ [basic.link]p8:
2193     //   - it is a compound type (3.9.2) other than a class or enumeration,
2194     //     compounded exclusively from types that have linkage; or
2195   case Type::Complex:
2196     return Cache::get(cast<ComplexType>(T)->getElementType());
2197   case Type::Pointer:
2198     return Cache::get(cast<PointerType>(T)->getPointeeType());
2199   case Type::BlockPointer:
2200     return Cache::get(cast<BlockPointerType>(T)->getPointeeType());
2201   case Type::LValueReference:
2202   case Type::RValueReference:
2203     return Cache::get(cast<ReferenceType>(T)->getPointeeType());
2204   case Type::MemberPointer: {
2205     const MemberPointerType *MPT = cast<MemberPointerType>(T);
2206     return merge(Cache::get(MPT->getClass()),
2207                  Cache::get(MPT->getPointeeType()));
2208   }
2209   case Type::ConstantArray:
2210   case Type::IncompleteArray:
2211   case Type::VariableArray:
2212     return Cache::get(cast<ArrayType>(T)->getElementType());
2213   case Type::Vector:
2214   case Type::ExtVector:
2215     return Cache::get(cast<VectorType>(T)->getElementType());
2216   case Type::FunctionNoProto:
2217     return Cache::get(cast<FunctionType>(T)->getReturnType());
2218   case Type::FunctionProto: {
2219     const FunctionProtoType *FPT = cast<FunctionProtoType>(T);
2220     CachedProperties result = Cache::get(FPT->getReturnType());
2221     for (const auto &ai : FPT->param_types())
2222       result = merge(result, Cache::get(ai));
2223     return result;
2224   }
2225   case Type::ObjCInterface: {
2226     Linkage L = cast<ObjCInterfaceType>(T)->getDecl()->getLinkageInternal();
2227     return CachedProperties(L, false);
2228   }
2229   case Type::ObjCObject:
2230     return Cache::get(cast<ObjCObjectType>(T)->getBaseType());
2231   case Type::ObjCObjectPointer:
2232     return Cache::get(cast<ObjCObjectPointerType>(T)->getPointeeType());
2233   case Type::Atomic:
2234     return Cache::get(cast<AtomicType>(T)->getValueType());
2235   }
2236
2237   llvm_unreachable("unhandled type class");
2238 }
2239
2240 /// \brief Determine the linkage of this type.
2241 Linkage Type::getLinkage() const {
2242   Cache::ensure(this);
2243   return TypeBits.getLinkage();
2244 }
2245
2246 bool Type::hasUnnamedOrLocalType() const {
2247   Cache::ensure(this);
2248   return TypeBits.hasLocalOrUnnamedType();
2249 }
2250
2251 static LinkageInfo computeLinkageInfo(QualType T);
2252
2253 static LinkageInfo computeLinkageInfo(const Type *T) {
2254   switch (T->getTypeClass()) {
2255 #define TYPE(Class,Base)
2256 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
2257 #include "clang/AST/TypeNodes.def"
2258     llvm_unreachable("didn't expect a non-canonical type here");
2259
2260 #define TYPE(Class,Base)
2261 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
2262 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
2263 #include "clang/AST/TypeNodes.def"
2264     // Treat instantiation-dependent types as external.
2265     assert(T->isInstantiationDependentType());
2266     return LinkageInfo::external();
2267
2268   case Type::Builtin:
2269     return LinkageInfo::external();
2270
2271   case Type::Auto:
2272     return LinkageInfo::external();
2273
2274   case Type::Record:
2275   case Type::Enum:
2276     return cast<TagType>(T)->getDecl()->getLinkageAndVisibility();
2277
2278   case Type::Complex:
2279     return computeLinkageInfo(cast<ComplexType>(T)->getElementType());
2280   case Type::Pointer:
2281     return computeLinkageInfo(cast<PointerType>(T)->getPointeeType());
2282   case Type::BlockPointer:
2283     return computeLinkageInfo(cast<BlockPointerType>(T)->getPointeeType());
2284   case Type::LValueReference:
2285   case Type::RValueReference:
2286     return computeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
2287   case Type::MemberPointer: {
2288     const MemberPointerType *MPT = cast<MemberPointerType>(T);
2289     LinkageInfo LV = computeLinkageInfo(MPT->getClass());
2290     LV.merge(computeLinkageInfo(MPT->getPointeeType()));
2291     return LV;
2292   }
2293   case Type::ConstantArray:
2294   case Type::IncompleteArray:
2295   case Type::VariableArray:
2296     return computeLinkageInfo(cast<ArrayType>(T)->getElementType());
2297   case Type::Vector:
2298   case Type::ExtVector:
2299     return computeLinkageInfo(cast<VectorType>(T)->getElementType());
2300   case Type::FunctionNoProto:
2301     return computeLinkageInfo(cast<FunctionType>(T)->getReturnType());
2302   case Type::FunctionProto: {
2303     const FunctionProtoType *FPT = cast<FunctionProtoType>(T);
2304     LinkageInfo LV = computeLinkageInfo(FPT->getReturnType());
2305     for (const auto &ai : FPT->param_types())
2306       LV.merge(computeLinkageInfo(ai));
2307     return LV;
2308   }
2309   case Type::ObjCInterface:
2310     return cast<ObjCInterfaceType>(T)->getDecl()->getLinkageAndVisibility();
2311   case Type::ObjCObject:
2312     return computeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType());
2313   case Type::ObjCObjectPointer:
2314     return computeLinkageInfo(cast<ObjCObjectPointerType>(T)->getPointeeType());
2315   case Type::Atomic:
2316     return computeLinkageInfo(cast<AtomicType>(T)->getValueType());
2317   }
2318
2319   llvm_unreachable("unhandled type class");
2320 }
2321
2322 static LinkageInfo computeLinkageInfo(QualType T) {
2323   return computeLinkageInfo(T.getTypePtr());
2324 }
2325
2326 bool Type::isLinkageValid() const {
2327   if (!TypeBits.isCacheValid())
2328     return true;
2329
2330   return computeLinkageInfo(getCanonicalTypeInternal()).getLinkage() ==
2331     TypeBits.getLinkage();
2332 }
2333
2334 LinkageInfo Type::getLinkageAndVisibility() const {
2335   if (!isCanonicalUnqualified())
2336     return computeLinkageInfo(getCanonicalTypeInternal());
2337
2338   LinkageInfo LV = computeLinkageInfo(this);
2339   assert(LV.getLinkage() == getLinkage());
2340   return LV;
2341 }
2342
2343 Qualifiers::ObjCLifetime Type::getObjCARCImplicitLifetime() const {
2344   if (isObjCARCImplicitlyUnretainedType())
2345     return Qualifiers::OCL_ExplicitNone;
2346   return Qualifiers::OCL_Strong;
2347 }
2348
2349 bool Type::isObjCARCImplicitlyUnretainedType() const {
2350   assert(isObjCLifetimeType() &&
2351          "cannot query implicit lifetime for non-inferrable type");
2352
2353   const Type *canon = getCanonicalTypeInternal().getTypePtr();
2354
2355   // Walk down to the base type.  We don't care about qualifiers for this.
2356   while (const ArrayType *array = dyn_cast<ArrayType>(canon))
2357     canon = array->getElementType().getTypePtr();
2358
2359   if (const ObjCObjectPointerType *opt
2360         = dyn_cast<ObjCObjectPointerType>(canon)) {
2361     // Class and Class<Protocol> don't require retension.
2362     if (opt->getObjectType()->isObjCClass())
2363       return true;
2364   }
2365
2366   return false;
2367 }
2368
2369 bool Type::isObjCNSObjectType() const {
2370   if (const TypedefType *typedefType = dyn_cast<TypedefType>(this))
2371     return typedefType->getDecl()->hasAttr<ObjCNSObjectAttr>();
2372   return false;
2373 }
2374 bool Type::isObjCIndependentClassType() const {
2375   if (const TypedefType *typedefType = dyn_cast<TypedefType>(this))
2376     return typedefType->getDecl()->hasAttr<ObjCIndependentClassAttr>();
2377   return false;
2378 }
2379 bool Type::isObjCRetainableType() const {
2380   return isObjCObjectPointerType() ||
2381          isBlockPointerType() ||
2382          isObjCNSObjectType();
2383 }
2384 bool Type::isObjCIndirectLifetimeType() const {
2385   if (isObjCLifetimeType())
2386     return true;
2387   if (const PointerType *OPT = getAs<PointerType>())
2388     return OPT->getPointeeType()->isObjCIndirectLifetimeType();
2389   if (const ReferenceType *Ref = getAs<ReferenceType>())
2390     return Ref->getPointeeType()->isObjCIndirectLifetimeType();
2391   if (const MemberPointerType *MemPtr = getAs<MemberPointerType>())
2392     return MemPtr->getPointeeType()->isObjCIndirectLifetimeType();
2393   return false;
2394 }
2395
2396 /// Returns true if objects of this type have lifetime semantics under
2397 /// ARC.
2398 bool Type::isObjCLifetimeType() const {
2399   const Type *type = this;
2400   while (const ArrayType *array = type->getAsArrayTypeUnsafe())
2401     type = array->getElementType().getTypePtr();
2402   return type->isObjCRetainableType();
2403 }
2404
2405 /// \brief Determine whether the given type T is a "bridgable" Objective-C type,
2406 /// which is either an Objective-C object pointer type or an
2407 bool Type::isObjCARCBridgableType() const {
2408   return isObjCObjectPointerType() || isBlockPointerType();
2409 }
2410
2411 /// \brief Determine whether the given type T is a "bridgeable" C type.
2412 bool Type::isCARCBridgableType() const {
2413   const PointerType *Pointer = getAs<PointerType>();
2414   if (!Pointer)
2415     return false;
2416
2417   QualType Pointee = Pointer->getPointeeType();
2418   return Pointee->isVoidType() || Pointee->isRecordType();
2419 }
2420
2421 bool Type::hasSizedVLAType() const {
2422   if (!isVariablyModifiedType()) return false;
2423
2424   if (const PointerType *ptr = getAs<PointerType>())
2425     return ptr->getPointeeType()->hasSizedVLAType();
2426   if (const ReferenceType *ref = getAs<ReferenceType>())
2427     return ref->getPointeeType()->hasSizedVLAType();
2428   if (const ArrayType *arr = getAsArrayTypeUnsafe()) {
2429     if (isa<VariableArrayType>(arr) &&
2430         cast<VariableArrayType>(arr)->getSizeExpr())
2431       return true;
2432
2433     return arr->getElementType()->hasSizedVLAType();
2434   }
2435
2436   return false;
2437 }
2438
2439 QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) {
2440   switch (type.getObjCLifetime()) {
2441   case Qualifiers::OCL_None:
2442   case Qualifiers::OCL_ExplicitNone:
2443   case Qualifiers::OCL_Autoreleasing:
2444     break;
2445
2446   case Qualifiers::OCL_Strong:
2447     return DK_objc_strong_lifetime;
2448   case Qualifiers::OCL_Weak:
2449     return DK_objc_weak_lifetime;
2450   }
2451
2452   /// Currently, the only destruction kind we recognize is C++ objects
2453   /// with non-trivial destructors.
2454   const CXXRecordDecl *record =
2455     type->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
2456   if (record && record->hasDefinition() && !record->hasTrivialDestructor())
2457     return DK_cxx_destructor;
2458
2459   return DK_none;
2460 }
2461
2462 CXXRecordDecl *MemberPointerType::getMostRecentCXXRecordDecl() const {
2463   return getClass()->getAsCXXRecordDecl()->getMostRecentDecl();
2464 }