• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "clang/Basic/TargetInfo.h"
26 #include "llvm/ADT/APSInt.h"
27 #include "llvm/ADT/StringExtras.h"
28 #include "llvm/Support/raw_ostream.h"
29 #include <algorithm>
30 using namespace clang;
31 
isStrictSupersetOf(Qualifiers Other) const32 bool Qualifiers::isStrictSupersetOf(Qualifiers Other) const {
33   return (*this != Other) &&
34     // CVR qualifiers superset
35     (((Mask & CVRMask) | (Other.Mask & CVRMask)) == (Mask & CVRMask)) &&
36     // ObjC GC qualifiers superset
37     ((getObjCGCAttr() == Other.getObjCGCAttr()) ||
38      (hasObjCGCAttr() && !Other.hasObjCGCAttr())) &&
39     // Address space superset.
40     ((getAddressSpace() == Other.getAddressSpace()) ||
41      (hasAddressSpace()&& !Other.hasAddressSpace())) &&
42     // Lifetime qualifier superset.
43     ((getObjCLifetime() == Other.getObjCLifetime()) ||
44      (hasObjCLifetime() && !Other.hasObjCLifetime()));
45 }
46 
getBaseTypeIdentifier() const47 const IdentifierInfo* QualType::getBaseTypeIdentifier() const {
48   const Type* ty = getTypePtr();
49   NamedDecl *ND = nullptr;
50   if (ty->isPointerType() || ty->isReferenceType())
51     return ty->getPointeeType().getBaseTypeIdentifier();
52   else if (ty->isRecordType())
53     ND = ty->getAs<RecordType>()->getDecl();
54   else if (ty->isEnumeralType())
55     ND = ty->getAs<EnumType>()->getDecl();
56   else if (ty->getTypeClass() == Type::Typedef)
57     ND = ty->getAs<TypedefType>()->getDecl();
58   else if (ty->isArrayType())
59     return ty->castAsArrayTypeUnsafe()->
60         getElementType().getBaseTypeIdentifier();
61 
62   if (ND)
63     return ND->getIdentifier();
64   return nullptr;
65 }
66 
isConstant(QualType T,const ASTContext & Ctx)67 bool QualType::isConstant(QualType T, const ASTContext &Ctx) {
68   if (T.isConstQualified())
69     return true;
70 
71   if (const ArrayType *AT = Ctx.getAsArrayType(T))
72     return AT->getElementType().isConstant(Ctx);
73 
74   return T.getAddressSpace() == LangAS::opencl_constant;
75 }
76 
getNumAddressingBits(const ASTContext & Context,QualType ElementType,const llvm::APInt & NumElements)77 unsigned ConstantArrayType::getNumAddressingBits(const ASTContext &Context,
78                                                  QualType ElementType,
79                                                const llvm::APInt &NumElements) {
80   uint64_t ElementSize = Context.getTypeSizeInChars(ElementType).getQuantity();
81 
82   // Fast path the common cases so we can avoid the conservative computation
83   // below, which in common cases allocates "large" APSInt values, which are
84   // slow.
85 
86   // If the element size is a power of 2, we can directly compute the additional
87   // number of addressing bits beyond those required for the element count.
88   if (llvm::isPowerOf2_64(ElementSize)) {
89     return NumElements.getActiveBits() + llvm::Log2_64(ElementSize);
90   }
91 
92   // If both the element count and element size fit in 32-bits, we can do the
93   // computation directly in 64-bits.
94   if ((ElementSize >> 32) == 0 && NumElements.getBitWidth() <= 64 &&
95       (NumElements.getZExtValue() >> 32) == 0) {
96     uint64_t TotalSize = NumElements.getZExtValue() * ElementSize;
97     return 64 - llvm::countLeadingZeros(TotalSize);
98   }
99 
100   // Otherwise, use APSInt to handle arbitrary sized values.
101   llvm::APSInt SizeExtended(NumElements, true);
102   unsigned SizeTypeBits = Context.getTypeSize(Context.getSizeType());
103   SizeExtended = SizeExtended.extend(std::max(SizeTypeBits,
104                                               SizeExtended.getBitWidth()) * 2);
105 
106   llvm::APSInt TotalSize(llvm::APInt(SizeExtended.getBitWidth(), ElementSize));
107   TotalSize *= SizeExtended;
108 
109   return TotalSize.getActiveBits();
110 }
111 
getMaxSizeBits(const ASTContext & Context)112 unsigned ConstantArrayType::getMaxSizeBits(const ASTContext &Context) {
113   unsigned Bits = Context.getTypeSize(Context.getSizeType());
114 
115   // Limit the number of bits in size_t so that maximal bit size fits 64 bit
116   // integer (see PR8256).  We can do this as currently there is no hardware
117   // that supports full 64-bit virtual space.
118   if (Bits > 61)
119     Bits = 61;
120 
121   return Bits;
122 }
123 
DependentSizedArrayType(const ASTContext & Context,QualType et,QualType can,Expr * e,ArraySizeModifier sm,unsigned tq,SourceRange brackets)124 DependentSizedArrayType::DependentSizedArrayType(const ASTContext &Context,
125                                                  QualType et, QualType can,
126                                                  Expr *e, ArraySizeModifier sm,
127                                                  unsigned tq,
128                                                  SourceRange brackets)
129     : ArrayType(DependentSizedArray, et, can, sm, tq,
130                 (et->containsUnexpandedParameterPack() ||
131                  (e && e->containsUnexpandedParameterPack()))),
132       Context(Context), SizeExpr((Stmt*) e), Brackets(brackets)
133 {
134 }
135 
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,QualType ET,ArraySizeModifier SizeMod,unsigned TypeQuals,Expr * E)136 void DependentSizedArrayType::Profile(llvm::FoldingSetNodeID &ID,
137                                       const ASTContext &Context,
138                                       QualType ET,
139                                       ArraySizeModifier SizeMod,
140                                       unsigned TypeQuals,
141                                       Expr *E) {
142   ID.AddPointer(ET.getAsOpaquePtr());
143   ID.AddInteger(SizeMod);
144   ID.AddInteger(TypeQuals);
145   E->Profile(ID, Context, true);
146 }
147 
DependentSizedExtVectorType(const ASTContext & Context,QualType ElementType,QualType can,Expr * SizeExpr,SourceLocation loc)148 DependentSizedExtVectorType::DependentSizedExtVectorType(const
149                                                          ASTContext &Context,
150                                                          QualType ElementType,
151                                                          QualType can,
152                                                          Expr *SizeExpr,
153                                                          SourceLocation loc)
154     : Type(DependentSizedExtVector, can, /*Dependent=*/true,
155            /*InstantiationDependent=*/true,
156            ElementType->isVariablyModifiedType(),
157            (ElementType->containsUnexpandedParameterPack() ||
158             (SizeExpr && SizeExpr->containsUnexpandedParameterPack()))),
159       Context(Context), SizeExpr(SizeExpr), ElementType(ElementType),
160       loc(loc)
161 {
162 }
163 
164 void
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,QualType ElementType,Expr * SizeExpr)165 DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID,
166                                      const ASTContext &Context,
167                                      QualType ElementType, Expr *SizeExpr) {
168   ID.AddPointer(ElementType.getAsOpaquePtr());
169   SizeExpr->Profile(ID, Context, true);
170 }
171 
VectorType(QualType vecType,unsigned nElements,QualType canonType,VectorKind vecKind)172 VectorType::VectorType(QualType vecType, unsigned nElements, QualType canonType,
173                        VectorKind vecKind)
174     : VectorType(Vector, vecType, nElements, canonType, vecKind) {}
175 
VectorType(TypeClass tc,QualType vecType,unsigned nElements,QualType canonType,VectorKind vecKind)176 VectorType::VectorType(TypeClass tc, QualType vecType, unsigned nElements,
177                        QualType canonType, VectorKind vecKind)
178   : Type(tc, canonType, vecType->isDependentType(),
179          vecType->isInstantiationDependentType(),
180          vecType->isVariablyModifiedType(),
181          vecType->containsUnexpandedParameterPack()),
182     ElementType(vecType)
183 {
184   VectorTypeBits.VecKind = vecKind;
185   VectorTypeBits.NumElements = nElements;
186 }
187 
188 /// getArrayElementTypeNoTypeQual - If this is an array type, return the
189 /// element type of the array, potentially with type qualifiers missing.
190 /// This method should never be used when type qualifiers are meaningful.
getArrayElementTypeNoTypeQual() const191 const Type *Type::getArrayElementTypeNoTypeQual() const {
192   // If this is directly an array type, return it.
193   if (const ArrayType *ATy = dyn_cast<ArrayType>(this))
194     return ATy->getElementType().getTypePtr();
195 
196   // If the canonical form of this type isn't the right kind, reject it.
197   if (!isa<ArrayType>(CanonicalType))
198     return nullptr;
199 
200   // If this is a typedef for an array type, strip the typedef off without
201   // losing all typedef information.
202   return cast<ArrayType>(getUnqualifiedDesugaredType())
203     ->getElementType().getTypePtr();
204 }
205 
206 /// getDesugaredType - Return the specified type with any "sugar" removed from
207 /// the type.  This takes off typedefs, typeof's etc.  If the outer level of
208 /// the type is already concrete, it returns it unmodified.  This is similar
209 /// to getting the canonical type, but it doesn't remove *all* typedefs.  For
210 /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
211 /// concrete.
getDesugaredType(QualType T,const ASTContext & Context)212 QualType QualType::getDesugaredType(QualType T, const ASTContext &Context) {
213   SplitQualType split = getSplitDesugaredType(T);
214   return Context.getQualifiedType(split.Ty, split.Quals);
215 }
216 
getSingleStepDesugaredTypeImpl(QualType type,const ASTContext & Context)217 QualType QualType::getSingleStepDesugaredTypeImpl(QualType type,
218                                                   const ASTContext &Context) {
219   SplitQualType split = type.split();
220   QualType desugar = split.Ty->getLocallyUnqualifiedSingleStepDesugaredType();
221   return Context.getQualifiedType(desugar, split.Quals);
222 }
223 
getLocallyUnqualifiedSingleStepDesugaredType() const224 QualType Type::getLocallyUnqualifiedSingleStepDesugaredType() const {
225   switch (getTypeClass()) {
226 #define ABSTRACT_TYPE(Class, Parent)
227 #define TYPE(Class, Parent) \
228   case Type::Class: { \
229     const Class##Type *ty = cast<Class##Type>(this); \
230     if (!ty->isSugared()) return QualType(ty, 0); \
231     return ty->desugar(); \
232   }
233 #include "clang/AST/TypeNodes.def"
234   }
235   llvm_unreachable("bad type kind!");
236 }
237 
getSplitDesugaredType(QualType T)238 SplitQualType QualType::getSplitDesugaredType(QualType T) {
239   QualifierCollector Qs;
240 
241   QualType Cur = T;
242   while (true) {
243     const Type *CurTy = Qs.strip(Cur);
244     switch (CurTy->getTypeClass()) {
245 #define ABSTRACT_TYPE(Class, Parent)
246 #define TYPE(Class, Parent) \
247     case Type::Class: { \
248       const Class##Type *Ty = cast<Class##Type>(CurTy); \
249       if (!Ty->isSugared()) \
250         return SplitQualType(Ty, Qs); \
251       Cur = Ty->desugar(); \
252       break; \
253     }
254 #include "clang/AST/TypeNodes.def"
255     }
256   }
257 }
258 
getSplitUnqualifiedTypeImpl(QualType type)259 SplitQualType QualType::getSplitUnqualifiedTypeImpl(QualType type) {
260   SplitQualType split = type.split();
261 
262   // All the qualifiers we've seen so far.
263   Qualifiers quals = split.Quals;
264 
265   // The last type node we saw with any nodes inside it.
266   const Type *lastTypeWithQuals = split.Ty;
267 
268   while (true) {
269     QualType next;
270 
271     // Do a single-step desugar, aborting the loop if the type isn't
272     // sugared.
273     switch (split.Ty->getTypeClass()) {
274 #define ABSTRACT_TYPE(Class, Parent)
275 #define TYPE(Class, Parent) \
276     case Type::Class: { \
277       const Class##Type *ty = cast<Class##Type>(split.Ty); \
278       if (!ty->isSugared()) goto done; \
279       next = ty->desugar(); \
280       break; \
281     }
282 #include "clang/AST/TypeNodes.def"
283     }
284 
285     // Otherwise, split the underlying type.  If that yields qualifiers,
286     // update the information.
287     split = next.split();
288     if (!split.Quals.empty()) {
289       lastTypeWithQuals = split.Ty;
290       quals.addConsistentQualifiers(split.Quals);
291     }
292   }
293 
294  done:
295   return SplitQualType(lastTypeWithQuals, quals);
296 }
297 
IgnoreParens(QualType T)298 QualType QualType::IgnoreParens(QualType T) {
299   // FIXME: this seems inherently un-qualifiers-safe.
300   while (const ParenType *PT = T->getAs<ParenType>())
301     T = PT->getInnerType();
302   return T;
303 }
304 
305 /// \brief This will check for a T (which should be a Type which can act as
306 /// sugar, such as a TypedefType) by removing any existing sugar until it
307 /// reaches a T or a non-sugared type.
getAsSugar(const Type * Cur)308 template<typename T> static const T *getAsSugar(const Type *Cur) {
309   while (true) {
310     if (const T *Sugar = dyn_cast<T>(Cur))
311       return Sugar;
312     switch (Cur->getTypeClass()) {
313 #define ABSTRACT_TYPE(Class, Parent)
314 #define TYPE(Class, Parent) \
315     case Type::Class: { \
316       const Class##Type *Ty = cast<Class##Type>(Cur); \
317       if (!Ty->isSugared()) return 0; \
318       Cur = Ty->desugar().getTypePtr(); \
319       break; \
320     }
321 #include "clang/AST/TypeNodes.def"
322     }
323   }
324 }
325 
getAs() const326 template <> const TypedefType *Type::getAs() const {
327   return getAsSugar<TypedefType>(this);
328 }
329 
getAs() const330 template <> const TemplateSpecializationType *Type::getAs() const {
331   return getAsSugar<TemplateSpecializationType>(this);
332 }
333 
getAs() const334 template <> const AttributedType *Type::getAs() const {
335   return getAsSugar<AttributedType>(this);
336 }
337 
338 /// getUnqualifiedDesugaredType - Pull any qualifiers and syntactic
339 /// sugar off the given type.  This should produce an object of the
340 /// same dynamic type as the canonical type.
getUnqualifiedDesugaredType() const341 const Type *Type::getUnqualifiedDesugaredType() const {
342   const Type *Cur = this;
343 
344   while (true) {
345     switch (Cur->getTypeClass()) {
346 #define ABSTRACT_TYPE(Class, Parent)
347 #define TYPE(Class, Parent) \
348     case Class: { \
349       const Class##Type *Ty = cast<Class##Type>(Cur); \
350       if (!Ty->isSugared()) return Cur; \
351       Cur = Ty->desugar().getTypePtr(); \
352       break; \
353     }
354 #include "clang/AST/TypeNodes.def"
355     }
356   }
357 }
isClassType() const358 bool Type::isClassType() const {
359   if (const RecordType *RT = getAs<RecordType>())
360     return RT->getDecl()->isClass();
361   return false;
362 }
isStructureType() const363 bool Type::isStructureType() const {
364   if (const RecordType *RT = getAs<RecordType>())
365     return RT->getDecl()->isStruct();
366   return false;
367 }
isObjCBoxableRecordType() const368 bool Type::isObjCBoxableRecordType() const {
369   if (const RecordType *RT = getAs<RecordType>())
370     return RT->getDecl()->hasAttr<ObjCBoxableAttr>();
371   return false;
372 }
isInterfaceType() const373 bool Type::isInterfaceType() const {
374   if (const RecordType *RT = getAs<RecordType>())
375     return RT->getDecl()->isInterface();
376   return false;
377 }
isStructureOrClassType() const378 bool Type::isStructureOrClassType() const {
379   if (const RecordType *RT = getAs<RecordType>()) {
380     RecordDecl *RD = RT->getDecl();
381     return RD->isStruct() || RD->isClass() || RD->isInterface();
382   }
383   return false;
384 }
isVoidPointerType() const385 bool Type::isVoidPointerType() const {
386   if (const PointerType *PT = getAs<PointerType>())
387     return PT->getPointeeType()->isVoidType();
388   return false;
389 }
390 
isUnionType() const391 bool Type::isUnionType() const {
392   if (const RecordType *RT = getAs<RecordType>())
393     return RT->getDecl()->isUnion();
394   return false;
395 }
396 
isComplexType() const397 bool Type::isComplexType() const {
398   if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType))
399     return CT->getElementType()->isFloatingType();
400   return false;
401 }
402 
isComplexIntegerType() const403 bool Type::isComplexIntegerType() const {
404   // Check for GCC complex integer extension.
405   return getAsComplexIntegerType();
406 }
407 
getAsComplexIntegerType() const408 const ComplexType *Type::getAsComplexIntegerType() const {
409   if (const ComplexType *Complex = getAs<ComplexType>())
410     if (Complex->getElementType()->isIntegerType())
411       return Complex;
412   return nullptr;
413 }
414 
getPointeeType() const415 QualType Type::getPointeeType() const {
416   if (const PointerType *PT = getAs<PointerType>())
417     return PT->getPointeeType();
418   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>())
419     return OPT->getPointeeType();
420   if (const BlockPointerType *BPT = getAs<BlockPointerType>())
421     return BPT->getPointeeType();
422   if (const ReferenceType *RT = getAs<ReferenceType>())
423     return RT->getPointeeType();
424   if (const MemberPointerType *MPT = getAs<MemberPointerType>())
425     return MPT->getPointeeType();
426   if (const DecayedType *DT = getAs<DecayedType>())
427     return DT->getPointeeType();
428   return QualType();
429 }
430 
getAsStructureType() const431 const RecordType *Type::getAsStructureType() const {
432   // If this is directly a structure type, return it.
433   if (const RecordType *RT = dyn_cast<RecordType>(this)) {
434     if (RT->getDecl()->isStruct())
435       return RT;
436   }
437 
438   // If the canonical form of this type isn't the right kind, reject it.
439   if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) {
440     if (!RT->getDecl()->isStruct())
441       return nullptr;
442 
443     // If this is a typedef for a structure type, strip the typedef off without
444     // losing all typedef information.
445     return cast<RecordType>(getUnqualifiedDesugaredType());
446   }
447   return nullptr;
448 }
449 
getAsUnionType() const450 const RecordType *Type::getAsUnionType() const {
451   // If this is directly a union type, return it.
452   if (const RecordType *RT = dyn_cast<RecordType>(this)) {
453     if (RT->getDecl()->isUnion())
454       return RT;
455   }
456 
457   // If the canonical form of this type isn't the right kind, reject it.
458   if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) {
459     if (!RT->getDecl()->isUnion())
460       return nullptr;
461 
462     // If this is a typedef for a union type, strip the typedef off without
463     // losing all typedef information.
464     return cast<RecordType>(getUnqualifiedDesugaredType());
465   }
466 
467   return nullptr;
468 }
469 
isObjCIdOrObjectKindOfType(const ASTContext & ctx,const ObjCObjectType * & bound) const470 bool Type::isObjCIdOrObjectKindOfType(const ASTContext &ctx,
471                                       const ObjCObjectType *&bound) const {
472   bound = nullptr;
473 
474   const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>();
475   if (!OPT)
476     return false;
477 
478   // Easy case: id.
479   if (OPT->isObjCIdType())
480     return true;
481 
482   // If it's not a __kindof type, reject it now.
483   if (!OPT->isKindOfType())
484     return false;
485 
486   // If it's Class or qualified Class, it's not an object type.
487   if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType())
488     return false;
489 
490   // Figure out the type bound for the __kindof type.
491   bound = OPT->getObjectType()->stripObjCKindOfTypeAndQuals(ctx)
492             ->getAs<ObjCObjectType>();
493   return true;
494 }
495 
isObjCClassOrClassKindOfType() const496 bool Type::isObjCClassOrClassKindOfType() const {
497   const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>();
498   if (!OPT)
499     return false;
500 
501   // Easy case: Class.
502   if (OPT->isObjCClassType())
503     return true;
504 
505   // If it's not a __kindof type, reject it now.
506   if (!OPT->isKindOfType())
507     return false;
508 
509   // If it's Class or qualified Class, it's a class __kindof type.
510   return OPT->isObjCClassType() || OPT->isObjCQualifiedClassType();
511 }
512 
513 /// Was this type written with the special inert-in-MRC __unsafe_unretained
514 /// qualifier?
515 ///
516 /// This approximates the answer to the following question: if this
517 /// translation unit were compiled in ARC, would this type be qualified
518 /// with __unsafe_unretained?
isObjCInertUnsafeUnretainedType() const519 bool Type::isObjCInertUnsafeUnretainedType() const {
520   const Type *cur = this;
521   while (true) {
522     if (auto attributed = dyn_cast<AttributedType>(cur)) {
523       if (attributed->getAttrKind() ==
524             AttributedType::attr_objc_inert_unsafe_unretained)
525         return true;
526     }
527 
528     // Single-step desugar until we run out of sugar.
529     QualType next = cur->getLocallyUnqualifiedSingleStepDesugaredType();
530     if (next.getTypePtr() == cur) return false;
531     cur = next.getTypePtr();
532   }
533 }
534 
ObjCObjectType(QualType Canonical,QualType Base,ArrayRef<QualType> typeArgs,ArrayRef<ObjCProtocolDecl * > protocols,bool isKindOf)535 ObjCObjectType::ObjCObjectType(QualType Canonical, QualType Base,
536                                ArrayRef<QualType> typeArgs,
537                                ArrayRef<ObjCProtocolDecl *> protocols,
538                                bool isKindOf)
539   : Type(ObjCObject, Canonical, Base->isDependentType(),
540          Base->isInstantiationDependentType(),
541          Base->isVariablyModifiedType(),
542          Base->containsUnexpandedParameterPack()),
543     BaseType(Base)
544 {
545   ObjCObjectTypeBits.IsKindOf = isKindOf;
546 
547   ObjCObjectTypeBits.NumTypeArgs = typeArgs.size();
548   assert(getTypeArgsAsWritten().size() == typeArgs.size() &&
549          "bitfield overflow in type argument count");
550   ObjCObjectTypeBits.NumProtocols = protocols.size();
551   assert(getNumProtocols() == protocols.size() &&
552          "bitfield overflow in protocol count");
553   if (!typeArgs.empty())
554     memcpy(getTypeArgStorage(), typeArgs.data(),
555            typeArgs.size() * sizeof(QualType));
556   if (!protocols.empty())
557     memcpy(getProtocolStorage(), protocols.data(),
558            protocols.size() * sizeof(ObjCProtocolDecl*));
559 
560   for (auto typeArg : typeArgs) {
561     if (typeArg->isDependentType())
562       setDependent();
563     else if (typeArg->isInstantiationDependentType())
564       setInstantiationDependent();
565 
566     if (typeArg->containsUnexpandedParameterPack())
567       setContainsUnexpandedParameterPack();
568   }
569 }
570 
isSpecialized() const571 bool ObjCObjectType::isSpecialized() const {
572   // If we have type arguments written here, the type is specialized.
573   if (ObjCObjectTypeBits.NumTypeArgs > 0)
574     return true;
575 
576   // Otherwise, check whether the base type is specialized.
577   if (auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
578     // Terminate when we reach an interface type.
579     if (isa<ObjCInterfaceType>(objcObject))
580       return false;
581 
582     return objcObject->isSpecialized();
583   }
584 
585   // Not specialized.
586   return false;
587 }
588 
getTypeArgs() const589 ArrayRef<QualType> ObjCObjectType::getTypeArgs() const {
590   // We have type arguments written on this type.
591   if (isSpecializedAsWritten())
592     return getTypeArgsAsWritten();
593 
594   // Look at the base type, which might have type arguments.
595   if (auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
596     // Terminate when we reach an interface type.
597     if (isa<ObjCInterfaceType>(objcObject))
598       return { };
599 
600     return objcObject->getTypeArgs();
601   }
602 
603   // No type arguments.
604   return { };
605 }
606 
isKindOfType() const607 bool ObjCObjectType::isKindOfType() const {
608   if (isKindOfTypeAsWritten())
609     return true;
610 
611   // Look at the base type, which might have type arguments.
612   if (auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
613     // Terminate when we reach an interface type.
614     if (isa<ObjCInterfaceType>(objcObject))
615       return false;
616 
617     return objcObject->isKindOfType();
618   }
619 
620   // Not a "__kindof" type.
621   return false;
622 }
623 
stripObjCKindOfTypeAndQuals(const ASTContext & ctx) const624 QualType ObjCObjectType::stripObjCKindOfTypeAndQuals(
625            const ASTContext &ctx) const {
626   if (!isKindOfType() && qual_empty())
627     return QualType(this, 0);
628 
629   // Recursively strip __kindof.
630   SplitQualType splitBaseType = getBaseType().split();
631   QualType baseType(splitBaseType.Ty, 0);
632   if (const ObjCObjectType *baseObj
633         = splitBaseType.Ty->getAs<ObjCObjectType>()) {
634     baseType = baseObj->stripObjCKindOfTypeAndQuals(ctx);
635   }
636 
637   return ctx.getObjCObjectType(ctx.getQualifiedType(baseType,
638                                                     splitBaseType.Quals),
639                                getTypeArgsAsWritten(),
640                                /*protocols=*/{ },
641                                /*isKindOf=*/false);
642 }
643 
stripObjCKindOfTypeAndQuals(const ASTContext & ctx) const644 const ObjCObjectPointerType *ObjCObjectPointerType::stripObjCKindOfTypeAndQuals(
645                                const ASTContext &ctx) const {
646   if (!isKindOfType() && qual_empty())
647     return this;
648 
649   QualType obj = getObjectType()->stripObjCKindOfTypeAndQuals(ctx);
650   return ctx.getObjCObjectPointerType(obj)->castAs<ObjCObjectPointerType>();
651 }
652 
653 namespace {
654 
655 template<typename F>
656 QualType simpleTransform(ASTContext &ctx, QualType type, F &&f);
657 
658 /// Visitor used by simpleTransform() to perform the transformation.
659 template<typename F>
660 struct SimpleTransformVisitor
661          : public TypeVisitor<SimpleTransformVisitor<F>, QualType> {
662   ASTContext &Ctx;
663   F &&TheFunc;
664 
recurse__anon3066757e0111::SimpleTransformVisitor665   QualType recurse(QualType type) {
666     return simpleTransform(Ctx, type, std::move(TheFunc));
667   }
668 
669 public:
SimpleTransformVisitor__anon3066757e0111::SimpleTransformVisitor670   SimpleTransformVisitor(ASTContext &ctx, F &&f) : Ctx(ctx), TheFunc(std::move(f)) { }
671 
672   // None of the clients of this transformation can occur where
673   // there are dependent types, so skip dependent types.
674 #define TYPE(Class, Base)
675 #define DEPENDENT_TYPE(Class, Base) \
676   QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
677 #include "clang/AST/TypeNodes.def"
678 
679 #define TRIVIAL_TYPE_CLASS(Class) \
680   QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
681 
TRIVIAL_TYPE_CLASS__anon3066757e0111::SimpleTransformVisitor682   TRIVIAL_TYPE_CLASS(Builtin)
683 
684   QualType VisitComplexType(const ComplexType *T) {
685     QualType elementType = recurse(T->getElementType());
686     if (elementType.isNull())
687       return QualType();
688 
689     if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
690       return QualType(T, 0);
691 
692     return Ctx.getComplexType(elementType);
693   }
694 
VisitPointerType__anon3066757e0111::SimpleTransformVisitor695   QualType VisitPointerType(const PointerType *T) {
696     QualType pointeeType = recurse(T->getPointeeType());
697     if (pointeeType.isNull())
698       return QualType();
699 
700     if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
701       return QualType(T, 0);
702 
703     return Ctx.getPointerType(pointeeType);
704   }
705 
VisitBlockPointerType__anon3066757e0111::SimpleTransformVisitor706   QualType VisitBlockPointerType(const BlockPointerType *T) {
707     QualType pointeeType = recurse(T->getPointeeType());
708     if (pointeeType.isNull())
709       return QualType();
710 
711     if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
712       return QualType(T, 0);
713 
714     return Ctx.getBlockPointerType(pointeeType);
715   }
716 
VisitLValueReferenceType__anon3066757e0111::SimpleTransformVisitor717   QualType VisitLValueReferenceType(const LValueReferenceType *T) {
718     QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
719     if (pointeeType.isNull())
720       return QualType();
721 
722     if (pointeeType.getAsOpaquePtr()
723           == T->getPointeeTypeAsWritten().getAsOpaquePtr())
724       return QualType(T, 0);
725 
726     return Ctx.getLValueReferenceType(pointeeType, T->isSpelledAsLValue());
727   }
728 
VisitRValueReferenceType__anon3066757e0111::SimpleTransformVisitor729   QualType VisitRValueReferenceType(const RValueReferenceType *T) {
730     QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
731     if (pointeeType.isNull())
732       return QualType();
733 
734     if (pointeeType.getAsOpaquePtr()
735           == T->getPointeeTypeAsWritten().getAsOpaquePtr())
736       return QualType(T, 0);
737 
738     return Ctx.getRValueReferenceType(pointeeType);
739   }
740 
VisitMemberPointerType__anon3066757e0111::SimpleTransformVisitor741   QualType VisitMemberPointerType(const MemberPointerType *T) {
742     QualType pointeeType = recurse(T->getPointeeType());
743     if (pointeeType.isNull())
744       return QualType();
745 
746     if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
747       return QualType(T, 0);
748 
749     return Ctx.getMemberPointerType(pointeeType, T->getClass());
750   }
751 
VisitConstantArrayType__anon3066757e0111::SimpleTransformVisitor752   QualType VisitConstantArrayType(const ConstantArrayType *T) {
753     QualType elementType = recurse(T->getElementType());
754     if (elementType.isNull())
755       return QualType();
756 
757     if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
758       return QualType(T, 0);
759 
760     return Ctx.getConstantArrayType(elementType, T->getSize(),
761                                     T->getSizeModifier(),
762                                     T->getIndexTypeCVRQualifiers());
763   }
764 
VisitVariableArrayType__anon3066757e0111::SimpleTransformVisitor765   QualType VisitVariableArrayType(const VariableArrayType *T) {
766     QualType elementType = recurse(T->getElementType());
767     if (elementType.isNull())
768       return QualType();
769 
770     if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
771       return QualType(T, 0);
772 
773     return Ctx.getVariableArrayType(elementType, T->getSizeExpr(),
774                                     T->getSizeModifier(),
775                                     T->getIndexTypeCVRQualifiers(),
776                                     T->getBracketsRange());
777   }
778 
VisitIncompleteArrayType__anon3066757e0111::SimpleTransformVisitor779   QualType VisitIncompleteArrayType(const IncompleteArrayType *T) {
780     QualType elementType = recurse(T->getElementType());
781     if (elementType.isNull())
782       return QualType();
783 
784     if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
785       return QualType(T, 0);
786 
787     return Ctx.getIncompleteArrayType(elementType, T->getSizeModifier(),
788                                       T->getIndexTypeCVRQualifiers());
789   }
790 
VisitVectorType__anon3066757e0111::SimpleTransformVisitor791   QualType VisitVectorType(const VectorType *T) {
792     QualType elementType = recurse(T->getElementType());
793     if (elementType.isNull())
794       return QualType();
795 
796     if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
797       return QualType(T, 0);
798 
799     return Ctx.getVectorType(elementType, T->getNumElements(),
800                              T->getVectorKind());
801   }
802 
VisitExtVectorType__anon3066757e0111::SimpleTransformVisitor803   QualType VisitExtVectorType(const ExtVectorType *T) {
804     QualType elementType = recurse(T->getElementType());
805     if (elementType.isNull())
806       return QualType();
807 
808     if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
809       return QualType(T, 0);
810 
811     return Ctx.getExtVectorType(elementType, T->getNumElements());
812   }
813 
VisitFunctionNoProtoType__anon3066757e0111::SimpleTransformVisitor814   QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
815     QualType returnType = recurse(T->getReturnType());
816     if (returnType.isNull())
817       return QualType();
818 
819     if (returnType.getAsOpaquePtr() == T->getReturnType().getAsOpaquePtr())
820       return QualType(T, 0);
821 
822     return Ctx.getFunctionNoProtoType(returnType, T->getExtInfo());
823   }
824 
VisitFunctionProtoType__anon3066757e0111::SimpleTransformVisitor825   QualType VisitFunctionProtoType(const FunctionProtoType *T) {
826     QualType returnType = recurse(T->getReturnType());
827     if (returnType.isNull())
828       return QualType();
829 
830     // Transform parameter types.
831     SmallVector<QualType, 4> paramTypes;
832     bool paramChanged = false;
833     for (auto paramType : T->getParamTypes()) {
834       QualType newParamType = recurse(paramType);
835       if (newParamType.isNull())
836         return QualType();
837 
838       if (newParamType.getAsOpaquePtr() != paramType.getAsOpaquePtr())
839         paramChanged = true;
840 
841       paramTypes.push_back(newParamType);
842     }
843 
844     // Transform extended info.
845     FunctionProtoType::ExtProtoInfo info = T->getExtProtoInfo();
846     bool exceptionChanged = false;
847     if (info.ExceptionSpec.Type == EST_Dynamic) {
848       SmallVector<QualType, 4> exceptionTypes;
849       for (auto exceptionType : info.ExceptionSpec.Exceptions) {
850         QualType newExceptionType = recurse(exceptionType);
851         if (newExceptionType.isNull())
852           return QualType();
853 
854         if (newExceptionType.getAsOpaquePtr()
855               != exceptionType.getAsOpaquePtr())
856           exceptionChanged = true;
857 
858         exceptionTypes.push_back(newExceptionType);
859       }
860 
861       if (exceptionChanged) {
862         info.ExceptionSpec.Exceptions =
863             llvm::makeArrayRef(exceptionTypes).copy(Ctx);
864       }
865     }
866 
867     if (returnType.getAsOpaquePtr() == T->getReturnType().getAsOpaquePtr() &&
868         !paramChanged && !exceptionChanged)
869       return QualType(T, 0);
870 
871     return Ctx.getFunctionType(returnType, paramTypes, info);
872   }
873 
VisitParenType__anon3066757e0111::SimpleTransformVisitor874   QualType VisitParenType(const ParenType *T) {
875     QualType innerType = recurse(T->getInnerType());
876     if (innerType.isNull())
877       return QualType();
878 
879     if (innerType.getAsOpaquePtr() == T->getInnerType().getAsOpaquePtr())
880       return QualType(T, 0);
881 
882     return Ctx.getParenType(innerType);
883   }
884 
TRIVIAL_TYPE_CLASS__anon3066757e0111::SimpleTransformVisitor885   TRIVIAL_TYPE_CLASS(Typedef)
886 
887   QualType VisitAdjustedType(const AdjustedType *T) {
888     QualType originalType = recurse(T->getOriginalType());
889     if (originalType.isNull())
890       return QualType();
891 
892     QualType adjustedType = recurse(T->getAdjustedType());
893     if (adjustedType.isNull())
894       return QualType();
895 
896     if (originalType.getAsOpaquePtr()
897           == T->getOriginalType().getAsOpaquePtr() &&
898         adjustedType.getAsOpaquePtr() == T->getAdjustedType().getAsOpaquePtr())
899       return QualType(T, 0);
900 
901     return Ctx.getAdjustedType(originalType, adjustedType);
902   }
903 
VisitDecayedType__anon3066757e0111::SimpleTransformVisitor904   QualType VisitDecayedType(const DecayedType *T) {
905     QualType originalType = recurse(T->getOriginalType());
906     if (originalType.isNull())
907       return QualType();
908 
909     if (originalType.getAsOpaquePtr()
910           == T->getOriginalType().getAsOpaquePtr())
911       return QualType(T, 0);
912 
913     return Ctx.getDecayedType(originalType);
914   }
915 
916   TRIVIAL_TYPE_CLASS(TypeOfExpr)
TRIVIAL_TYPE_CLASS__anon3066757e0111::SimpleTransformVisitor917   TRIVIAL_TYPE_CLASS(TypeOf)
918   TRIVIAL_TYPE_CLASS(Decltype)
919   TRIVIAL_TYPE_CLASS(UnaryTransform)
920   TRIVIAL_TYPE_CLASS(Record)
921   TRIVIAL_TYPE_CLASS(Enum)
922 
923   // FIXME: Non-trivial to implement, but important for C++
924   TRIVIAL_TYPE_CLASS(Elaborated)
925 
926   QualType VisitAttributedType(const AttributedType *T) {
927     QualType modifiedType = recurse(T->getModifiedType());
928     if (modifiedType.isNull())
929       return QualType();
930 
931     QualType equivalentType = recurse(T->getEquivalentType());
932     if (equivalentType.isNull())
933       return QualType();
934 
935     if (modifiedType.getAsOpaquePtr()
936           == T->getModifiedType().getAsOpaquePtr() &&
937         equivalentType.getAsOpaquePtr()
938           == T->getEquivalentType().getAsOpaquePtr())
939       return QualType(T, 0);
940 
941     return Ctx.getAttributedType(T->getAttrKind(), modifiedType,
942                                  equivalentType);
943   }
944 
VisitSubstTemplateTypeParmType__anon3066757e0111::SimpleTransformVisitor945   QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
946     QualType replacementType = recurse(T->getReplacementType());
947     if (replacementType.isNull())
948       return QualType();
949 
950     if (replacementType.getAsOpaquePtr()
951           == T->getReplacementType().getAsOpaquePtr())
952       return QualType(T, 0);
953 
954     return Ctx.getSubstTemplateTypeParmType(T->getReplacedParameter(),
955                                             replacementType);
956   }
957 
958   // FIXME: Non-trivial to implement, but important for C++
TRIVIAL_TYPE_CLASS__anon3066757e0111::SimpleTransformVisitor959   TRIVIAL_TYPE_CLASS(TemplateSpecialization)
960 
961   QualType VisitAutoType(const AutoType *T) {
962     if (!T->isDeduced())
963       return QualType(T, 0);
964 
965     QualType deducedType = recurse(T->getDeducedType());
966     if (deducedType.isNull())
967       return QualType();
968 
969     if (deducedType.getAsOpaquePtr()
970           == T->getDeducedType().getAsOpaquePtr())
971       return QualType(T, 0);
972 
973     return Ctx.getAutoType(deducedType, T->getKeyword(),
974                            T->isDependentType());
975   }
976 
977   // FIXME: Non-trivial to implement, but important for C++
TRIVIAL_TYPE_CLASS__anon3066757e0111::SimpleTransformVisitor978   TRIVIAL_TYPE_CLASS(PackExpansion)
979 
980   QualType VisitObjCObjectType(const ObjCObjectType *T) {
981     QualType baseType = recurse(T->getBaseType());
982     if (baseType.isNull())
983       return QualType();
984 
985     // Transform type arguments.
986     bool typeArgChanged = false;
987     SmallVector<QualType, 4> typeArgs;
988     for (auto typeArg : T->getTypeArgsAsWritten()) {
989       QualType newTypeArg = recurse(typeArg);
990       if (newTypeArg.isNull())
991         return QualType();
992 
993       if (newTypeArg.getAsOpaquePtr() != typeArg.getAsOpaquePtr())
994         typeArgChanged = true;
995 
996       typeArgs.push_back(newTypeArg);
997     }
998 
999     if (baseType.getAsOpaquePtr() == T->getBaseType().getAsOpaquePtr() &&
1000         !typeArgChanged)
1001       return QualType(T, 0);
1002 
1003     return Ctx.getObjCObjectType(baseType, typeArgs,
1004                                  llvm::makeArrayRef(T->qual_begin(),
1005                                                     T->getNumProtocols()),
1006                                  T->isKindOfTypeAsWritten());
1007   }
1008 
TRIVIAL_TYPE_CLASS__anon3066757e0111::SimpleTransformVisitor1009   TRIVIAL_TYPE_CLASS(ObjCInterface)
1010 
1011   QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1012     QualType pointeeType = recurse(T->getPointeeType());
1013     if (pointeeType.isNull())
1014       return QualType();
1015 
1016     if (pointeeType.getAsOpaquePtr()
1017           == T->getPointeeType().getAsOpaquePtr())
1018       return QualType(T, 0);
1019 
1020     return Ctx.getObjCObjectPointerType(pointeeType);
1021   }
1022 
VisitAtomicType__anon3066757e0111::SimpleTransformVisitor1023   QualType VisitAtomicType(const AtomicType *T) {
1024     QualType valueType = recurse(T->getValueType());
1025     if (valueType.isNull())
1026       return QualType();
1027 
1028     if (valueType.getAsOpaquePtr()
1029           == T->getValueType().getAsOpaquePtr())
1030       return QualType(T, 0);
1031 
1032     return Ctx.getAtomicType(valueType);
1033   }
1034 
1035 #undef TRIVIAL_TYPE_CLASS
1036 };
1037 
1038 /// Perform a simple type transformation that does not change the
1039 /// semantics of the type.
1040 template<typename F>
simpleTransform(ASTContext & ctx,QualType type,F && f)1041 QualType simpleTransform(ASTContext &ctx, QualType type, F &&f) {
1042   // Transform the type. If it changed, return the transformed result.
1043   QualType transformed = f(type);
1044   if (transformed.getAsOpaquePtr() != type.getAsOpaquePtr())
1045     return transformed;
1046 
1047   // Split out the qualifiers from the type.
1048   SplitQualType splitType = type.split();
1049 
1050   // Visit the type itself.
1051   SimpleTransformVisitor<F> visitor(ctx, std::move(f));
1052   QualType result = visitor.Visit(splitType.Ty);
1053   if (result.isNull())
1054     return result;
1055 
1056   // Reconstruct the transformed type by applying the local qualifiers
1057   // from the split type.
1058   return ctx.getQualifiedType(result, splitType.Quals);
1059 }
1060 
1061 } // end anonymous namespace
1062 
1063 /// Substitute the given type arguments for Objective-C type
1064 /// parameters within the given type, recursively.
substObjCTypeArgs(ASTContext & ctx,ArrayRef<QualType> typeArgs,ObjCSubstitutionContext context) const1065 QualType QualType::substObjCTypeArgs(
1066            ASTContext &ctx,
1067            ArrayRef<QualType> typeArgs,
1068            ObjCSubstitutionContext context) const {
1069   return simpleTransform(ctx, *this,
1070                          [&](QualType type) -> QualType {
1071     SplitQualType splitType = type.split();
1072 
1073     // Replace an Objective-C type parameter reference with the corresponding
1074     // type argument.
1075     if (const auto *typedefTy = dyn_cast<TypedefType>(splitType.Ty)) {
1076       if (auto *typeParam = dyn_cast<ObjCTypeParamDecl>(typedefTy->getDecl())) {
1077         // If we have type arguments, use them.
1078         if (!typeArgs.empty()) {
1079           // FIXME: Introduce SubstObjCTypeParamType ?
1080           QualType argType = typeArgs[typeParam->getIndex()];
1081           return ctx.getQualifiedType(argType, splitType.Quals);
1082         }
1083 
1084         switch (context) {
1085         case ObjCSubstitutionContext::Ordinary:
1086         case ObjCSubstitutionContext::Parameter:
1087         case ObjCSubstitutionContext::Superclass:
1088           // Substitute the bound.
1089           return ctx.getQualifiedType(typeParam->getUnderlyingType(),
1090                                       splitType.Quals);
1091 
1092         case ObjCSubstitutionContext::Result:
1093         case ObjCSubstitutionContext::Property: {
1094           // Substitute the __kindof form of the underlying type.
1095           const auto *objPtr = typeParam->getUnderlyingType()
1096             ->castAs<ObjCObjectPointerType>();
1097 
1098           // __kindof types, id, and Class don't need an additional
1099           // __kindof.
1100           if (objPtr->isKindOfType() || objPtr->isObjCIdOrClassType())
1101             return ctx.getQualifiedType(typeParam->getUnderlyingType(),
1102                                         splitType.Quals);
1103 
1104           // Add __kindof.
1105           const auto *obj = objPtr->getObjectType();
1106           QualType resultTy = ctx.getObjCObjectType(obj->getBaseType(),
1107                                                     obj->getTypeArgsAsWritten(),
1108                                                     obj->getProtocols(),
1109                                                     /*isKindOf=*/true);
1110 
1111           // Rebuild object pointer type.
1112           resultTy = ctx.getObjCObjectPointerType(resultTy);
1113           return ctx.getQualifiedType(resultTy, splitType.Quals);
1114         }
1115         }
1116       }
1117     }
1118 
1119     // If we have a function type, update the context appropriately.
1120     if (const auto *funcType = dyn_cast<FunctionType>(splitType.Ty)) {
1121       // Substitute result type.
1122       QualType returnType = funcType->getReturnType().substObjCTypeArgs(
1123                               ctx,
1124                               typeArgs,
1125                               ObjCSubstitutionContext::Result);
1126       if (returnType.isNull())
1127         return QualType();
1128 
1129       // Handle non-prototyped functions, which only substitute into the result
1130       // type.
1131       if (isa<FunctionNoProtoType>(funcType)) {
1132         // If the return type was unchanged, do nothing.
1133         if (returnType.getAsOpaquePtr()
1134               == funcType->getReturnType().getAsOpaquePtr())
1135           return type;
1136 
1137         // Otherwise, build a new type.
1138         return ctx.getFunctionNoProtoType(returnType, funcType->getExtInfo());
1139       }
1140 
1141       const auto *funcProtoType = cast<FunctionProtoType>(funcType);
1142 
1143       // Transform parameter types.
1144       SmallVector<QualType, 4> paramTypes;
1145       bool paramChanged = false;
1146       for (auto paramType : funcProtoType->getParamTypes()) {
1147         QualType newParamType = paramType.substObjCTypeArgs(
1148                                   ctx,
1149                                   typeArgs,
1150                                   ObjCSubstitutionContext::Parameter);
1151         if (newParamType.isNull())
1152           return QualType();
1153 
1154         if (newParamType.getAsOpaquePtr() != paramType.getAsOpaquePtr())
1155           paramChanged = true;
1156 
1157         paramTypes.push_back(newParamType);
1158       }
1159 
1160       // Transform extended info.
1161       FunctionProtoType::ExtProtoInfo info = funcProtoType->getExtProtoInfo();
1162       bool exceptionChanged = false;
1163       if (info.ExceptionSpec.Type == EST_Dynamic) {
1164         SmallVector<QualType, 4> exceptionTypes;
1165         for (auto exceptionType : info.ExceptionSpec.Exceptions) {
1166           QualType newExceptionType = exceptionType.substObjCTypeArgs(
1167                                         ctx,
1168                                         typeArgs,
1169                                         ObjCSubstitutionContext::Ordinary);
1170           if (newExceptionType.isNull())
1171             return QualType();
1172 
1173           if (newExceptionType.getAsOpaquePtr()
1174               != exceptionType.getAsOpaquePtr())
1175             exceptionChanged = true;
1176 
1177           exceptionTypes.push_back(newExceptionType);
1178         }
1179 
1180         if (exceptionChanged) {
1181           info.ExceptionSpec.Exceptions =
1182               llvm::makeArrayRef(exceptionTypes).copy(ctx);
1183         }
1184       }
1185 
1186       if (returnType.getAsOpaquePtr()
1187             == funcProtoType->getReturnType().getAsOpaquePtr() &&
1188           !paramChanged && !exceptionChanged)
1189         return type;
1190 
1191       return ctx.getFunctionType(returnType, paramTypes, info);
1192     }
1193 
1194     // Substitute into the type arguments of a specialized Objective-C object
1195     // type.
1196     if (const auto *objcObjectType = dyn_cast<ObjCObjectType>(splitType.Ty)) {
1197       if (objcObjectType->isSpecializedAsWritten()) {
1198         SmallVector<QualType, 4> newTypeArgs;
1199         bool anyChanged = false;
1200         for (auto typeArg : objcObjectType->getTypeArgsAsWritten()) {
1201           QualType newTypeArg = typeArg.substObjCTypeArgs(
1202                                   ctx, typeArgs,
1203                                   ObjCSubstitutionContext::Ordinary);
1204           if (newTypeArg.isNull())
1205             return QualType();
1206 
1207           if (newTypeArg.getAsOpaquePtr() != typeArg.getAsOpaquePtr()) {
1208             // If we're substituting based on an unspecialized context type,
1209             // produce an unspecialized type.
1210             ArrayRef<ObjCProtocolDecl *> protocols(
1211                                            objcObjectType->qual_begin(),
1212                                            objcObjectType->getNumProtocols());
1213             if (typeArgs.empty() &&
1214                 context != ObjCSubstitutionContext::Superclass) {
1215               return ctx.getObjCObjectType(
1216                        objcObjectType->getBaseType(), { },
1217                        protocols,
1218                        objcObjectType->isKindOfTypeAsWritten());
1219             }
1220 
1221             anyChanged = true;
1222           }
1223 
1224           newTypeArgs.push_back(newTypeArg);
1225         }
1226 
1227         if (anyChanged) {
1228           ArrayRef<ObjCProtocolDecl *> protocols(
1229                                          objcObjectType->qual_begin(),
1230                                          objcObjectType->getNumProtocols());
1231           return ctx.getObjCObjectType(objcObjectType->getBaseType(),
1232                                        newTypeArgs, protocols,
1233                                        objcObjectType->isKindOfTypeAsWritten());
1234         }
1235       }
1236 
1237       return type;
1238     }
1239 
1240     return type;
1241   });
1242 }
1243 
substObjCMemberType(QualType objectType,const DeclContext * dc,ObjCSubstitutionContext context) const1244 QualType QualType::substObjCMemberType(QualType objectType,
1245                                        const DeclContext *dc,
1246                                        ObjCSubstitutionContext context) const {
1247   if (auto subs = objectType->getObjCSubstitutions(dc))
1248     return substObjCTypeArgs(dc->getParentASTContext(), *subs, context);
1249 
1250   return *this;
1251 }
1252 
stripObjCKindOfType(const ASTContext & constCtx) const1253 QualType QualType::stripObjCKindOfType(const ASTContext &constCtx) const {
1254   // FIXME: Because ASTContext::getAttributedType() is non-const.
1255   auto &ctx = const_cast<ASTContext &>(constCtx);
1256   return simpleTransform(ctx, *this,
1257            [&](QualType type) -> QualType {
1258              SplitQualType splitType = type.split();
1259              if (auto *objType = splitType.Ty->getAs<ObjCObjectType>()) {
1260                if (!objType->isKindOfType())
1261                  return type;
1262 
1263                QualType baseType
1264                  = objType->getBaseType().stripObjCKindOfType(ctx);
1265                return ctx.getQualifiedType(
1266                         ctx.getObjCObjectType(baseType,
1267                                               objType->getTypeArgsAsWritten(),
1268                                               objType->getProtocols(),
1269                                               /*isKindOf=*/false),
1270                         splitType.Quals);
1271              }
1272 
1273              return type;
1274            });
1275 }
1276 
getAtomicUnqualifiedType() const1277 QualType QualType::getAtomicUnqualifiedType() const {
1278   if (auto AT = getTypePtr()->getAs<AtomicType>())
1279     return AT->getValueType().getUnqualifiedType();
1280   return getUnqualifiedType();
1281 }
1282 
getObjCSubstitutions(const DeclContext * dc) const1283 Optional<ArrayRef<QualType>> Type::getObjCSubstitutions(
1284                                const DeclContext *dc) const {
1285   // Look through method scopes.
1286   if (auto method = dyn_cast<ObjCMethodDecl>(dc))
1287     dc = method->getDeclContext();
1288 
1289   // Find the class or category in which the type we're substituting
1290   // was declared.
1291   const ObjCInterfaceDecl *dcClassDecl = dyn_cast<ObjCInterfaceDecl>(dc);
1292   const ObjCCategoryDecl *dcCategoryDecl = nullptr;
1293   ObjCTypeParamList *dcTypeParams = nullptr;
1294   if (dcClassDecl) {
1295     // If the class does not have any type parameters, there's no
1296     // substitution to do.
1297     dcTypeParams = dcClassDecl->getTypeParamList();
1298     if (!dcTypeParams)
1299       return None;
1300   } else {
1301     // If we are in neither a class nor a category, there's no
1302     // substitution to perform.
1303     dcCategoryDecl = dyn_cast<ObjCCategoryDecl>(dc);
1304     if (!dcCategoryDecl)
1305       return None;
1306 
1307     // If the category does not have any type parameters, there's no
1308     // substitution to do.
1309     dcTypeParams = dcCategoryDecl->getTypeParamList();
1310     if (!dcTypeParams)
1311       return None;
1312 
1313     dcClassDecl = dcCategoryDecl->getClassInterface();
1314     if (!dcClassDecl)
1315       return None;
1316   }
1317   assert(dcTypeParams && "No substitutions to perform");
1318   assert(dcClassDecl && "No class context");
1319 
1320   // Find the underlying object type.
1321   const ObjCObjectType *objectType;
1322   if (const auto *objectPointerType = getAs<ObjCObjectPointerType>()) {
1323     objectType = objectPointerType->getObjectType();
1324   } else if (getAs<BlockPointerType>()) {
1325     ASTContext &ctx = dc->getParentASTContext();
1326     objectType = ctx.getObjCObjectType(ctx.ObjCBuiltinIdTy, { }, { })
1327                    ->castAs<ObjCObjectType>();;
1328   } else {
1329     objectType = getAs<ObjCObjectType>();
1330   }
1331 
1332   /// Extract the class from the receiver object type.
1333   ObjCInterfaceDecl *curClassDecl = objectType ? objectType->getInterface()
1334                                                : nullptr;
1335   if (!curClassDecl) {
1336     // If we don't have a context type (e.g., this is "id" or some
1337     // variant thereof), substitute the bounds.
1338     return llvm::ArrayRef<QualType>();
1339   }
1340 
1341   // Follow the superclass chain until we've mapped the receiver type
1342   // to the same class as the context.
1343   while (curClassDecl != dcClassDecl) {
1344     // Map to the superclass type.
1345     QualType superType = objectType->getSuperClassType();
1346     if (superType.isNull()) {
1347       objectType = nullptr;
1348       break;
1349     }
1350 
1351     objectType = superType->castAs<ObjCObjectType>();
1352     curClassDecl = objectType->getInterface();
1353   }
1354 
1355   // If we don't have a receiver type, or the receiver type does not
1356   // have type arguments, substitute in the defaults.
1357   if (!objectType || objectType->isUnspecialized()) {
1358     return llvm::ArrayRef<QualType>();
1359   }
1360 
1361   // The receiver type has the type arguments we want.
1362   return objectType->getTypeArgs();
1363 }
1364 
acceptsObjCTypeParams() const1365 bool Type::acceptsObjCTypeParams() const {
1366   if (auto *IfaceT = getAsObjCInterfaceType()) {
1367     if (auto *ID = IfaceT->getInterface()) {
1368       if (ID->getTypeParamList())
1369         return true;
1370     }
1371   }
1372 
1373   return false;
1374 }
1375 
computeSuperClassTypeSlow() const1376 void ObjCObjectType::computeSuperClassTypeSlow() const {
1377   // Retrieve the class declaration for this type. If there isn't one
1378   // (e.g., this is some variant of "id" or "Class"), then there is no
1379   // superclass type.
1380   ObjCInterfaceDecl *classDecl = getInterface();
1381   if (!classDecl) {
1382     CachedSuperClassType.setInt(true);
1383     return;
1384   }
1385 
1386   // Extract the superclass type.
1387   const ObjCObjectType *superClassObjTy = classDecl->getSuperClassType();
1388   if (!superClassObjTy) {
1389     CachedSuperClassType.setInt(true);
1390     return;
1391   }
1392 
1393   ObjCInterfaceDecl *superClassDecl = superClassObjTy->getInterface();
1394   if (!superClassDecl) {
1395     CachedSuperClassType.setInt(true);
1396     return;
1397   }
1398 
1399   // If the superclass doesn't have type parameters, then there is no
1400   // substitution to perform.
1401   QualType superClassType(superClassObjTy, 0);
1402   ObjCTypeParamList *superClassTypeParams = superClassDecl->getTypeParamList();
1403   if (!superClassTypeParams) {
1404     CachedSuperClassType.setPointerAndInt(
1405       superClassType->castAs<ObjCObjectType>(), true);
1406     return;
1407   }
1408 
1409   // If the superclass reference is unspecialized, return it.
1410   if (superClassObjTy->isUnspecialized()) {
1411     CachedSuperClassType.setPointerAndInt(superClassObjTy, true);
1412     return;
1413   }
1414 
1415   // If the subclass is not parameterized, there aren't any type
1416   // parameters in the superclass reference to substitute.
1417   ObjCTypeParamList *typeParams = classDecl->getTypeParamList();
1418   if (!typeParams) {
1419     CachedSuperClassType.setPointerAndInt(
1420       superClassType->castAs<ObjCObjectType>(), true);
1421     return;
1422   }
1423 
1424   // If the subclass type isn't specialized, return the unspecialized
1425   // superclass.
1426   if (isUnspecialized()) {
1427     QualType unspecializedSuper
1428       = classDecl->getASTContext().getObjCInterfaceType(
1429           superClassObjTy->getInterface());
1430     CachedSuperClassType.setPointerAndInt(
1431       unspecializedSuper->castAs<ObjCObjectType>(),
1432       true);
1433     return;
1434   }
1435 
1436   // Substitute the provided type arguments into the superclass type.
1437   ArrayRef<QualType> typeArgs = getTypeArgs();
1438   assert(typeArgs.size() == typeParams->size());
1439   CachedSuperClassType.setPointerAndInt(
1440     superClassType.substObjCTypeArgs(classDecl->getASTContext(), typeArgs,
1441                                      ObjCSubstitutionContext::Superclass)
1442       ->castAs<ObjCObjectType>(),
1443     true);
1444 }
1445 
getInterfaceType() const1446 const ObjCInterfaceType *ObjCObjectPointerType::getInterfaceType() const {
1447   if (auto interfaceDecl = getObjectType()->getInterface()) {
1448     return interfaceDecl->getASTContext().getObjCInterfaceType(interfaceDecl)
1449              ->castAs<ObjCInterfaceType>();
1450   }
1451 
1452   return nullptr;
1453 }
1454 
getSuperClassType() const1455 QualType ObjCObjectPointerType::getSuperClassType() const {
1456   QualType superObjectType = getObjectType()->getSuperClassType();
1457   if (superObjectType.isNull())
1458     return superObjectType;
1459 
1460   ASTContext &ctx = getInterfaceDecl()->getASTContext();
1461   return ctx.getObjCObjectPointerType(superObjectType);
1462 }
1463 
getAsObjCQualifiedInterfaceType() const1464 const ObjCObjectType *Type::getAsObjCQualifiedInterfaceType() const {
1465   // There is no sugar for ObjCObjectType's, just return the canonical
1466   // type pointer if it is the right class.  There is no typedef information to
1467   // return and these cannot be Address-space qualified.
1468   if (const ObjCObjectType *T = getAs<ObjCObjectType>())
1469     if (T->getNumProtocols() && T->getInterface())
1470       return T;
1471   return nullptr;
1472 }
1473 
isObjCQualifiedInterfaceType() const1474 bool Type::isObjCQualifiedInterfaceType() const {
1475   return getAsObjCQualifiedInterfaceType() != nullptr;
1476 }
1477 
getAsObjCQualifiedIdType() const1478 const ObjCObjectPointerType *Type::getAsObjCQualifiedIdType() const {
1479   // There is no sugar for ObjCQualifiedIdType's, just return the canonical
1480   // type pointer if it is the right class.
1481   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) {
1482     if (OPT->isObjCQualifiedIdType())
1483       return OPT;
1484   }
1485   return nullptr;
1486 }
1487 
getAsObjCQualifiedClassType() const1488 const ObjCObjectPointerType *Type::getAsObjCQualifiedClassType() const {
1489   // There is no sugar for ObjCQualifiedClassType's, just return the canonical
1490   // type pointer if it is the right class.
1491   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) {
1492     if (OPT->isObjCQualifiedClassType())
1493       return OPT;
1494   }
1495   return nullptr;
1496 }
1497 
getAsObjCInterfaceType() const1498 const ObjCObjectType *Type::getAsObjCInterfaceType() const {
1499   if (const ObjCObjectType *OT = getAs<ObjCObjectType>()) {
1500     if (OT->getInterface())
1501       return OT;
1502   }
1503   return nullptr;
1504 }
getAsObjCInterfacePointerType() const1505 const ObjCObjectPointerType *Type::getAsObjCInterfacePointerType() const {
1506   if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) {
1507     if (OPT->getInterfaceType())
1508       return OPT;
1509   }
1510   return nullptr;
1511 }
1512 
getPointeeCXXRecordDecl() const1513 const CXXRecordDecl *Type::getPointeeCXXRecordDecl() const {
1514   QualType PointeeType;
1515   if (const PointerType *PT = getAs<PointerType>())
1516     PointeeType = PT->getPointeeType();
1517   else if (const ReferenceType *RT = getAs<ReferenceType>())
1518     PointeeType = RT->getPointeeType();
1519   else
1520     return nullptr;
1521 
1522   if (const RecordType *RT = PointeeType->getAs<RecordType>())
1523     return dyn_cast<CXXRecordDecl>(RT->getDecl());
1524 
1525   return nullptr;
1526 }
1527 
getAsCXXRecordDecl() const1528 CXXRecordDecl *Type::getAsCXXRecordDecl() const {
1529   return dyn_cast_or_null<CXXRecordDecl>(getAsTagDecl());
1530 }
1531 
getAsTagDecl() const1532 TagDecl *Type::getAsTagDecl() const {
1533   if (const auto *TT = getAs<TagType>())
1534     return cast<TagDecl>(TT->getDecl());
1535   if (const auto *Injected = getAs<InjectedClassNameType>())
1536     return Injected->getDecl();
1537 
1538   return nullptr;
1539 }
1540 
1541 namespace {
1542   class GetContainedAutoVisitor :
1543     public TypeVisitor<GetContainedAutoVisitor, AutoType*> {
1544   public:
1545     using TypeVisitor<GetContainedAutoVisitor, AutoType*>::Visit;
Visit(QualType T)1546     AutoType *Visit(QualType T) {
1547       if (T.isNull())
1548         return nullptr;
1549       return Visit(T.getTypePtr());
1550     }
1551 
1552     // The 'auto' type itself.
VisitAutoType(const AutoType * AT)1553     AutoType *VisitAutoType(const AutoType *AT) {
1554       return const_cast<AutoType*>(AT);
1555     }
1556 
1557     // Only these types can contain the desired 'auto' type.
VisitPointerType(const PointerType * T)1558     AutoType *VisitPointerType(const PointerType *T) {
1559       return Visit(T->getPointeeType());
1560     }
VisitBlockPointerType(const BlockPointerType * T)1561     AutoType *VisitBlockPointerType(const BlockPointerType *T) {
1562       return Visit(T->getPointeeType());
1563     }
VisitReferenceType(const ReferenceType * T)1564     AutoType *VisitReferenceType(const ReferenceType *T) {
1565       return Visit(T->getPointeeTypeAsWritten());
1566     }
VisitMemberPointerType(const MemberPointerType * T)1567     AutoType *VisitMemberPointerType(const MemberPointerType *T) {
1568       return Visit(T->getPointeeType());
1569     }
VisitArrayType(const ArrayType * T)1570     AutoType *VisitArrayType(const ArrayType *T) {
1571       return Visit(T->getElementType());
1572     }
VisitDependentSizedExtVectorType(const DependentSizedExtVectorType * T)1573     AutoType *VisitDependentSizedExtVectorType(
1574       const DependentSizedExtVectorType *T) {
1575       return Visit(T->getElementType());
1576     }
VisitVectorType(const VectorType * T)1577     AutoType *VisitVectorType(const VectorType *T) {
1578       return Visit(T->getElementType());
1579     }
VisitFunctionType(const FunctionType * T)1580     AutoType *VisitFunctionType(const FunctionType *T) {
1581       return Visit(T->getReturnType());
1582     }
VisitParenType(const ParenType * T)1583     AutoType *VisitParenType(const ParenType *T) {
1584       return Visit(T->getInnerType());
1585     }
VisitAttributedType(const AttributedType * T)1586     AutoType *VisitAttributedType(const AttributedType *T) {
1587       return Visit(T->getModifiedType());
1588     }
VisitAdjustedType(const AdjustedType * T)1589     AutoType *VisitAdjustedType(const AdjustedType *T) {
1590       return Visit(T->getOriginalType());
1591     }
1592   };
1593 }
1594 
getContainedAutoType() const1595 AutoType *Type::getContainedAutoType() const {
1596   return GetContainedAutoVisitor().Visit(this);
1597 }
1598 
hasIntegerRepresentation() const1599 bool Type::hasIntegerRepresentation() const {
1600   if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
1601     return VT->getElementType()->isIntegerType();
1602   else
1603     return isIntegerType();
1604 }
1605 
1606 /// \brief Determine whether this type is an integral type.
1607 ///
1608 /// This routine determines whether the given type is an integral type per
1609 /// C++ [basic.fundamental]p7. Although the C standard does not define the
1610 /// term "integral type", it has a similar term "integer type", and in C++
1611 /// the two terms are equivalent. However, C's "integer type" includes
1612 /// enumeration types, while C++'s "integer type" does not. The \c ASTContext
1613 /// parameter is used to determine whether we should be following the C or
1614 /// C++ rules when determining whether this type is an integral/integer type.
1615 ///
1616 /// For cases where C permits "an integer type" and C++ permits "an integral
1617 /// type", use this routine.
1618 ///
1619 /// For cases where C permits "an integer type" and C++ permits "an integral
1620 /// or enumeration type", use \c isIntegralOrEnumerationType() instead.
1621 ///
1622 /// \param Ctx The context in which this type occurs.
1623 ///
1624 /// \returns true if the type is considered an integral type, false otherwise.
isIntegralType(const ASTContext & Ctx) const1625 bool Type::isIntegralType(const ASTContext &Ctx) const {
1626   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1627     return BT->getKind() >= BuiltinType::Bool &&
1628            BT->getKind() <= BuiltinType::Int128;
1629 
1630   // Complete enum types are integral in C.
1631   if (!Ctx.getLangOpts().CPlusPlus)
1632     if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
1633       return ET->getDecl()->isComplete();
1634 
1635   return false;
1636 }
1637 
1638 
isIntegralOrUnscopedEnumerationType() const1639 bool Type::isIntegralOrUnscopedEnumerationType() const {
1640   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1641     return BT->getKind() >= BuiltinType::Bool &&
1642            BT->getKind() <= BuiltinType::Int128;
1643 
1644   // Check for a complete enum type; incomplete enum types are not properly an
1645   // enumeration type in the sense required here.
1646   // C++0x: However, if the underlying type of the enum is fixed, it is
1647   // considered complete.
1648   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
1649     return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
1650 
1651   return false;
1652 }
1653 
1654 
1655 
isCharType() const1656 bool Type::isCharType() const {
1657   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1658     return BT->getKind() == BuiltinType::Char_U ||
1659            BT->getKind() == BuiltinType::UChar ||
1660            BT->getKind() == BuiltinType::Char_S ||
1661            BT->getKind() == BuiltinType::SChar;
1662   return false;
1663 }
1664 
isWideCharType() const1665 bool Type::isWideCharType() const {
1666   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1667     return BT->getKind() == BuiltinType::WChar_S ||
1668            BT->getKind() == BuiltinType::WChar_U;
1669   return false;
1670 }
1671 
isChar16Type() const1672 bool Type::isChar16Type() const {
1673   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1674     return BT->getKind() == BuiltinType::Char16;
1675   return false;
1676 }
1677 
isChar32Type() const1678 bool Type::isChar32Type() const {
1679   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1680     return BT->getKind() == BuiltinType::Char32;
1681   return false;
1682 }
1683 
1684 /// \brief Determine whether this type is any of the built-in character
1685 /// types.
isAnyCharacterType() const1686 bool Type::isAnyCharacterType() const {
1687   const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType);
1688   if (!BT) return false;
1689   switch (BT->getKind()) {
1690   default: return false;
1691   case BuiltinType::Char_U:
1692   case BuiltinType::UChar:
1693   case BuiltinType::WChar_U:
1694   case BuiltinType::Char16:
1695   case BuiltinType::Char32:
1696   case BuiltinType::Char_S:
1697   case BuiltinType::SChar:
1698   case BuiltinType::WChar_S:
1699     return true;
1700   }
1701 }
1702 
1703 /// isSignedIntegerType - Return true if this is an integer type that is
1704 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
1705 /// an enum decl which has a signed representation
isSignedIntegerType() const1706 bool Type::isSignedIntegerType() const {
1707   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1708     return BT->getKind() >= BuiltinType::Char_S &&
1709            BT->getKind() <= BuiltinType::Int128;
1710   }
1711 
1712   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
1713     // Incomplete enum types are not treated as integer types.
1714     // FIXME: In C++, enum types are never integer types.
1715     if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
1716       return ET->getDecl()->getIntegerType()->isSignedIntegerType();
1717   }
1718 
1719   return false;
1720 }
1721 
isSignedIntegerOrEnumerationType() const1722 bool Type::isSignedIntegerOrEnumerationType() const {
1723   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1724     return BT->getKind() >= BuiltinType::Char_S &&
1725            BT->getKind() <= BuiltinType::Int128;
1726   }
1727 
1728   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
1729     if (ET->getDecl()->isComplete())
1730       return ET->getDecl()->getIntegerType()->isSignedIntegerType();
1731   }
1732 
1733   return false;
1734 }
1735 
hasSignedIntegerRepresentation() const1736 bool Type::hasSignedIntegerRepresentation() const {
1737   if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
1738     return VT->getElementType()->isSignedIntegerOrEnumerationType();
1739   else
1740     return isSignedIntegerOrEnumerationType();
1741 }
1742 
1743 /// isUnsignedIntegerType - Return true if this is an integer type that is
1744 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum
1745 /// decl which has an unsigned representation
isUnsignedIntegerType() const1746 bool Type::isUnsignedIntegerType() const {
1747   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1748     return BT->getKind() >= BuiltinType::Bool &&
1749            BT->getKind() <= BuiltinType::UInt128;
1750   }
1751 
1752   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
1753     // Incomplete enum types are not treated as integer types.
1754     // FIXME: In C++, enum types are never integer types.
1755     if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
1756       return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
1757   }
1758 
1759   return false;
1760 }
1761 
isUnsignedIntegerOrEnumerationType() const1762 bool Type::isUnsignedIntegerOrEnumerationType() const {
1763   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1764     return BT->getKind() >= BuiltinType::Bool &&
1765     BT->getKind() <= BuiltinType::UInt128;
1766   }
1767 
1768   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
1769     if (ET->getDecl()->isComplete())
1770       return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
1771   }
1772 
1773   return false;
1774 }
1775 
hasUnsignedIntegerRepresentation() const1776 bool Type::hasUnsignedIntegerRepresentation() const {
1777   if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
1778     return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
1779   else
1780     return isUnsignedIntegerOrEnumerationType();
1781 }
1782 
isFloatingType() const1783 bool Type::isFloatingType() const {
1784   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1785     return BT->getKind() >= BuiltinType::Half &&
1786            BT->getKind() <= BuiltinType::Float128;
1787   if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType))
1788     return CT->getElementType()->isFloatingType();
1789   return false;
1790 }
1791 
hasFloatingRepresentation() const1792 bool Type::hasFloatingRepresentation() const {
1793   if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
1794     return VT->getElementType()->isFloatingType();
1795   else
1796     return isFloatingType();
1797 }
1798 
isRealFloatingType() const1799 bool Type::isRealFloatingType() const {
1800   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1801     return BT->isFloatingPoint();
1802   return false;
1803 }
1804 
isRealType() const1805 bool Type::isRealType() const {
1806   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1807     return BT->getKind() >= BuiltinType::Bool &&
1808            BT->getKind() <= BuiltinType::Float128;
1809   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
1810       return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
1811   return false;
1812 }
1813 
isArithmeticType() const1814 bool Type::isArithmeticType() const {
1815   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1816     return BT->getKind() >= BuiltinType::Bool &&
1817            BT->getKind() <= BuiltinType::Float128;
1818   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
1819     // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2).
1820     // If a body isn't seen by the time we get here, return false.
1821     //
1822     // C++0x: Enumerations are not arithmetic types. For now, just return
1823     // false for scoped enumerations since that will disable any
1824     // unwanted implicit conversions.
1825     return !ET->getDecl()->isScoped() && ET->getDecl()->isComplete();
1826   return isa<ComplexType>(CanonicalType);
1827 }
1828 
getScalarTypeKind() const1829 Type::ScalarTypeKind Type::getScalarTypeKind() const {
1830   assert(isScalarType());
1831 
1832   const Type *T = CanonicalType.getTypePtr();
1833   if (const BuiltinType *BT = dyn_cast<BuiltinType>(T)) {
1834     if (BT->getKind() == BuiltinType::Bool) return STK_Bool;
1835     if (BT->getKind() == BuiltinType::NullPtr) return STK_CPointer;
1836     if (BT->isInteger()) return STK_Integral;
1837     if (BT->isFloatingPoint()) return STK_Floating;
1838     llvm_unreachable("unknown scalar builtin type");
1839   } else if (isa<PointerType>(T)) {
1840     return STK_CPointer;
1841   } else if (isa<BlockPointerType>(T)) {
1842     return STK_BlockPointer;
1843   } else if (isa<ObjCObjectPointerType>(T)) {
1844     return STK_ObjCObjectPointer;
1845   } else if (isa<MemberPointerType>(T)) {
1846     return STK_MemberPointer;
1847   } else if (isa<EnumType>(T)) {
1848     assert(cast<EnumType>(T)->getDecl()->isComplete());
1849     return STK_Integral;
1850   } else if (const ComplexType *CT = dyn_cast<ComplexType>(T)) {
1851     if (CT->getElementType()->isRealFloatingType())
1852       return STK_FloatingComplex;
1853     return STK_IntegralComplex;
1854   }
1855 
1856   llvm_unreachable("unknown scalar type");
1857 }
1858 
1859 /// \brief Determines whether the type is a C++ aggregate type or C
1860 /// aggregate or union type.
1861 ///
1862 /// An aggregate type is an array or a class type (struct, union, or
1863 /// class) that has no user-declared constructors, no private or
1864 /// protected non-static data members, no base classes, and no virtual
1865 /// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type
1866 /// subsumes the notion of C aggregates (C99 6.2.5p21) because it also
1867 /// includes union types.
isAggregateType() const1868 bool Type::isAggregateType() const {
1869   if (const RecordType *Record = dyn_cast<RecordType>(CanonicalType)) {
1870     if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl()))
1871       return ClassDecl->isAggregate();
1872 
1873     return true;
1874   }
1875 
1876   return isa<ArrayType>(CanonicalType);
1877 }
1878 
1879 /// isConstantSizeType - Return true if this is not a variable sized type,
1880 /// according to the rules of C99 6.7.5p3.  It is not legal to call this on
1881 /// incomplete types or dependent types.
isConstantSizeType() const1882 bool Type::isConstantSizeType() const {
1883   assert(!isIncompleteType() && "This doesn't make sense for incomplete types");
1884   assert(!isDependentType() && "This doesn't make sense for dependent types");
1885   // The VAT must have a size, as it is known to be complete.
1886   return !isa<VariableArrayType>(CanonicalType);
1887 }
1888 
1889 /// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1)
1890 /// - a type that can describe objects, but which lacks information needed to
1891 /// determine its size.
isIncompleteType(NamedDecl ** Def) const1892 bool Type::isIncompleteType(NamedDecl **Def) const {
1893   if (Def)
1894     *Def = nullptr;
1895 
1896   switch (CanonicalType->getTypeClass()) {
1897   default: return false;
1898   case Builtin:
1899     // Void is the only incomplete builtin type.  Per C99 6.2.5p19, it can never
1900     // be completed.
1901     return isVoidType();
1902   case Enum: {
1903     EnumDecl *EnumD = cast<EnumType>(CanonicalType)->getDecl();
1904     if (Def)
1905       *Def = EnumD;
1906 
1907     // An enumeration with fixed underlying type is complete (C++0x 7.2p3).
1908     if (EnumD->isFixed())
1909       return false;
1910 
1911     return !EnumD->isCompleteDefinition();
1912   }
1913   case Record: {
1914     // A tagged type (struct/union/enum/class) is incomplete if the decl is a
1915     // forward declaration, but not a full definition (C99 6.2.5p22).
1916     RecordDecl *Rec = cast<RecordType>(CanonicalType)->getDecl();
1917     if (Def)
1918       *Def = Rec;
1919     return !Rec->isCompleteDefinition();
1920   }
1921   case ConstantArray:
1922     // An array is incomplete if its element type is incomplete
1923     // (C++ [dcl.array]p1).
1924     // We don't handle variable arrays (they're not allowed in C++) or
1925     // dependent-sized arrays (dependent types are never treated as incomplete).
1926     return cast<ArrayType>(CanonicalType)->getElementType()
1927              ->isIncompleteType(Def);
1928   case IncompleteArray:
1929     // An array of unknown size is an incomplete type (C99 6.2.5p22).
1930     return true;
1931   case MemberPointer: {
1932     // Member pointers in the MS ABI have special behavior in
1933     // RequireCompleteType: they attach a MSInheritanceAttr to the CXXRecordDecl
1934     // to indicate which inheritance model to use.
1935     auto *MPTy = cast<MemberPointerType>(CanonicalType);
1936     const Type *ClassTy = MPTy->getClass();
1937     // Member pointers with dependent class types don't get special treatment.
1938     if (ClassTy->isDependentType())
1939       return false;
1940     const CXXRecordDecl *RD = ClassTy->getAsCXXRecordDecl();
1941     ASTContext &Context = RD->getASTContext();
1942     // Member pointers not in the MS ABI don't get special treatment.
1943     if (!Context.getTargetInfo().getCXXABI().isMicrosoft())
1944       return false;
1945     // The inheritance attribute might only be present on the most recent
1946     // CXXRecordDecl, use that one.
1947     RD = RD->getMostRecentDecl();
1948     // Nothing interesting to do if the inheritance attribute is already set.
1949     if (RD->hasAttr<MSInheritanceAttr>())
1950       return false;
1951     return true;
1952   }
1953   case ObjCObject:
1954     return cast<ObjCObjectType>(CanonicalType)->getBaseType()
1955              ->isIncompleteType(Def);
1956   case ObjCInterface: {
1957     // ObjC interfaces are incomplete if they are @class, not @interface.
1958     ObjCInterfaceDecl *Interface
1959       = cast<ObjCInterfaceType>(CanonicalType)->getDecl();
1960     if (Def)
1961       *Def = Interface;
1962     return !Interface->hasDefinition();
1963   }
1964   }
1965 }
1966 
isPODType(const ASTContext & Context) const1967 bool QualType::isPODType(const ASTContext &Context) const {
1968   // C++11 has a more relaxed definition of POD.
1969   if (Context.getLangOpts().CPlusPlus11)
1970     return isCXX11PODType(Context);
1971 
1972   return isCXX98PODType(Context);
1973 }
1974 
isCXX98PODType(const ASTContext & Context) const1975 bool QualType::isCXX98PODType(const ASTContext &Context) const {
1976   // The compiler shouldn't query this for incomplete types, but the user might.
1977   // We return false for that case. Except for incomplete arrays of PODs, which
1978   // are PODs according to the standard.
1979   if (isNull())
1980     return 0;
1981 
1982   if ((*this)->isIncompleteArrayType())
1983     return Context.getBaseElementType(*this).isCXX98PODType(Context);
1984 
1985   if ((*this)->isIncompleteType())
1986     return false;
1987 
1988   if (Context.getLangOpts().ObjCAutoRefCount) {
1989     switch (getObjCLifetime()) {
1990     case Qualifiers::OCL_ExplicitNone:
1991       return true;
1992 
1993     case Qualifiers::OCL_Strong:
1994     case Qualifiers::OCL_Weak:
1995     case Qualifiers::OCL_Autoreleasing:
1996       return false;
1997 
1998     case Qualifiers::OCL_None:
1999       break;
2000     }
2001   }
2002 
2003   QualType CanonicalType = getTypePtr()->CanonicalType;
2004   switch (CanonicalType->getTypeClass()) {
2005     // Everything not explicitly mentioned is not POD.
2006   default: return false;
2007   case Type::VariableArray:
2008   case Type::ConstantArray:
2009     // IncompleteArray is handled above.
2010     return Context.getBaseElementType(*this).isCXX98PODType(Context);
2011 
2012   case Type::ObjCObjectPointer:
2013   case Type::BlockPointer:
2014   case Type::Builtin:
2015   case Type::Complex:
2016   case Type::Pointer:
2017   case Type::MemberPointer:
2018   case Type::Vector:
2019   case Type::ExtVector:
2020     return true;
2021 
2022   case Type::Enum:
2023     return true;
2024 
2025   case Type::Record:
2026     if (CXXRecordDecl *ClassDecl
2027           = dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl()))
2028       return ClassDecl->isPOD();
2029 
2030     // C struct/union is POD.
2031     return true;
2032   }
2033 }
2034 
isTrivialType(const ASTContext & Context) const2035 bool QualType::isTrivialType(const ASTContext &Context) const {
2036   // The compiler shouldn't query this for incomplete types, but the user might.
2037   // We return false for that case. Except for incomplete arrays of PODs, which
2038   // are PODs according to the standard.
2039   if (isNull())
2040     return 0;
2041 
2042   if ((*this)->isArrayType())
2043     return Context.getBaseElementType(*this).isTrivialType(Context);
2044 
2045   // Return false for incomplete types after skipping any incomplete array
2046   // types which are expressly allowed by the standard and thus our API.
2047   if ((*this)->isIncompleteType())
2048     return false;
2049 
2050   if (Context.getLangOpts().ObjCAutoRefCount) {
2051     switch (getObjCLifetime()) {
2052     case Qualifiers::OCL_ExplicitNone:
2053       return true;
2054 
2055     case Qualifiers::OCL_Strong:
2056     case Qualifiers::OCL_Weak:
2057     case Qualifiers::OCL_Autoreleasing:
2058       return false;
2059 
2060     case Qualifiers::OCL_None:
2061       if ((*this)->isObjCLifetimeType())
2062         return false;
2063       break;
2064     }
2065   }
2066 
2067   QualType CanonicalType = getTypePtr()->CanonicalType;
2068   if (CanonicalType->isDependentType())
2069     return false;
2070 
2071   // C++0x [basic.types]p9:
2072   //   Scalar types, trivial class types, arrays of such types, and
2073   //   cv-qualified versions of these types are collectively called trivial
2074   //   types.
2075 
2076   // As an extension, Clang treats vector types as Scalar types.
2077   if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
2078     return true;
2079   if (const RecordType *RT = CanonicalType->getAs<RecordType>()) {
2080     if (const CXXRecordDecl *ClassDecl =
2081         dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2082       // C++11 [class]p6:
2083       //   A trivial class is a class that has a default constructor,
2084       //   has no non-trivial default constructors, and is trivially
2085       //   copyable.
2086       return ClassDecl->hasDefaultConstructor() &&
2087              !ClassDecl->hasNonTrivialDefaultConstructor() &&
2088              ClassDecl->isTriviallyCopyable();
2089     }
2090 
2091     return true;
2092   }
2093 
2094   // No other types can match.
2095   return false;
2096 }
2097 
isTriviallyCopyableType(const ASTContext & Context) const2098 bool QualType::isTriviallyCopyableType(const ASTContext &Context) const {
2099   if ((*this)->isArrayType())
2100     return Context.getBaseElementType(*this).isTriviallyCopyableType(Context);
2101 
2102   if (Context.getLangOpts().ObjCAutoRefCount) {
2103     switch (getObjCLifetime()) {
2104     case Qualifiers::OCL_ExplicitNone:
2105       return true;
2106 
2107     case Qualifiers::OCL_Strong:
2108     case Qualifiers::OCL_Weak:
2109     case Qualifiers::OCL_Autoreleasing:
2110       return false;
2111 
2112     case Qualifiers::OCL_None:
2113       if ((*this)->isObjCLifetimeType())
2114         return false;
2115       break;
2116     }
2117   }
2118 
2119   // C++11 [basic.types]p9
2120   //   Scalar types, trivially copyable class types, arrays of such types, and
2121   //   non-volatile const-qualified versions of these types are collectively
2122   //   called trivially copyable types.
2123 
2124   QualType CanonicalType = getCanonicalType();
2125   if (CanonicalType->isDependentType())
2126     return false;
2127 
2128   if (CanonicalType.isVolatileQualified())
2129     return false;
2130 
2131   // Return false for incomplete types after skipping any incomplete array types
2132   // which are expressly allowed by the standard and thus our API.
2133   if (CanonicalType->isIncompleteType())
2134     return false;
2135 
2136   // As an extension, Clang treats vector types as Scalar types.
2137   if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
2138     return true;
2139 
2140   if (const RecordType *RT = CanonicalType->getAs<RecordType>()) {
2141     if (const CXXRecordDecl *ClassDecl =
2142           dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2143       if (!ClassDecl->isTriviallyCopyable()) return false;
2144     }
2145 
2146     return true;
2147   }
2148 
2149   // No other types can match.
2150   return false;
2151 }
2152 
2153 
2154 
isLiteralType(const ASTContext & Ctx) const2155 bool Type::isLiteralType(const ASTContext &Ctx) const {
2156   if (isDependentType())
2157     return false;
2158 
2159   // C++1y [basic.types]p10:
2160   //   A type is a literal type if it is:
2161   //   -- cv void; or
2162   if (Ctx.getLangOpts().CPlusPlus14 && isVoidType())
2163     return true;
2164 
2165   // C++11 [basic.types]p10:
2166   //   A type is a literal type if it is:
2167   //   [...]
2168   //   -- an array of literal type other than an array of runtime bound; or
2169   if (isVariableArrayType())
2170     return false;
2171   const Type *BaseTy = getBaseElementTypeUnsafe();
2172   assert(BaseTy && "NULL element type");
2173 
2174   // Return false for incomplete types after skipping any incomplete array
2175   // types; those are expressly allowed by the standard and thus our API.
2176   if (BaseTy->isIncompleteType())
2177     return false;
2178 
2179   // C++11 [basic.types]p10:
2180   //   A type is a literal type if it is:
2181   //    -- a scalar type; or
2182   // As an extension, Clang treats vector types and complex types as
2183   // literal types.
2184   if (BaseTy->isScalarType() || BaseTy->isVectorType() ||
2185       BaseTy->isAnyComplexType())
2186     return true;
2187   //    -- a reference type; or
2188   if (BaseTy->isReferenceType())
2189     return true;
2190   //    -- a class type that has all of the following properties:
2191   if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
2192     //    -- a trivial destructor,
2193     //    -- every constructor call and full-expression in the
2194     //       brace-or-equal-initializers for non-static data members (if any)
2195     //       is a constant expression,
2196     //    -- it is an aggregate type or has at least one constexpr
2197     //       constructor or constructor template that is not a copy or move
2198     //       constructor, and
2199     //    -- all non-static data members and base classes of literal types
2200     //
2201     // We resolve DR1361 by ignoring the second bullet.
2202     if (const CXXRecordDecl *ClassDecl =
2203         dyn_cast<CXXRecordDecl>(RT->getDecl()))
2204       return ClassDecl->isLiteral();
2205 
2206     return true;
2207   }
2208 
2209   // We treat _Atomic T as a literal type if T is a literal type.
2210   if (const AtomicType *AT = BaseTy->getAs<AtomicType>())
2211     return AT->getValueType()->isLiteralType(Ctx);
2212 
2213   // If this type hasn't been deduced yet, then conservatively assume that
2214   // it'll work out to be a literal type.
2215   if (isa<AutoType>(BaseTy->getCanonicalTypeInternal()))
2216     return true;
2217 
2218   return false;
2219 }
2220 
isStandardLayoutType() const2221 bool Type::isStandardLayoutType() const {
2222   if (isDependentType())
2223     return false;
2224 
2225   // C++0x [basic.types]p9:
2226   //   Scalar types, standard-layout class types, arrays of such types, and
2227   //   cv-qualified versions of these types are collectively called
2228   //   standard-layout types.
2229   const Type *BaseTy = getBaseElementTypeUnsafe();
2230   assert(BaseTy && "NULL element type");
2231 
2232   // Return false for incomplete types after skipping any incomplete array
2233   // types which are expressly allowed by the standard and thus our API.
2234   if (BaseTy->isIncompleteType())
2235     return false;
2236 
2237   // As an extension, Clang treats vector types as Scalar types.
2238   if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
2239   if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
2240     if (const CXXRecordDecl *ClassDecl =
2241         dyn_cast<CXXRecordDecl>(RT->getDecl()))
2242       if (!ClassDecl->isStandardLayout())
2243         return false;
2244 
2245     // Default to 'true' for non-C++ class types.
2246     // FIXME: This is a bit dubious, but plain C structs should trivially meet
2247     // all the requirements of standard layout classes.
2248     return true;
2249   }
2250 
2251   // No other types can match.
2252   return false;
2253 }
2254 
2255 // This is effectively the intersection of isTrivialType and
2256 // isStandardLayoutType. We implement it directly to avoid redundant
2257 // conversions from a type to a CXXRecordDecl.
isCXX11PODType(const ASTContext & Context) const2258 bool QualType::isCXX11PODType(const ASTContext &Context) const {
2259   const Type *ty = getTypePtr();
2260   if (ty->isDependentType())
2261     return false;
2262 
2263   if (Context.getLangOpts().ObjCAutoRefCount) {
2264     switch (getObjCLifetime()) {
2265     case Qualifiers::OCL_ExplicitNone:
2266       return true;
2267 
2268     case Qualifiers::OCL_Strong:
2269     case Qualifiers::OCL_Weak:
2270     case Qualifiers::OCL_Autoreleasing:
2271       return false;
2272 
2273     case Qualifiers::OCL_None:
2274       break;
2275     }
2276   }
2277 
2278   // C++11 [basic.types]p9:
2279   //   Scalar types, POD classes, arrays of such types, and cv-qualified
2280   //   versions of these types are collectively called trivial types.
2281   const Type *BaseTy = ty->getBaseElementTypeUnsafe();
2282   assert(BaseTy && "NULL element type");
2283 
2284   // Return false for incomplete types after skipping any incomplete array
2285   // types which are expressly allowed by the standard and thus our API.
2286   if (BaseTy->isIncompleteType())
2287     return false;
2288 
2289   // As an extension, Clang treats vector types as Scalar types.
2290   if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
2291   if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
2292     if (const CXXRecordDecl *ClassDecl =
2293         dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2294       // C++11 [class]p10:
2295       //   A POD struct is a non-union class that is both a trivial class [...]
2296       if (!ClassDecl->isTrivial()) return false;
2297 
2298       // C++11 [class]p10:
2299       //   A POD struct is a non-union class that is both a trivial class and
2300       //   a standard-layout class [...]
2301       if (!ClassDecl->isStandardLayout()) return false;
2302 
2303       // C++11 [class]p10:
2304       //   A POD struct is a non-union class that is both a trivial class and
2305       //   a standard-layout class, and has no non-static data members of type
2306       //   non-POD struct, non-POD union (or array of such types). [...]
2307       //
2308       // We don't directly query the recursive aspect as the requirements for
2309       // both standard-layout classes and trivial classes apply recursively
2310       // already.
2311     }
2312 
2313     return true;
2314   }
2315 
2316   // No other types can match.
2317   return false;
2318 }
2319 
isPromotableIntegerType() const2320 bool Type::isPromotableIntegerType() const {
2321   if (const BuiltinType *BT = getAs<BuiltinType>())
2322     switch (BT->getKind()) {
2323     case BuiltinType::Bool:
2324     case BuiltinType::Char_S:
2325     case BuiltinType::Char_U:
2326     case BuiltinType::SChar:
2327     case BuiltinType::UChar:
2328     case BuiltinType::Short:
2329     case BuiltinType::UShort:
2330     case BuiltinType::WChar_S:
2331     case BuiltinType::WChar_U:
2332     case BuiltinType::Char16:
2333     case BuiltinType::Char32:
2334       return true;
2335     default:
2336       return false;
2337     }
2338 
2339   // Enumerated types are promotable to their compatible integer types
2340   // (C99 6.3.1.1) a.k.a. its underlying type (C++ [conv.prom]p2).
2341   if (const EnumType *ET = getAs<EnumType>()){
2342     if (this->isDependentType() || ET->getDecl()->getPromotionType().isNull()
2343         || ET->getDecl()->isScoped())
2344       return false;
2345 
2346     return true;
2347   }
2348 
2349   return false;
2350 }
2351 
isSpecifierType() const2352 bool Type::isSpecifierType() const {
2353   // Note that this intentionally does not use the canonical type.
2354   switch (getTypeClass()) {
2355   case Builtin:
2356   case Record:
2357   case Enum:
2358   case Typedef:
2359   case Complex:
2360   case TypeOfExpr:
2361   case TypeOf:
2362   case TemplateTypeParm:
2363   case SubstTemplateTypeParm:
2364   case TemplateSpecialization:
2365   case Elaborated:
2366   case DependentName:
2367   case DependentTemplateSpecialization:
2368   case ObjCInterface:
2369   case ObjCObject:
2370   case ObjCObjectPointer: // FIXME: object pointers aren't really specifiers
2371     return true;
2372   default:
2373     return false;
2374   }
2375 }
2376 
2377 ElaboratedTypeKeyword
getKeywordForTypeSpec(unsigned TypeSpec)2378 TypeWithKeyword::getKeywordForTypeSpec(unsigned TypeSpec) {
2379   switch (TypeSpec) {
2380   default: return ETK_None;
2381   case TST_typename: return ETK_Typename;
2382   case TST_class: return ETK_Class;
2383   case TST_struct: return ETK_Struct;
2384   case TST_interface: return ETK_Interface;
2385   case TST_union: return ETK_Union;
2386   case TST_enum: return ETK_Enum;
2387   }
2388 }
2389 
2390 TagTypeKind
getTagTypeKindForTypeSpec(unsigned TypeSpec)2391 TypeWithKeyword::getTagTypeKindForTypeSpec(unsigned TypeSpec) {
2392   switch(TypeSpec) {
2393   case TST_class: return TTK_Class;
2394   case TST_struct: return TTK_Struct;
2395   case TST_interface: return TTK_Interface;
2396   case TST_union: return TTK_Union;
2397   case TST_enum: return TTK_Enum;
2398   }
2399 
2400   llvm_unreachable("Type specifier is not a tag type kind.");
2401 }
2402 
2403 ElaboratedTypeKeyword
getKeywordForTagTypeKind(TagTypeKind Kind)2404 TypeWithKeyword::getKeywordForTagTypeKind(TagTypeKind Kind) {
2405   switch (Kind) {
2406   case TTK_Class: return ETK_Class;
2407   case TTK_Struct: return ETK_Struct;
2408   case TTK_Interface: return ETK_Interface;
2409   case TTK_Union: return ETK_Union;
2410   case TTK_Enum: return ETK_Enum;
2411   }
2412   llvm_unreachable("Unknown tag type kind.");
2413 }
2414 
2415 TagTypeKind
getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)2416 TypeWithKeyword::getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword) {
2417   switch (Keyword) {
2418   case ETK_Class: return TTK_Class;
2419   case ETK_Struct: return TTK_Struct;
2420   case ETK_Interface: return TTK_Interface;
2421   case ETK_Union: return TTK_Union;
2422   case ETK_Enum: return TTK_Enum;
2423   case ETK_None: // Fall through.
2424   case ETK_Typename:
2425     llvm_unreachable("Elaborated type keyword is not a tag type kind.");
2426   }
2427   llvm_unreachable("Unknown elaborated type keyword.");
2428 }
2429 
2430 bool
KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword)2431 TypeWithKeyword::KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword) {
2432   switch (Keyword) {
2433   case ETK_None:
2434   case ETK_Typename:
2435     return false;
2436   case ETK_Class:
2437   case ETK_Struct:
2438   case ETK_Interface:
2439   case ETK_Union:
2440   case ETK_Enum:
2441     return true;
2442   }
2443   llvm_unreachable("Unknown elaborated type keyword.");
2444 }
2445 
getKeywordName(ElaboratedTypeKeyword Keyword)2446 StringRef TypeWithKeyword::getKeywordName(ElaboratedTypeKeyword Keyword) {
2447   switch (Keyword) {
2448   case ETK_None: return "";
2449   case ETK_Typename: return "typename";
2450   case ETK_Class:  return "class";
2451   case ETK_Struct: return "struct";
2452   case ETK_Interface: return "__interface";
2453   case ETK_Union:  return "union";
2454   case ETK_Enum:   return "enum";
2455   }
2456 
2457   llvm_unreachable("Unknown elaborated type keyword.");
2458 }
2459 
DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,NestedNameSpecifier * NNS,const IdentifierInfo * Name,ArrayRef<TemplateArgument> Args,QualType Canon)2460 DependentTemplateSpecializationType::DependentTemplateSpecializationType(
2461                          ElaboratedTypeKeyword Keyword,
2462                          NestedNameSpecifier *NNS, const IdentifierInfo *Name,
2463                          ArrayRef<TemplateArgument> Args,
2464                          QualType Canon)
2465   : TypeWithKeyword(Keyword, DependentTemplateSpecialization, Canon, true, true,
2466                     /*VariablyModified=*/false,
2467                     NNS && NNS->containsUnexpandedParameterPack()),
2468     NNS(NNS), Name(Name), NumArgs(Args.size()) {
2469   assert((!NNS || NNS->isDependent()) &&
2470          "DependentTemplateSpecializatonType requires dependent qualifier");
2471   TemplateArgument *ArgBuffer = getArgBuffer();
2472   for (const TemplateArgument &Arg : Args) {
2473     if (Arg.containsUnexpandedParameterPack())
2474       setContainsUnexpandedParameterPack();
2475 
2476     new (ArgBuffer++) TemplateArgument(Arg);
2477   }
2478 }
2479 
2480 void
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,ElaboratedTypeKeyword Keyword,NestedNameSpecifier * Qualifier,const IdentifierInfo * Name,ArrayRef<TemplateArgument> Args)2481 DependentTemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
2482                                              const ASTContext &Context,
2483                                              ElaboratedTypeKeyword Keyword,
2484                                              NestedNameSpecifier *Qualifier,
2485                                              const IdentifierInfo *Name,
2486                                              ArrayRef<TemplateArgument> Args) {
2487   ID.AddInteger(Keyword);
2488   ID.AddPointer(Qualifier);
2489   ID.AddPointer(Name);
2490   for (const TemplateArgument &Arg : Args)
2491     Arg.Profile(ID, Context);
2492 }
2493 
isElaboratedTypeSpecifier() const2494 bool Type::isElaboratedTypeSpecifier() const {
2495   ElaboratedTypeKeyword Keyword;
2496   if (const ElaboratedType *Elab = dyn_cast<ElaboratedType>(this))
2497     Keyword = Elab->getKeyword();
2498   else if (const DependentNameType *DepName = dyn_cast<DependentNameType>(this))
2499     Keyword = DepName->getKeyword();
2500   else if (const DependentTemplateSpecializationType *DepTST =
2501              dyn_cast<DependentTemplateSpecializationType>(this))
2502     Keyword = DepTST->getKeyword();
2503   else
2504     return false;
2505 
2506   return TypeWithKeyword::KeywordIsTagTypeKind(Keyword);
2507 }
2508 
getTypeClassName() const2509 const char *Type::getTypeClassName() const {
2510   switch (TypeBits.TC) {
2511 #define ABSTRACT_TYPE(Derived, Base)
2512 #define TYPE(Derived, Base) case Derived: return #Derived;
2513 #include "clang/AST/TypeNodes.def"
2514   }
2515 
2516   llvm_unreachable("Invalid type class.");
2517 }
2518 
getName(const PrintingPolicy & Policy) const2519 StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
2520   switch (getKind()) {
2521   case Void:
2522     return "void";
2523   case Bool:
2524     return Policy.Bool ? "bool" : "_Bool";
2525   case Char_S:
2526     return "char";
2527   case Char_U:
2528     return "char";
2529   case SChar:
2530     return "signed char";
2531   case Short:
2532     return "short";
2533   case Int:
2534     return "int";
2535   case Long:
2536     return "long";
2537   case LongLong:
2538     return "long long";
2539   case Int128:
2540     return "__int128";
2541   case UChar:
2542     return "unsigned char";
2543   case UShort:
2544     return "unsigned short";
2545   case UInt:
2546     return "unsigned int";
2547   case ULong:
2548     return "unsigned long";
2549   case ULongLong:
2550     return "unsigned long long";
2551   case UInt128:
2552     return "unsigned __int128";
2553   case Half:
2554     return Policy.Half ? "half" : "__fp16";
2555   case Float:
2556     return "float";
2557   case Double:
2558     return "double";
2559   case LongDouble:
2560     return "long double";
2561   case Float128:
2562     return "__float128";
2563   case WChar_S:
2564   case WChar_U:
2565     return Policy.MSWChar ? "__wchar_t" : "wchar_t";
2566   case Char16:
2567     return "char16_t";
2568   case Char32:
2569     return "char32_t";
2570   case NullPtr:
2571     return "nullptr_t";
2572   case Overload:
2573     return "<overloaded function type>";
2574   case BoundMember:
2575     return "<bound member function type>";
2576   case PseudoObject:
2577     return "<pseudo-object type>";
2578   case Dependent:
2579     return "<dependent type>";
2580   case UnknownAny:
2581     return "<unknown type>";
2582   case ARCUnbridgedCast:
2583     return "<ARC unbridged cast type>";
2584   case BuiltinFn:
2585     return "<builtin fn type>";
2586   case ObjCId:
2587     return "id";
2588   case ObjCClass:
2589     return "Class";
2590   case ObjCSel:
2591     return "SEL";
2592 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2593   case Id: \
2594     return "__" #Access " " #ImgType "_t";
2595 #include "clang/Basic/OpenCLImageTypes.def"
2596   case OCLSampler:
2597     return "sampler_t";
2598   case OCLEvent:
2599     return "event_t";
2600   case OCLClkEvent:
2601     return "clk_event_t";
2602   case OCLQueue:
2603     return "queue_t";
2604   case OCLNDRange:
2605     return "ndrange_t";
2606   case OCLReserveID:
2607     return "reserve_id_t";
2608   case OMPArraySection:
2609     return "<OpenMP array section type>";
2610   }
2611 
2612   llvm_unreachable("Invalid builtin type.");
2613 }
2614 
getNonLValueExprType(const ASTContext & Context) const2615 QualType QualType::getNonLValueExprType(const ASTContext &Context) const {
2616   if (const ReferenceType *RefType = getTypePtr()->getAs<ReferenceType>())
2617     return RefType->getPointeeType();
2618 
2619   // C++0x [basic.lval]:
2620   //   Class prvalues can have cv-qualified types; non-class prvalues always
2621   //   have cv-unqualified types.
2622   //
2623   // See also C99 6.3.2.1p2.
2624   if (!Context.getLangOpts().CPlusPlus ||
2625       (!getTypePtr()->isDependentType() && !getTypePtr()->isRecordType()))
2626     return getUnqualifiedType();
2627 
2628   return *this;
2629 }
2630 
getNameForCallConv(CallingConv CC)2631 StringRef FunctionType::getNameForCallConv(CallingConv CC) {
2632   switch (CC) {
2633   case CC_C: return "cdecl";
2634   case CC_X86StdCall: return "stdcall";
2635   case CC_X86FastCall: return "fastcall";
2636   case CC_X86ThisCall: return "thiscall";
2637   case CC_X86Pascal: return "pascal";
2638   case CC_X86VectorCall: return "vectorcall";
2639   case CC_X86_64Win64: return "ms_abi";
2640   case CC_X86_64SysV: return "sysv_abi";
2641   case CC_AAPCS: return "aapcs";
2642   case CC_AAPCS_VFP: return "aapcs-vfp";
2643   case CC_IntelOclBicc: return "intel_ocl_bicc";
2644   case CC_SpirFunction: return "spir_function";
2645   case CC_OpenCLKernel: return "opencl_kernel";
2646   case CC_Swift: return "swiftcall";
2647   case CC_PreserveMost: return "preserve_most";
2648   case CC_PreserveAll: return "preserve_all";
2649   }
2650 
2651   llvm_unreachable("Invalid calling convention.");
2652 }
2653 
FunctionProtoType(QualType result,ArrayRef<QualType> params,QualType canonical,const ExtProtoInfo & epi)2654 FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
2655                                      QualType canonical,
2656                                      const ExtProtoInfo &epi)
2657     : FunctionType(FunctionProto, result, canonical,
2658                    result->isDependentType(),
2659                    result->isInstantiationDependentType(),
2660                    result->isVariablyModifiedType(),
2661                    result->containsUnexpandedParameterPack(), epi.ExtInfo),
2662       NumParams(params.size()),
2663       NumExceptions(epi.ExceptionSpec.Exceptions.size()),
2664       ExceptionSpecType(epi.ExceptionSpec.Type),
2665       HasExtParameterInfos(epi.ExtParameterInfos != nullptr),
2666       Variadic(epi.Variadic), HasTrailingReturn(epi.HasTrailingReturn) {
2667   assert(NumParams == params.size() && "function has too many parameters");
2668 
2669   FunctionTypeBits.TypeQuals = epi.TypeQuals;
2670   FunctionTypeBits.RefQualifier = epi.RefQualifier;
2671 
2672   // Fill in the trailing argument array.
2673   QualType *argSlot = reinterpret_cast<QualType*>(this+1);
2674   for (unsigned i = 0; i != NumParams; ++i) {
2675     if (params[i]->isDependentType())
2676       setDependent();
2677     else if (params[i]->isInstantiationDependentType())
2678       setInstantiationDependent();
2679 
2680     if (params[i]->containsUnexpandedParameterPack())
2681       setContainsUnexpandedParameterPack();
2682 
2683     argSlot[i] = params[i];
2684   }
2685 
2686   if (getExceptionSpecType() == EST_Dynamic) {
2687     // Fill in the exception array.
2688     QualType *exnSlot = argSlot + NumParams;
2689     unsigned I = 0;
2690     for (QualType ExceptionType : epi.ExceptionSpec.Exceptions) {
2691       // Note that a dependent exception specification does *not* make
2692       // a type dependent; it's not even part of the C++ type system.
2693       if (ExceptionType->isInstantiationDependentType())
2694         setInstantiationDependent();
2695 
2696       if (ExceptionType->containsUnexpandedParameterPack())
2697         setContainsUnexpandedParameterPack();
2698 
2699       exnSlot[I++] = ExceptionType;
2700     }
2701   } else if (getExceptionSpecType() == EST_ComputedNoexcept) {
2702     // Store the noexcept expression and context.
2703     Expr **noexSlot = reinterpret_cast<Expr **>(argSlot + NumParams);
2704     *noexSlot = epi.ExceptionSpec.NoexceptExpr;
2705 
2706     if (epi.ExceptionSpec.NoexceptExpr) {
2707       if (epi.ExceptionSpec.NoexceptExpr->isValueDependent() ||
2708           epi.ExceptionSpec.NoexceptExpr->isInstantiationDependent())
2709         setInstantiationDependent();
2710 
2711       if (epi.ExceptionSpec.NoexceptExpr->containsUnexpandedParameterPack())
2712         setContainsUnexpandedParameterPack();
2713     }
2714   } else if (getExceptionSpecType() == EST_Uninstantiated) {
2715     // Store the function decl from which we will resolve our
2716     // exception specification.
2717     FunctionDecl **slot =
2718         reinterpret_cast<FunctionDecl **>(argSlot + NumParams);
2719     slot[0] = epi.ExceptionSpec.SourceDecl;
2720     slot[1] = epi.ExceptionSpec.SourceTemplate;
2721     // This exception specification doesn't make the type dependent, because
2722     // it's not instantiated as part of instantiating the type.
2723   } else if (getExceptionSpecType() == EST_Unevaluated) {
2724     // Store the function decl from which we will resolve our
2725     // exception specification.
2726     FunctionDecl **slot =
2727         reinterpret_cast<FunctionDecl **>(argSlot + NumParams);
2728     slot[0] = epi.ExceptionSpec.SourceDecl;
2729   }
2730 
2731   if (epi.ExtParameterInfos) {
2732     ExtParameterInfo *extParamInfos =
2733       const_cast<ExtParameterInfo *>(getExtParameterInfosBuffer());
2734     for (unsigned i = 0; i != NumParams; ++i)
2735       extParamInfos[i] = epi.ExtParameterInfos[i];
2736   }
2737 }
2738 
hasDependentExceptionSpec() const2739 bool FunctionProtoType::hasDependentExceptionSpec() const {
2740   if (Expr *NE = getNoexceptExpr())
2741     return NE->isValueDependent();
2742   for (QualType ET : exceptions())
2743     // A pack expansion with a non-dependent pattern is still dependent,
2744     // because we don't know whether the pattern is in the exception spec
2745     // or not (that depends on whether the pack has 0 expansions).
2746     if (ET->isDependentType() || ET->getAs<PackExpansionType>())
2747       return true;
2748   return false;
2749 }
2750 
2751 FunctionProtoType::NoexceptResult
getNoexceptSpec(const ASTContext & ctx) const2752 FunctionProtoType::getNoexceptSpec(const ASTContext &ctx) const {
2753   ExceptionSpecificationType est = getExceptionSpecType();
2754   if (est == EST_BasicNoexcept)
2755     return NR_Nothrow;
2756 
2757   if (est != EST_ComputedNoexcept)
2758     return NR_NoNoexcept;
2759 
2760   Expr *noexceptExpr = getNoexceptExpr();
2761   if (!noexceptExpr)
2762     return NR_BadNoexcept;
2763   if (noexceptExpr->isValueDependent())
2764     return NR_Dependent;
2765 
2766   llvm::APSInt value;
2767   bool isICE = noexceptExpr->isIntegerConstantExpr(value, ctx, nullptr,
2768                                                    /*evaluated*/false);
2769   (void)isICE;
2770   assert(isICE && "AST should not contain bad noexcept expressions.");
2771 
2772   return value.getBoolValue() ? NR_Nothrow : NR_Throw;
2773 }
2774 
isNothrow(const ASTContext & Ctx,bool ResultIfDependent) const2775 bool FunctionProtoType::isNothrow(const ASTContext &Ctx,
2776                                   bool ResultIfDependent) const {
2777   ExceptionSpecificationType EST = getExceptionSpecType();
2778   assert(EST != EST_Unevaluated && EST != EST_Uninstantiated);
2779   if (EST == EST_DynamicNone || EST == EST_BasicNoexcept)
2780     return true;
2781 
2782   if (EST == EST_Dynamic && ResultIfDependent) {
2783     // A dynamic exception specification is throwing unless every exception
2784     // type is an (unexpanded) pack expansion type.
2785     for (unsigned I = 0, N = NumExceptions; I != N; ++I)
2786       if (!getExceptionType(I)->getAs<PackExpansionType>())
2787         return false;
2788     return ResultIfDependent;
2789   }
2790 
2791   if (EST != EST_ComputedNoexcept)
2792     return false;
2793 
2794   NoexceptResult NR = getNoexceptSpec(Ctx);
2795   if (NR == NR_Dependent)
2796     return ResultIfDependent;
2797   return NR == NR_Nothrow;
2798 }
2799 
isTemplateVariadic() const2800 bool FunctionProtoType::isTemplateVariadic() const {
2801   for (unsigned ArgIdx = getNumParams(); ArgIdx; --ArgIdx)
2802     if (isa<PackExpansionType>(getParamType(ArgIdx - 1)))
2803       return true;
2804 
2805   return false;
2806 }
2807 
Profile(llvm::FoldingSetNodeID & ID,QualType Result,const QualType * ArgTys,unsigned NumParams,const ExtProtoInfo & epi,const ASTContext & Context)2808 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
2809                                 const QualType *ArgTys, unsigned NumParams,
2810                                 const ExtProtoInfo &epi,
2811                                 const ASTContext &Context) {
2812 
2813   // We have to be careful not to get ambiguous profile encodings.
2814   // Note that valid type pointers are never ambiguous with anything else.
2815   //
2816   // The encoding grammar begins:
2817   //      type type* bool int bool
2818   // If that final bool is true, then there is a section for the EH spec:
2819   //      bool type*
2820   // This is followed by an optional "consumed argument" section of the
2821   // same length as the first type sequence:
2822   //      bool*
2823   // Finally, we have the ext info and trailing return type flag:
2824   //      int bool
2825   //
2826   // There is no ambiguity between the consumed arguments and an empty EH
2827   // spec because of the leading 'bool' which unambiguously indicates
2828   // whether the following bool is the EH spec or part of the arguments.
2829 
2830   ID.AddPointer(Result.getAsOpaquePtr());
2831   for (unsigned i = 0; i != NumParams; ++i)
2832     ID.AddPointer(ArgTys[i].getAsOpaquePtr());
2833   // This method is relatively performance sensitive, so as a performance
2834   // shortcut, use one AddInteger call instead of four for the next four
2835   // fields.
2836   assert(!(unsigned(epi.Variadic) & ~1) &&
2837          !(unsigned(epi.TypeQuals) & ~255) &&
2838          !(unsigned(epi.RefQualifier) & ~3) &&
2839          !(unsigned(epi.ExceptionSpec.Type) & ~15) &&
2840          "Values larger than expected.");
2841   ID.AddInteger(unsigned(epi.Variadic) +
2842                 (epi.TypeQuals << 1) +
2843                 (epi.RefQualifier << 9) +
2844                 (epi.ExceptionSpec.Type << 11));
2845   if (epi.ExceptionSpec.Type == EST_Dynamic) {
2846     for (QualType Ex : epi.ExceptionSpec.Exceptions)
2847       ID.AddPointer(Ex.getAsOpaquePtr());
2848   } else if (epi.ExceptionSpec.Type == EST_ComputedNoexcept &&
2849              epi.ExceptionSpec.NoexceptExpr) {
2850     epi.ExceptionSpec.NoexceptExpr->Profile(ID, Context, false);
2851   } else if (epi.ExceptionSpec.Type == EST_Uninstantiated ||
2852              epi.ExceptionSpec.Type == EST_Unevaluated) {
2853     ID.AddPointer(epi.ExceptionSpec.SourceDecl->getCanonicalDecl());
2854   }
2855   if (epi.ExtParameterInfos) {
2856     for (unsigned i = 0; i != NumParams; ++i)
2857       ID.AddInteger(epi.ExtParameterInfos[i].getOpaqueValue());
2858   }
2859   epi.ExtInfo.Profile(ID);
2860   ID.AddBoolean(epi.HasTrailingReturn);
2861 }
2862 
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Ctx)2863 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID,
2864                                 const ASTContext &Ctx) {
2865   Profile(ID, getReturnType(), param_type_begin(), NumParams, getExtProtoInfo(),
2866           Ctx);
2867 }
2868 
desugar() const2869 QualType TypedefType::desugar() const {
2870   return getDecl()->getUnderlyingType();
2871 }
2872 
TypeOfExprType(Expr * E,QualType can)2873 TypeOfExprType::TypeOfExprType(Expr *E, QualType can)
2874   : Type(TypeOfExpr, can, E->isTypeDependent(),
2875          E->isInstantiationDependent(),
2876          E->getType()->isVariablyModifiedType(),
2877          E->containsUnexpandedParameterPack()),
2878     TOExpr(E) {
2879 }
2880 
isSugared() const2881 bool TypeOfExprType::isSugared() const {
2882   return !TOExpr->isTypeDependent();
2883 }
2884 
desugar() const2885 QualType TypeOfExprType::desugar() const {
2886   if (isSugared())
2887     return getUnderlyingExpr()->getType();
2888 
2889   return QualType(this, 0);
2890 }
2891 
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,Expr * E)2892 void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID,
2893                                       const ASTContext &Context, Expr *E) {
2894   E->Profile(ID, Context, true);
2895 }
2896 
DecltypeType(Expr * E,QualType underlyingType,QualType can)2897 DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can)
2898   // C++11 [temp.type]p2: "If an expression e involves a template parameter,
2899   // decltype(e) denotes a unique dependent type." Hence a decltype type is
2900   // type-dependent even if its expression is only instantiation-dependent.
2901   : Type(Decltype, can, E->isInstantiationDependent(),
2902          E->isInstantiationDependent(),
2903          E->getType()->isVariablyModifiedType(),
2904          E->containsUnexpandedParameterPack()),
2905     E(E),
2906   UnderlyingType(underlyingType) {
2907 }
2908 
isSugared() const2909 bool DecltypeType::isSugared() const { return !E->isInstantiationDependent(); }
2910 
desugar() const2911 QualType DecltypeType::desugar() const {
2912   if (isSugared())
2913     return getUnderlyingType();
2914 
2915   return QualType(this, 0);
2916 }
2917 
DependentDecltypeType(const ASTContext & Context,Expr * E)2918 DependentDecltypeType::DependentDecltypeType(const ASTContext &Context, Expr *E)
2919   : DecltypeType(E, Context.DependentTy), Context(Context) { }
2920 
Profile(llvm::FoldingSetNodeID & ID,const ASTContext & Context,Expr * E)2921 void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID,
2922                                     const ASTContext &Context, Expr *E) {
2923   E->Profile(ID, Context, true);
2924 }
2925 
UnaryTransformType(QualType BaseType,QualType UnderlyingType,UTTKind UKind,QualType CanonicalType)2926 UnaryTransformType::UnaryTransformType(QualType BaseType,
2927                                        QualType UnderlyingType,
2928                                        UTTKind UKind,
2929                                        QualType CanonicalType)
2930   : Type(UnaryTransform, CanonicalType, BaseType->isDependentType(),
2931          BaseType->isInstantiationDependentType(),
2932          BaseType->isVariablyModifiedType(),
2933          BaseType->containsUnexpandedParameterPack())
2934   , BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind)
2935 {}
2936 
DependentUnaryTransformType(const ASTContext & C,QualType BaseType,UTTKind UKind)2937 DependentUnaryTransformType::DependentUnaryTransformType(const ASTContext &C,
2938                                                          QualType BaseType,
2939                                                          UTTKind UKind)
2940    : UnaryTransformType(BaseType, C.DependentTy, UKind, QualType())
2941 {}
2942 
2943 
TagType(TypeClass TC,const TagDecl * D,QualType can)2944 TagType::TagType(TypeClass TC, const TagDecl *D, QualType can)
2945   : Type(TC, can, D->isDependentType(),
2946          /*InstantiationDependent=*/D->isDependentType(),
2947          /*VariablyModified=*/false,
2948          /*ContainsUnexpandedParameterPack=*/false),
2949     decl(const_cast<TagDecl*>(D)) {}
2950 
getInterestingTagDecl(TagDecl * decl)2951 static TagDecl *getInterestingTagDecl(TagDecl *decl) {
2952   for (auto I : decl->redecls()) {
2953     if (I->isCompleteDefinition() || I->isBeingDefined())
2954       return I;
2955   }
2956   // If there's no definition (not even in progress), return what we have.
2957   return decl;
2958 }
2959 
getDecl() const2960 TagDecl *TagType::getDecl() const {
2961   return getInterestingTagDecl(decl);
2962 }
2963 
isBeingDefined() const2964 bool TagType::isBeingDefined() const {
2965   return getDecl()->isBeingDefined();
2966 }
2967 
isQualifier() const2968 bool AttributedType::isQualifier() const {
2969   switch (getAttrKind()) {
2970   // These are type qualifiers in the traditional C sense: they annotate
2971   // something about a specific value/variable of a type.  (They aren't
2972   // always part of the canonical type, though.)
2973   case AttributedType::attr_address_space:
2974   case AttributedType::attr_objc_gc:
2975   case AttributedType::attr_objc_ownership:
2976   case AttributedType::attr_objc_inert_unsafe_unretained:
2977   case AttributedType::attr_nonnull:
2978   case AttributedType::attr_nullable:
2979   case AttributedType::attr_null_unspecified:
2980     return true;
2981 
2982   // These aren't qualifiers; they rewrite the modified type to be a
2983   // semantically different type.
2984   case AttributedType::attr_regparm:
2985   case AttributedType::attr_vector_size:
2986   case AttributedType::attr_neon_vector_type:
2987   case AttributedType::attr_neon_polyvector_type:
2988   case AttributedType::attr_pcs:
2989   case AttributedType::attr_pcs_vfp:
2990   case AttributedType::attr_noreturn:
2991   case AttributedType::attr_cdecl:
2992   case AttributedType::attr_fastcall:
2993   case AttributedType::attr_stdcall:
2994   case AttributedType::attr_thiscall:
2995   case AttributedType::attr_pascal:
2996   case AttributedType::attr_swiftcall:
2997   case AttributedType::attr_vectorcall:
2998   case AttributedType::attr_inteloclbicc:
2999   case AttributedType::attr_preserve_most:
3000   case AttributedType::attr_preserve_all:
3001   case AttributedType::attr_ms_abi:
3002   case AttributedType::attr_sysv_abi:
3003   case AttributedType::attr_ptr32:
3004   case AttributedType::attr_ptr64:
3005   case AttributedType::attr_sptr:
3006   case AttributedType::attr_uptr:
3007   case AttributedType::attr_objc_kindof:
3008     return false;
3009   }
3010   llvm_unreachable("bad attributed type kind");
3011 }
3012 
isMSTypeSpec() const3013 bool AttributedType::isMSTypeSpec() const {
3014   switch (getAttrKind()) {
3015   default:  return false;
3016   case attr_ptr32:
3017   case attr_ptr64:
3018   case attr_sptr:
3019   case attr_uptr:
3020     return true;
3021   }
3022   llvm_unreachable("invalid attr kind");
3023 }
3024 
isCallingConv() const3025 bool AttributedType::isCallingConv() const {
3026   switch (getAttrKind()) {
3027   case attr_ptr32:
3028   case attr_ptr64:
3029   case attr_sptr:
3030   case attr_uptr:
3031   case attr_address_space:
3032   case attr_regparm:
3033   case attr_vector_size:
3034   case attr_neon_vector_type:
3035   case attr_neon_polyvector_type:
3036   case attr_objc_gc:
3037   case attr_objc_ownership:
3038   case attr_objc_inert_unsafe_unretained:
3039   case attr_noreturn:
3040   case attr_nonnull:
3041   case attr_nullable:
3042   case attr_null_unspecified:
3043   case attr_objc_kindof:
3044     return false;
3045 
3046   case attr_pcs:
3047   case attr_pcs_vfp:
3048   case attr_cdecl:
3049   case attr_fastcall:
3050   case attr_stdcall:
3051   case attr_thiscall:
3052   case attr_swiftcall:
3053   case attr_vectorcall:
3054   case attr_pascal:
3055   case attr_ms_abi:
3056   case attr_sysv_abi:
3057   case attr_inteloclbicc:
3058   case attr_preserve_most:
3059   case attr_preserve_all:
3060     return true;
3061   }
3062   llvm_unreachable("invalid attr kind");
3063 }
3064 
getDecl() const3065 CXXRecordDecl *InjectedClassNameType::getDecl() const {
3066   return cast<CXXRecordDecl>(getInterestingTagDecl(Decl));
3067 }
3068 
getIdentifier() const3069 IdentifierInfo *TemplateTypeParmType::getIdentifier() const {
3070   return isCanonicalUnqualified() ? nullptr : getDecl()->getIdentifier();
3071 }
3072 
3073 SubstTemplateTypeParmPackType::
SubstTemplateTypeParmPackType(const TemplateTypeParmType * Param,QualType Canon,const TemplateArgument & ArgPack)3074 SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
3075                               QualType Canon,
3076                               const TemplateArgument &ArgPack)
3077   : Type(SubstTemplateTypeParmPack, Canon, true, true, false, true),
3078     Replaced(Param),
3079     Arguments(ArgPack.pack_begin()), NumArguments(ArgPack.pack_size())
3080 {
3081 }
3082 
getArgumentPack() const3083 TemplateArgument SubstTemplateTypeParmPackType::getArgumentPack() const {
3084   return TemplateArgument(llvm::makeArrayRef(Arguments, NumArguments));
3085 }
3086 
Profile(llvm::FoldingSetNodeID & ID)3087 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
3088   Profile(ID, getReplacedParameter(), getArgumentPack());
3089 }
3090 
Profile(llvm::FoldingSetNodeID & ID,const TemplateTypeParmType * Replaced,const TemplateArgument & ArgPack)3091 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
3092                                            const TemplateTypeParmType *Replaced,
3093                                             const TemplateArgument &ArgPack) {
3094   ID.AddPointer(Replaced);
3095   ID.AddInteger(ArgPack.pack_size());
3096   for (const auto &P : ArgPack.pack_elements())
3097     ID.AddPointer(P.getAsType().getAsOpaquePtr());
3098 }
3099 
3100 bool TemplateSpecializationType::
anyDependentTemplateArguments(const TemplateArgumentListInfo & Args,bool & InstantiationDependent)3101 anyDependentTemplateArguments(const TemplateArgumentListInfo &Args,
3102                               bool &InstantiationDependent) {
3103   return anyDependentTemplateArguments(Args.arguments(),
3104                                        InstantiationDependent);
3105 }
3106 
3107 bool TemplateSpecializationType::
anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,bool & InstantiationDependent)3108 anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
3109                               bool &InstantiationDependent) {
3110   for (const TemplateArgumentLoc &ArgLoc : Args) {
3111     if (ArgLoc.getArgument().isDependent()) {
3112       InstantiationDependent = true;
3113       return true;
3114     }
3115 
3116     if (ArgLoc.getArgument().isInstantiationDependent())
3117       InstantiationDependent = true;
3118   }
3119   return false;
3120 }
3121 
3122 TemplateSpecializationType::
TemplateSpecializationType(TemplateName T,ArrayRef<TemplateArgument> Args,QualType Canon,QualType AliasedType)3123 TemplateSpecializationType(TemplateName T,
3124                            ArrayRef<TemplateArgument> Args,
3125                            QualType Canon, QualType AliasedType)
3126   : Type(TemplateSpecialization,
3127          Canon.isNull()? QualType(this, 0) : Canon,
3128          Canon.isNull()? true : Canon->isDependentType(),
3129          Canon.isNull()? true : Canon->isInstantiationDependentType(),
3130          false,
3131          T.containsUnexpandedParameterPack()),
3132     Template(T), NumArgs(Args.size()), TypeAlias(!AliasedType.isNull()) {
3133   assert(!T.getAsDependentTemplateName() &&
3134          "Use DependentTemplateSpecializationType for dependent template-name");
3135   assert((T.getKind() == TemplateName::Template ||
3136           T.getKind() == TemplateName::SubstTemplateTemplateParm ||
3137           T.getKind() == TemplateName::SubstTemplateTemplateParmPack) &&
3138          "Unexpected template name for TemplateSpecializationType");
3139 
3140   TemplateArgument *TemplateArgs
3141     = reinterpret_cast<TemplateArgument *>(this + 1);
3142   for (const TemplateArgument &Arg : Args) {
3143     // Update instantiation-dependent and variably-modified bits.
3144     // If the canonical type exists and is non-dependent, the template
3145     // specialization type can be non-dependent even if one of the type
3146     // arguments is. Given:
3147     //   template<typename T> using U = int;
3148     // U<T> is always non-dependent, irrespective of the type T.
3149     // However, U<Ts> contains an unexpanded parameter pack, even though
3150     // its expansion (and thus its desugared type) doesn't.
3151     if (Arg.isInstantiationDependent())
3152       setInstantiationDependent();
3153     if (Arg.getKind() == TemplateArgument::Type &&
3154         Arg.getAsType()->isVariablyModifiedType())
3155       setVariablyModified();
3156     if (Arg.containsUnexpandedParameterPack())
3157       setContainsUnexpandedParameterPack();
3158     new (TemplateArgs++) TemplateArgument(Arg);
3159   }
3160 
3161   // Store the aliased type if this is a type alias template specialization.
3162   if (TypeAlias) {
3163     TemplateArgument *Begin = reinterpret_cast<TemplateArgument *>(this + 1);
3164     *reinterpret_cast<QualType*>(Begin + getNumArgs()) = AliasedType;
3165   }
3166 }
3167 
3168 void
Profile(llvm::FoldingSetNodeID & ID,TemplateName T,ArrayRef<TemplateArgument> Args,const ASTContext & Context)3169 TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
3170                                     TemplateName T,
3171                                     ArrayRef<TemplateArgument> Args,
3172                                     const ASTContext &Context) {
3173   T.Profile(ID);
3174   for (const TemplateArgument &Arg : Args)
3175     Arg.Profile(ID, Context);
3176 }
3177 
3178 QualType
apply(const ASTContext & Context,QualType QT) const3179 QualifierCollector::apply(const ASTContext &Context, QualType QT) const {
3180   if (!hasNonFastQualifiers())
3181     return QT.withFastQualifiers(getFastQualifiers());
3182 
3183   return Context.getQualifiedType(QT, *this);
3184 }
3185 
3186 QualType
apply(const ASTContext & Context,const Type * T) const3187 QualifierCollector::apply(const ASTContext &Context, const Type *T) const {
3188   if (!hasNonFastQualifiers())
3189     return QualType(T, getFastQualifiers());
3190 
3191   return Context.getQualifiedType(T, *this);
3192 }
3193 
Profile(llvm::FoldingSetNodeID & ID,QualType BaseType,ArrayRef<QualType> typeArgs,ArrayRef<ObjCProtocolDecl * > protocols,bool isKindOf)3194 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID,
3195                                  QualType BaseType,
3196                                  ArrayRef<QualType> typeArgs,
3197                                  ArrayRef<ObjCProtocolDecl *> protocols,
3198                                  bool isKindOf) {
3199   ID.AddPointer(BaseType.getAsOpaquePtr());
3200   ID.AddInteger(typeArgs.size());
3201   for (auto typeArg : typeArgs)
3202     ID.AddPointer(typeArg.getAsOpaquePtr());
3203   ID.AddInteger(protocols.size());
3204   for (auto proto : protocols)
3205     ID.AddPointer(proto);
3206   ID.AddBoolean(isKindOf);
3207 }
3208 
Profile(llvm::FoldingSetNodeID & ID)3209 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) {
3210   Profile(ID, getBaseType(), getTypeArgsAsWritten(),
3211           llvm::makeArrayRef(qual_begin(), getNumProtocols()),
3212           isKindOfTypeAsWritten());
3213 }
3214 
3215 namespace {
3216 
3217 /// \brief The cached properties of a type.
3218 class CachedProperties {
3219   Linkage L;
3220   bool local;
3221 
3222 public:
CachedProperties(Linkage L,bool local)3223   CachedProperties(Linkage L, bool local) : L(L), local(local) {}
3224 
getLinkage() const3225   Linkage getLinkage() const { return L; }
hasLocalOrUnnamedType() const3226   bool hasLocalOrUnnamedType() const { return local; }
3227 
merge(CachedProperties L,CachedProperties R)3228   friend CachedProperties merge(CachedProperties L, CachedProperties R) {
3229     Linkage MergedLinkage = minLinkage(L.L, R.L);
3230     return CachedProperties(MergedLinkage,
3231                          L.hasLocalOrUnnamedType() | R.hasLocalOrUnnamedType());
3232   }
3233 };
3234 }
3235 
3236 static CachedProperties computeCachedProperties(const Type *T);
3237 
3238 namespace clang {
3239 /// The type-property cache.  This is templated so as to be
3240 /// instantiated at an internal type to prevent unnecessary symbol
3241 /// leakage.
3242 template <class Private> class TypePropertyCache {
3243 public:
get(QualType T)3244   static CachedProperties get(QualType T) {
3245     return get(T.getTypePtr());
3246   }
3247 
get(const Type * T)3248   static CachedProperties get(const Type *T) {
3249     ensure(T);
3250     return CachedProperties(T->TypeBits.getLinkage(),
3251                             T->TypeBits.hasLocalOrUnnamedType());
3252   }
3253 
ensure(const Type * T)3254   static void ensure(const Type *T) {
3255     // If the cache is valid, we're okay.
3256     if (T->TypeBits.isCacheValid()) return;
3257 
3258     // If this type is non-canonical, ask its canonical type for the
3259     // relevant information.
3260     if (!T->isCanonicalUnqualified()) {
3261       const Type *CT = T->getCanonicalTypeInternal().getTypePtr();
3262       ensure(CT);
3263       T->TypeBits.CacheValid = true;
3264       T->TypeBits.CachedLinkage = CT->TypeBits.CachedLinkage;
3265       T->TypeBits.CachedLocalOrUnnamed = CT->TypeBits.CachedLocalOrUnnamed;
3266       return;
3267     }
3268 
3269     // Compute the cached properties and then set the cache.
3270     CachedProperties Result = computeCachedProperties(T);
3271     T->TypeBits.CacheValid = true;
3272     T->TypeBits.CachedLinkage = Result.getLinkage();
3273     T->TypeBits.CachedLocalOrUnnamed = Result.hasLocalOrUnnamedType();
3274   }
3275 };
3276 }
3277 
3278 // Instantiate the friend template at a private class.  In a
3279 // reasonable implementation, these symbols will be internal.
3280 // It is terrible that this is the best way to accomplish this.
3281 namespace { class Private {}; }
3282 typedef TypePropertyCache<Private> Cache;
3283 
computeCachedProperties(const Type * T)3284 static CachedProperties computeCachedProperties(const Type *T) {
3285   switch (T->getTypeClass()) {
3286 #define TYPE(Class,Base)
3287 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
3288 #include "clang/AST/TypeNodes.def"
3289     llvm_unreachable("didn't expect a non-canonical type here");
3290 
3291 #define TYPE(Class,Base)
3292 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
3293 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
3294 #include "clang/AST/TypeNodes.def"
3295     // Treat instantiation-dependent types as external.
3296     assert(T->isInstantiationDependentType());
3297     return CachedProperties(ExternalLinkage, false);
3298 
3299   case Type::Auto:
3300     // Give non-deduced 'auto' types external linkage. We should only see them
3301     // here in error recovery.
3302     return CachedProperties(ExternalLinkage, false);
3303 
3304   case Type::Builtin:
3305     // C++ [basic.link]p8:
3306     //   A type is said to have linkage if and only if:
3307     //     - it is a fundamental type (3.9.1); or
3308     return CachedProperties(ExternalLinkage, false);
3309 
3310   case Type::Record:
3311   case Type::Enum: {
3312     const TagDecl *Tag = cast<TagType>(T)->getDecl();
3313 
3314     // C++ [basic.link]p8:
3315     //     - it is a class or enumeration type that is named (or has a name
3316     //       for linkage purposes (7.1.3)) and the name has linkage; or
3317     //     -  it is a specialization of a class template (14); or
3318     Linkage L = Tag->getLinkageInternal();
3319     bool IsLocalOrUnnamed =
3320       Tag->getDeclContext()->isFunctionOrMethod() ||
3321       !Tag->hasNameForLinkage();
3322     return CachedProperties(L, IsLocalOrUnnamed);
3323   }
3324 
3325     // C++ [basic.link]p8:
3326     //   - it is a compound type (3.9.2) other than a class or enumeration,
3327     //     compounded exclusively from types that have linkage; or
3328   case Type::Complex:
3329     return Cache::get(cast<ComplexType>(T)->getElementType());
3330   case Type::Pointer:
3331     return Cache::get(cast<PointerType>(T)->getPointeeType());
3332   case Type::BlockPointer:
3333     return Cache::get(cast<BlockPointerType>(T)->getPointeeType());
3334   case Type::LValueReference:
3335   case Type::RValueReference:
3336     return Cache::get(cast<ReferenceType>(T)->getPointeeType());
3337   case Type::MemberPointer: {
3338     const MemberPointerType *MPT = cast<MemberPointerType>(T);
3339     return merge(Cache::get(MPT->getClass()),
3340                  Cache::get(MPT->getPointeeType()));
3341   }
3342   case Type::ConstantArray:
3343   case Type::IncompleteArray:
3344   case Type::VariableArray:
3345     return Cache::get(cast<ArrayType>(T)->getElementType());
3346   case Type::Vector:
3347   case Type::ExtVector:
3348     return Cache::get(cast<VectorType>(T)->getElementType());
3349   case Type::FunctionNoProto:
3350     return Cache::get(cast<FunctionType>(T)->getReturnType());
3351   case Type::FunctionProto: {
3352     const FunctionProtoType *FPT = cast<FunctionProtoType>(T);
3353     CachedProperties result = Cache::get(FPT->getReturnType());
3354     for (const auto &ai : FPT->param_types())
3355       result = merge(result, Cache::get(ai));
3356     return result;
3357   }
3358   case Type::ObjCInterface: {
3359     Linkage L = cast<ObjCInterfaceType>(T)->getDecl()->getLinkageInternal();
3360     return CachedProperties(L, false);
3361   }
3362   case Type::ObjCObject:
3363     return Cache::get(cast<ObjCObjectType>(T)->getBaseType());
3364   case Type::ObjCObjectPointer:
3365     return Cache::get(cast<ObjCObjectPointerType>(T)->getPointeeType());
3366   case Type::Atomic:
3367     return Cache::get(cast<AtomicType>(T)->getValueType());
3368   case Type::Pipe:
3369     return Cache::get(cast<PipeType>(T)->getElementType());
3370   }
3371 
3372   llvm_unreachable("unhandled type class");
3373 }
3374 
3375 /// \brief Determine the linkage of this type.
getLinkage() const3376 Linkage Type::getLinkage() const {
3377   Cache::ensure(this);
3378   return TypeBits.getLinkage();
3379 }
3380 
hasUnnamedOrLocalType() const3381 bool Type::hasUnnamedOrLocalType() const {
3382   Cache::ensure(this);
3383   return TypeBits.hasLocalOrUnnamedType();
3384 }
3385 
3386 static LinkageInfo computeLinkageInfo(QualType T);
3387 
computeLinkageInfo(const Type * T)3388 static LinkageInfo computeLinkageInfo(const Type *T) {
3389   switch (T->getTypeClass()) {
3390 #define TYPE(Class,Base)
3391 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
3392 #include "clang/AST/TypeNodes.def"
3393     llvm_unreachable("didn't expect a non-canonical type here");
3394 
3395 #define TYPE(Class,Base)
3396 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
3397 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
3398 #include "clang/AST/TypeNodes.def"
3399     // Treat instantiation-dependent types as external.
3400     assert(T->isInstantiationDependentType());
3401     return LinkageInfo::external();
3402 
3403   case Type::Builtin:
3404     return LinkageInfo::external();
3405 
3406   case Type::Auto:
3407     return LinkageInfo::external();
3408 
3409   case Type::Record:
3410   case Type::Enum:
3411     return cast<TagType>(T)->getDecl()->getLinkageAndVisibility();
3412 
3413   case Type::Complex:
3414     return computeLinkageInfo(cast<ComplexType>(T)->getElementType());
3415   case Type::Pointer:
3416     return computeLinkageInfo(cast<PointerType>(T)->getPointeeType());
3417   case Type::BlockPointer:
3418     return computeLinkageInfo(cast<BlockPointerType>(T)->getPointeeType());
3419   case Type::LValueReference:
3420   case Type::RValueReference:
3421     return computeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
3422   case Type::MemberPointer: {
3423     const MemberPointerType *MPT = cast<MemberPointerType>(T);
3424     LinkageInfo LV = computeLinkageInfo(MPT->getClass());
3425     LV.merge(computeLinkageInfo(MPT->getPointeeType()));
3426     return LV;
3427   }
3428   case Type::ConstantArray:
3429   case Type::IncompleteArray:
3430   case Type::VariableArray:
3431     return computeLinkageInfo(cast<ArrayType>(T)->getElementType());
3432   case Type::Vector:
3433   case Type::ExtVector:
3434     return computeLinkageInfo(cast<VectorType>(T)->getElementType());
3435   case Type::FunctionNoProto:
3436     return computeLinkageInfo(cast<FunctionType>(T)->getReturnType());
3437   case Type::FunctionProto: {
3438     const FunctionProtoType *FPT = cast<FunctionProtoType>(T);
3439     LinkageInfo LV = computeLinkageInfo(FPT->getReturnType());
3440     for (const auto &ai : FPT->param_types())
3441       LV.merge(computeLinkageInfo(ai));
3442     return LV;
3443   }
3444   case Type::ObjCInterface:
3445     return cast<ObjCInterfaceType>(T)->getDecl()->getLinkageAndVisibility();
3446   case Type::ObjCObject:
3447     return computeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType());
3448   case Type::ObjCObjectPointer:
3449     return computeLinkageInfo(cast<ObjCObjectPointerType>(T)->getPointeeType());
3450   case Type::Atomic:
3451     return computeLinkageInfo(cast<AtomicType>(T)->getValueType());
3452   case Type::Pipe:
3453     return computeLinkageInfo(cast<PipeType>(T)->getElementType());
3454   }
3455 
3456   llvm_unreachable("unhandled type class");
3457 }
3458 
computeLinkageInfo(QualType T)3459 static LinkageInfo computeLinkageInfo(QualType T) {
3460   return computeLinkageInfo(T.getTypePtr());
3461 }
3462 
isLinkageValid() const3463 bool Type::isLinkageValid() const {
3464   if (!TypeBits.isCacheValid())
3465     return true;
3466 
3467   return computeLinkageInfo(getCanonicalTypeInternal()).getLinkage() ==
3468     TypeBits.getLinkage();
3469 }
3470 
getLinkageAndVisibility() const3471 LinkageInfo Type::getLinkageAndVisibility() const {
3472   if (!isCanonicalUnqualified())
3473     return computeLinkageInfo(getCanonicalTypeInternal());
3474 
3475   LinkageInfo LV = computeLinkageInfo(this);
3476   assert(LV.getLinkage() == getLinkage());
3477   return LV;
3478 }
3479 
getNullability(const ASTContext & context) const3480 Optional<NullabilityKind> Type::getNullability(const ASTContext &context) const {
3481   QualType type(this, 0);
3482   do {
3483     // Check whether this is an attributed type with nullability
3484     // information.
3485     if (auto attributed = dyn_cast<AttributedType>(type.getTypePtr())) {
3486       if (auto nullability = attributed->getImmediateNullability())
3487         return nullability;
3488     }
3489 
3490     // Desugar the type. If desugaring does nothing, we're done.
3491     QualType desugared = type.getSingleStepDesugaredType(context);
3492     if (desugared.getTypePtr() == type.getTypePtr())
3493       return None;
3494 
3495     type = desugared;
3496   } while (true);
3497 }
3498 
canHaveNullability() const3499 bool Type::canHaveNullability() const {
3500   QualType type = getCanonicalTypeInternal();
3501 
3502   switch (type->getTypeClass()) {
3503   // We'll only see canonical types here.
3504 #define NON_CANONICAL_TYPE(Class, Parent)       \
3505   case Type::Class:                             \
3506     llvm_unreachable("non-canonical type");
3507 #define TYPE(Class, Parent)
3508 #include "clang/AST/TypeNodes.def"
3509 
3510   // Pointer types.
3511   case Type::Pointer:
3512   case Type::BlockPointer:
3513   case Type::MemberPointer:
3514   case Type::ObjCObjectPointer:
3515     return true;
3516 
3517   // Dependent types that could instantiate to pointer types.
3518   case Type::UnresolvedUsing:
3519   case Type::TypeOfExpr:
3520   case Type::TypeOf:
3521   case Type::Decltype:
3522   case Type::UnaryTransform:
3523   case Type::TemplateTypeParm:
3524   case Type::SubstTemplateTypeParmPack:
3525   case Type::DependentName:
3526   case Type::DependentTemplateSpecialization:
3527     return true;
3528 
3529   // Dependent template specializations can instantiate to pointer
3530   // types unless they're known to be specializations of a class
3531   // template.
3532   case Type::TemplateSpecialization:
3533     if (TemplateDecl *templateDecl
3534           = cast<TemplateSpecializationType>(type.getTypePtr())
3535               ->getTemplateName().getAsTemplateDecl()) {
3536       if (isa<ClassTemplateDecl>(templateDecl))
3537         return false;
3538     }
3539     return true;
3540 
3541   // auto is considered dependent when it isn't deduced.
3542   case Type::Auto:
3543     return !cast<AutoType>(type.getTypePtr())->isDeduced();
3544 
3545   case Type::Builtin:
3546     switch (cast<BuiltinType>(type.getTypePtr())->getKind()) {
3547       // Signed, unsigned, and floating-point types cannot have nullability.
3548 #define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
3549 #define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
3550 #define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
3551 #define BUILTIN_TYPE(Id, SingletonId)
3552 #include "clang/AST/BuiltinTypes.def"
3553       return false;
3554 
3555     // Dependent types that could instantiate to a pointer type.
3556     case BuiltinType::Dependent:
3557     case BuiltinType::Overload:
3558     case BuiltinType::BoundMember:
3559     case BuiltinType::PseudoObject:
3560     case BuiltinType::UnknownAny:
3561     case BuiltinType::ARCUnbridgedCast:
3562       return true;
3563 
3564     case BuiltinType::Void:
3565     case BuiltinType::ObjCId:
3566     case BuiltinType::ObjCClass:
3567     case BuiltinType::ObjCSel:
3568 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3569     case BuiltinType::Id:
3570 #include "clang/Basic/OpenCLImageTypes.def"
3571     case BuiltinType::OCLSampler:
3572     case BuiltinType::OCLEvent:
3573     case BuiltinType::OCLClkEvent:
3574     case BuiltinType::OCLQueue:
3575     case BuiltinType::OCLNDRange:
3576     case BuiltinType::OCLReserveID:
3577     case BuiltinType::BuiltinFn:
3578     case BuiltinType::NullPtr:
3579     case BuiltinType::OMPArraySection:
3580       return false;
3581     }
3582 
3583   // Non-pointer types.
3584   case Type::Complex:
3585   case Type::LValueReference:
3586   case Type::RValueReference:
3587   case Type::ConstantArray:
3588   case Type::IncompleteArray:
3589   case Type::VariableArray:
3590   case Type::DependentSizedArray:
3591   case Type::DependentSizedExtVector:
3592   case Type::Vector:
3593   case Type::ExtVector:
3594   case Type::FunctionProto:
3595   case Type::FunctionNoProto:
3596   case Type::Record:
3597   case Type::Enum:
3598   case Type::InjectedClassName:
3599   case Type::PackExpansion:
3600   case Type::ObjCObject:
3601   case Type::ObjCInterface:
3602   case Type::Atomic:
3603   case Type::Pipe:
3604     return false;
3605   }
3606   llvm_unreachable("bad type kind!");
3607 }
3608 
getImmediateNullability() const3609 llvm::Optional<NullabilityKind> AttributedType::getImmediateNullability() const {
3610   if (getAttrKind() == AttributedType::attr_nonnull)
3611     return NullabilityKind::NonNull;
3612   if (getAttrKind() == AttributedType::attr_nullable)
3613     return NullabilityKind::Nullable;
3614   if (getAttrKind() == AttributedType::attr_null_unspecified)
3615     return NullabilityKind::Unspecified;
3616   return None;
3617 }
3618 
stripOuterNullability(QualType & T)3619 Optional<NullabilityKind> AttributedType::stripOuterNullability(QualType &T) {
3620   if (auto attributed = dyn_cast<AttributedType>(T.getTypePtr())) {
3621     if (auto nullability = attributed->getImmediateNullability()) {
3622       T = attributed->getModifiedType();
3623       return nullability;
3624     }
3625   }
3626 
3627   return None;
3628 }
3629 
isBlockCompatibleObjCPointerType(ASTContext & ctx) const3630 bool Type::isBlockCompatibleObjCPointerType(ASTContext &ctx) const {
3631   const ObjCObjectPointerType *objcPtr = getAs<ObjCObjectPointerType>();
3632   if (!objcPtr)
3633     return false;
3634 
3635   if (objcPtr->isObjCIdType()) {
3636     // id is always okay.
3637     return true;
3638   }
3639 
3640   // Blocks are NSObjects.
3641   if (ObjCInterfaceDecl *iface = objcPtr->getInterfaceDecl()) {
3642     if (iface->getIdentifier() != ctx.getNSObjectName())
3643       return false;
3644 
3645     // Continue to check qualifiers, below.
3646   } else if (objcPtr->isObjCQualifiedIdType()) {
3647     // Continue to check qualifiers, below.
3648   } else {
3649     return false;
3650   }
3651 
3652   // Check protocol qualifiers.
3653   for (ObjCProtocolDecl *proto : objcPtr->quals()) {
3654     // Blocks conform to NSObject and NSCopying.
3655     if (proto->getIdentifier() != ctx.getNSObjectName() &&
3656         proto->getIdentifier() != ctx.getNSCopyingName())
3657       return false;
3658   }
3659 
3660   return true;
3661 }
3662 
getObjCARCImplicitLifetime() const3663 Qualifiers::ObjCLifetime Type::getObjCARCImplicitLifetime() const {
3664   if (isObjCARCImplicitlyUnretainedType())
3665     return Qualifiers::OCL_ExplicitNone;
3666   return Qualifiers::OCL_Strong;
3667 }
3668 
isObjCARCImplicitlyUnretainedType() const3669 bool Type::isObjCARCImplicitlyUnretainedType() const {
3670   assert(isObjCLifetimeType() &&
3671          "cannot query implicit lifetime for non-inferrable type");
3672 
3673   const Type *canon = getCanonicalTypeInternal().getTypePtr();
3674 
3675   // Walk down to the base type.  We don't care about qualifiers for this.
3676   while (const ArrayType *array = dyn_cast<ArrayType>(canon))
3677     canon = array->getElementType().getTypePtr();
3678 
3679   if (const ObjCObjectPointerType *opt
3680         = dyn_cast<ObjCObjectPointerType>(canon)) {
3681     // Class and Class<Protocol> don't require retention.
3682     if (opt->getObjectType()->isObjCClass())
3683       return true;
3684   }
3685 
3686   return false;
3687 }
3688 
isObjCNSObjectType() const3689 bool Type::isObjCNSObjectType() const {
3690   if (const TypedefType *typedefType = dyn_cast<TypedefType>(this))
3691     return typedefType->getDecl()->hasAttr<ObjCNSObjectAttr>();
3692   return false;
3693 }
isObjCIndependentClassType() const3694 bool Type::isObjCIndependentClassType() const {
3695   if (const TypedefType *typedefType = dyn_cast<TypedefType>(this))
3696     return typedefType->getDecl()->hasAttr<ObjCIndependentClassAttr>();
3697   return false;
3698 }
isObjCRetainableType() const3699 bool Type::isObjCRetainableType() const {
3700   return isObjCObjectPointerType() ||
3701          isBlockPointerType() ||
3702          isObjCNSObjectType();
3703 }
isObjCIndirectLifetimeType() const3704 bool Type::isObjCIndirectLifetimeType() const {
3705   if (isObjCLifetimeType())
3706     return true;
3707   if (const PointerType *OPT = getAs<PointerType>())
3708     return OPT->getPointeeType()->isObjCIndirectLifetimeType();
3709   if (const ReferenceType *Ref = getAs<ReferenceType>())
3710     return Ref->getPointeeType()->isObjCIndirectLifetimeType();
3711   if (const MemberPointerType *MemPtr = getAs<MemberPointerType>())
3712     return MemPtr->getPointeeType()->isObjCIndirectLifetimeType();
3713   return false;
3714 }
3715 
3716 /// Returns true if objects of this type have lifetime semantics under
3717 /// ARC.
isObjCLifetimeType() const3718 bool Type::isObjCLifetimeType() const {
3719   const Type *type = this;
3720   while (const ArrayType *array = type->getAsArrayTypeUnsafe())
3721     type = array->getElementType().getTypePtr();
3722   return type->isObjCRetainableType();
3723 }
3724 
3725 /// \brief Determine whether the given type T is a "bridgable" Objective-C type,
3726 /// which is either an Objective-C object pointer type or an
isObjCARCBridgableType() const3727 bool Type::isObjCARCBridgableType() const {
3728   return isObjCObjectPointerType() || isBlockPointerType();
3729 }
3730 
3731 /// \brief Determine whether the given type T is a "bridgeable" C type.
isCARCBridgableType() const3732 bool Type::isCARCBridgableType() const {
3733   const PointerType *Pointer = getAs<PointerType>();
3734   if (!Pointer)
3735     return false;
3736 
3737   QualType Pointee = Pointer->getPointeeType();
3738   return Pointee->isVoidType() || Pointee->isRecordType();
3739 }
3740 
hasSizedVLAType() const3741 bool Type::hasSizedVLAType() const {
3742   if (!isVariablyModifiedType()) return false;
3743 
3744   if (const PointerType *ptr = getAs<PointerType>())
3745     return ptr->getPointeeType()->hasSizedVLAType();
3746   if (const ReferenceType *ref = getAs<ReferenceType>())
3747     return ref->getPointeeType()->hasSizedVLAType();
3748   if (const ArrayType *arr = getAsArrayTypeUnsafe()) {
3749     if (isa<VariableArrayType>(arr) &&
3750         cast<VariableArrayType>(arr)->getSizeExpr())
3751       return true;
3752 
3753     return arr->getElementType()->hasSizedVLAType();
3754   }
3755 
3756   return false;
3757 }
3758 
isDestructedTypeImpl(QualType type)3759 QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) {
3760   switch (type.getObjCLifetime()) {
3761   case Qualifiers::OCL_None:
3762   case Qualifiers::OCL_ExplicitNone:
3763   case Qualifiers::OCL_Autoreleasing:
3764     break;
3765 
3766   case Qualifiers::OCL_Strong:
3767     return DK_objc_strong_lifetime;
3768   case Qualifiers::OCL_Weak:
3769     return DK_objc_weak_lifetime;
3770   }
3771 
3772   /// Currently, the only destruction kind we recognize is C++ objects
3773   /// with non-trivial destructors.
3774   const CXXRecordDecl *record =
3775     type->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
3776   if (record && record->hasDefinition() && !record->hasTrivialDestructor())
3777     return DK_cxx_destructor;
3778 
3779   return DK_none;
3780 }
3781 
getMostRecentCXXRecordDecl() const3782 CXXRecordDecl *MemberPointerType::getMostRecentCXXRecordDecl() const {
3783   return getClass()->getAsCXXRecordDecl()->getMostRecentDecl();
3784 }
3785