clang  3.8.0
Type.cpp
Go to the documentation of this file.
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"
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 
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 
48  const Type* ty = getTypePtr();
49  NamedDecl *ND = nullptr;
50  if (ty->isPointerType() || ty->isReferenceType())
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 
68  if (T.isConstQualified())
69  return true;
70 
71  if (const ArrayType *AT = Ctx.getAsArrayType(T))
72  return AT->getElementType().isConstant(Ctx);
73 
75 }
76 
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 
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 
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 
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 
148 DependentSizedExtVectorType::DependentSizedExtVectorType(const
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
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 
172 VectorType::VectorType(QualType vecType, unsigned nElements, QualType canonType,
173  VectorKind vecKind)
174  : VectorType(Vector, vecType, nElements, canonType, vecKind) {}
175 
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.
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.
214  return Context.getQualifiedType(split.Ty, split.Quals);
215 }
216 
217 QualType QualType::getSingleStepDesugaredTypeImpl(QualType type,
218  const ASTContext &Context) {
219  SplitQualType split = type.split();
221  return Context.getQualifiedType(desugar, split.Quals);
222 }
223 
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 
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 
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 
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.
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 
326 template <> const TypedefType *Type::getAs() const {
327  return getAsSugar<TypedefType>(this);
328 }
329 
330 template <> const TemplateSpecializationType *Type::getAs() const {
331  return getAsSugar<TemplateSpecializationType>(this);
332 }
333 
334 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.
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 }
358 bool Type::isClassType() const {
359  if (const RecordType *RT = getAs<RecordType>())
360  return RT->getDecl()->isClass();
361  return false;
362 }
363 bool Type::isStructureType() const {
364  if (const RecordType *RT = getAs<RecordType>())
365  return RT->getDecl()->isStruct();
366  return false;
367 }
369  if (const RecordType *RT = getAs<RecordType>())
370  return RT->getDecl()->hasAttr<ObjCBoxableAttr>();
371  return false;
372 }
373 bool Type::isInterfaceType() const {
374  if (const RecordType *RT = getAs<RecordType>())
375  return RT->getDecl()->isInterface();
376  return false;
377 }
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 }
386  if (const PointerType *PT = getAs<PointerType>())
387  return PT->getPointeeType()->isVoidType();
388  return false;
389 }
390 
391 bool Type::isUnionType() const {
392  if (const RecordType *RT = getAs<RecordType>())
393  return RT->getDecl()->isUnion();
394  return false;
395 }
396 
397 bool Type::isComplexType() const {
398  if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType))
399  return CT->getElementType()->isFloatingType();
400  return false;
401 }
402 
404  // Check for GCC complex integer extension.
405  return getAsComplexIntegerType();
406 }
407 
409  if (const ComplexType *Complex = getAs<ComplexType>())
410  if (Complex->getElementType()->isIntegerType())
411  return Complex;
412  return nullptr;
413 }
414 
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 
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 
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 
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 
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?
520  const Type *cur = this;
521  while (true) {
522  if (auto attributed = dyn_cast<AttributedType>(cur)) {
523  if (attributed->getAttrKind() ==
525  return true;
526  }
527 
528  // Single-step desugar until we run out of sugar.
530  if (next.getTypePtr() == cur) return false;
531  cur = next.getTypePtr();
532  }
533 }
534 
536  ArrayRef<QualType> typeArgs,
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())
565 
566  if (typeArg->containsUnexpandedParameterPack())
568  }
569 }
570 
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 
590  // We have type arguments written on this type.
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 
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 
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),
640  /*protocols=*/{ },
641  /*isKindOf=*/false);
642 }
643 
645  const ASTContext &ctx) const {
646  if (!isKindOfType() && qual_empty())
647  return this;
648 
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 
665  QualType recurse(QualType type) {
666  return simpleTransform(Ctx, type, std::move(TheFunc));
667  }
668 
669 public:
670  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 
682  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 
695  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 
706  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 
717  QualType VisitLValueReferenceType(const LValueReferenceType *T) {
718  QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
719  if (pointeeType.isNull())
720  return QualType();
721 
722  if (pointeeType.getAsOpaquePtr()
724  return QualType(T, 0);
725 
726  return Ctx.getLValueReferenceType(pointeeType, T->isSpelledAsLValue());
727  }
728 
729  QualType VisitRValueReferenceType(const RValueReferenceType *T) {
730  QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
731  if (pointeeType.isNull())
732  return QualType();
733 
734  if (pointeeType.getAsOpaquePtr()
736  return QualType(T, 0);
737 
738  return Ctx.getRValueReferenceType(pointeeType);
739  }
740 
741  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 
752  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(),
763  }
764 
765  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(),
776  T->getBracketsRange());
777  }
778 
779  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(),
789  }
790 
791  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 
803  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 
814  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 
825  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.
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) {
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 
874  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 
885  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 
904  QualType VisitDecayedType(const DecayedType *T) {
905  QualType originalType = recurse(T->getOriginalType());
906  if (originalType.isNull())
907  return QualType();
908 
909  if (originalType.getAsOpaquePtr()
911  return QualType(T, 0);
912 
913  return Ctx.getDecayedType(originalType);
914  }
915 
916  TRIVIAL_TYPE_CLASS(TypeOfExpr)
917  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 
945  QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
946  QualType replacementType = recurse(T->getReplacementType());
947  if (replacementType.isNull())
948  return QualType();
949 
950  if (replacementType.getAsOpaquePtr()
952  return QualType(T, 0);
953 
955  replacementType);
956  }
957 
958  // FIXME: Non-trivial to implement, but important for C++
959  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++
978  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 
1009  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 
1023  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>
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.
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) {
1088  // Substitute the bound.
1089  return ctx.getQualifiedType(typeParam->getUnderlyingType(),
1090  splitType.Quals);
1091 
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,
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,
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,
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,
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() &&
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 
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 
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 
1278  const DeclContext *dc) const {
1279  // Look through method scopes.
1280  if (auto method = dyn_cast<ObjCMethodDecl>(dc))
1281  dc = method->getDeclContext();
1282 
1283  // Find the class or category in which the type we're substituting
1284  // was declared.
1285  const ObjCInterfaceDecl *dcClassDecl = dyn_cast<ObjCInterfaceDecl>(dc);
1286  const ObjCCategoryDecl *dcCategoryDecl = nullptr;
1287  ObjCTypeParamList *dcTypeParams = nullptr;
1288  if (dcClassDecl) {
1289  // If the class does not have any type parameters, there's no
1290  // substitution to do.
1291  dcTypeParams = dcClassDecl->getTypeParamList();
1292  if (!dcTypeParams)
1293  return None;
1294  } else {
1295  // If we are in neither a class nor a category, there's no
1296  // substitution to perform.
1297  dcCategoryDecl = dyn_cast<ObjCCategoryDecl>(dc);
1298  if (!dcCategoryDecl)
1299  return None;
1300 
1301  // If the category does not have any type parameters, there's no
1302  // substitution to do.
1303  dcTypeParams = dcCategoryDecl->getTypeParamList();
1304  if (!dcTypeParams)
1305  return None;
1306 
1307  dcClassDecl = dcCategoryDecl->getClassInterface();
1308  if (!dcClassDecl)
1309  return None;
1310  }
1311  assert(dcTypeParams && "No substitutions to perform");
1312  assert(dcClassDecl && "No class context");
1313 
1314  // Find the underlying object type.
1315  const ObjCObjectType *objectType;
1316  if (const auto *objectPointerType = getAs<ObjCObjectPointerType>()) {
1317  objectType = objectPointerType->getObjectType();
1318  } else if (getAs<BlockPointerType>()) {
1319  ASTContext &ctx = dc->getParentASTContext();
1320  objectType = ctx.getObjCObjectType(ctx.ObjCBuiltinIdTy, { }, { })
1321  ->castAs<ObjCObjectType>();;
1322  } else {
1323  objectType = getAs<ObjCObjectType>();
1324  }
1325 
1326  /// Extract the class from the receiver object type.
1327  ObjCInterfaceDecl *curClassDecl = objectType ? objectType->getInterface()
1328  : nullptr;
1329  if (!curClassDecl) {
1330  // If we don't have a context type (e.g., this is "id" or some
1331  // variant thereof), substitute the bounds.
1332  return llvm::ArrayRef<QualType>();
1333  }
1334 
1335  // Follow the superclass chain until we've mapped the receiver type
1336  // to the same class as the context.
1337  while (curClassDecl != dcClassDecl) {
1338  // Map to the superclass type.
1339  QualType superType = objectType->getSuperClassType();
1340  if (superType.isNull()) {
1341  objectType = nullptr;
1342  break;
1343  }
1344 
1345  objectType = superType->castAs<ObjCObjectType>();
1346  curClassDecl = objectType->getInterface();
1347  }
1348 
1349  // If we don't have a receiver type, or the receiver type does not
1350  // have type arguments, substitute in the defaults.
1351  if (!objectType || objectType->isUnspecialized()) {
1352  return llvm::ArrayRef<QualType>();
1353  }
1354 
1355  // The receiver type has the type arguments we want.
1356  return objectType->getTypeArgs();
1357 }
1358 
1359 bool Type::acceptsObjCTypeParams() const {
1360  if (auto *IfaceT = getAsObjCInterfaceType()) {
1361  if (auto *ID = IfaceT->getInterface()) {
1362  if (ID->getTypeParamList())
1363  return true;
1364  }
1365  }
1366 
1367  return false;
1368 }
1369 
1371  // Retrieve the class declaration for this type. If there isn't one
1372  // (e.g., this is some variant of "id" or "Class"), then there is no
1373  // superclass type.
1374  ObjCInterfaceDecl *classDecl = getInterface();
1375  if (!classDecl) {
1376  CachedSuperClassType.setInt(true);
1377  return;
1378  }
1379 
1380  // Extract the superclass type.
1381  const ObjCObjectType *superClassObjTy = classDecl->getSuperClassType();
1382  if (!superClassObjTy) {
1383  CachedSuperClassType.setInt(true);
1384  return;
1385  }
1386 
1387  ObjCInterfaceDecl *superClassDecl = superClassObjTy->getInterface();
1388  if (!superClassDecl) {
1389  CachedSuperClassType.setInt(true);
1390  return;
1391  }
1392 
1393  // If the superclass doesn't have type parameters, then there is no
1394  // substitution to perform.
1395  QualType superClassType(superClassObjTy, 0);
1396  ObjCTypeParamList *superClassTypeParams = superClassDecl->getTypeParamList();
1397  if (!superClassTypeParams) {
1398  CachedSuperClassType.setPointerAndInt(
1399  superClassType->castAs<ObjCObjectType>(), true);
1400  return;
1401  }
1402 
1403  // If the superclass reference is unspecialized, return it.
1404  if (superClassObjTy->isUnspecialized()) {
1405  CachedSuperClassType.setPointerAndInt(superClassObjTy, true);
1406  return;
1407  }
1408 
1409  // If the subclass is not parameterized, there aren't any type
1410  // parameters in the superclass reference to substitute.
1411  ObjCTypeParamList *typeParams = classDecl->getTypeParamList();
1412  if (!typeParams) {
1413  CachedSuperClassType.setPointerAndInt(
1414  superClassType->castAs<ObjCObjectType>(), true);
1415  return;
1416  }
1417 
1418  // If the subclass type isn't specialized, return the unspecialized
1419  // superclass.
1420  if (isUnspecialized()) {
1421  QualType unspecializedSuper
1422  = classDecl->getASTContext().getObjCInterfaceType(
1423  superClassObjTy->getInterface());
1424  CachedSuperClassType.setPointerAndInt(
1425  unspecializedSuper->castAs<ObjCObjectType>(),
1426  true);
1427  return;
1428  }
1429 
1430  // Substitute the provided type arguments into the superclass type.
1431  ArrayRef<QualType> typeArgs = getTypeArgs();
1432  assert(typeArgs.size() == typeParams->size());
1433  CachedSuperClassType.setPointerAndInt(
1434  superClassType.substObjCTypeArgs(classDecl->getASTContext(), typeArgs,
1436  ->castAs<ObjCObjectType>(),
1437  true);
1438 }
1439 
1441  if (auto interfaceDecl = getObjectType()->getInterface()) {
1442  return interfaceDecl->getASTContext().getObjCInterfaceType(interfaceDecl)
1444  }
1445 
1446  return nullptr;
1447 }
1448 
1450  QualType superObjectType = getObjectType()->getSuperClassType();
1451  if (superObjectType.isNull())
1452  return superObjectType;
1453 
1455  return ctx.getObjCObjectPointerType(superObjectType);
1456 }
1457 
1459  // There is no sugar for ObjCObjectType's, just return the canonical
1460  // type pointer if it is the right class. There is no typedef information to
1461  // return and these cannot be Address-space qualified.
1462  if (const ObjCObjectType *T = getAs<ObjCObjectType>())
1463  if (T->getNumProtocols() && T->getInterface())
1464  return T;
1465  return nullptr;
1466 }
1467 
1469  return getAsObjCQualifiedInterfaceType() != nullptr;
1470 }
1471 
1473  // There is no sugar for ObjCQualifiedIdType's, just return the canonical
1474  // type pointer if it is the right class.
1475  if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) {
1476  if (OPT->isObjCQualifiedIdType())
1477  return OPT;
1478  }
1479  return nullptr;
1480 }
1481 
1483  // There is no sugar for ObjCQualifiedClassType's, just return the canonical
1484  // type pointer if it is the right class.
1485  if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) {
1486  if (OPT->isObjCQualifiedClassType())
1487  return OPT;
1488  }
1489  return nullptr;
1490 }
1491 
1493  if (const ObjCObjectType *OT = getAs<ObjCObjectType>()) {
1494  if (OT->getInterface())
1495  return OT;
1496  }
1497  return nullptr;
1498 }
1500  if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) {
1501  if (OPT->getInterfaceType())
1502  return OPT;
1503  }
1504  return nullptr;
1505 }
1506 
1508  QualType PointeeType;
1509  if (const PointerType *PT = getAs<PointerType>())
1510  PointeeType = PT->getPointeeType();
1511  else if (const ReferenceType *RT = getAs<ReferenceType>())
1512  PointeeType = RT->getPointeeType();
1513  else
1514  return nullptr;
1515 
1516  if (const RecordType *RT = PointeeType->getAs<RecordType>())
1517  return dyn_cast<CXXRecordDecl>(RT->getDecl());
1518 
1519  return nullptr;
1520 }
1521 
1523  return dyn_cast_or_null<CXXRecordDecl>(getAsTagDecl());
1524 }
1525 
1527  if (const auto *TT = getAs<TagType>())
1528  return cast<TagDecl>(TT->getDecl());
1529  if (const auto *Injected = getAs<InjectedClassNameType>())
1530  return Injected->getDecl();
1531 
1532  return nullptr;
1533 }
1534 
1535 namespace {
1536  class GetContainedAutoVisitor :
1537  public TypeVisitor<GetContainedAutoVisitor, AutoType*> {
1538  public:
1540  AutoType *Visit(QualType T) {
1541  if (T.isNull())
1542  return nullptr;
1543  return Visit(T.getTypePtr());
1544  }
1545 
1546  // The 'auto' type itself.
1547  AutoType *VisitAutoType(const AutoType *AT) {
1548  return const_cast<AutoType*>(AT);
1549  }
1550 
1551  // Only these types can contain the desired 'auto' type.
1552  AutoType *VisitPointerType(const PointerType *T) {
1553  return Visit(T->getPointeeType());
1554  }
1555  AutoType *VisitBlockPointerType(const BlockPointerType *T) {
1556  return Visit(T->getPointeeType());
1557  }
1558  AutoType *VisitReferenceType(const ReferenceType *T) {
1559  return Visit(T->getPointeeTypeAsWritten());
1560  }
1561  AutoType *VisitMemberPointerType(const MemberPointerType *T) {
1562  return Visit(T->getPointeeType());
1563  }
1564  AutoType *VisitArrayType(const ArrayType *T) {
1565  return Visit(T->getElementType());
1566  }
1567  AutoType *VisitDependentSizedExtVectorType(
1568  const DependentSizedExtVectorType *T) {
1569  return Visit(T->getElementType());
1570  }
1571  AutoType *VisitVectorType(const VectorType *T) {
1572  return Visit(T->getElementType());
1573  }
1574  AutoType *VisitFunctionType(const FunctionType *T) {
1575  return Visit(T->getReturnType());
1576  }
1577  AutoType *VisitParenType(const ParenType *T) {
1578  return Visit(T->getInnerType());
1579  }
1580  AutoType *VisitAttributedType(const AttributedType *T) {
1581  return Visit(T->getModifiedType());
1582  }
1583  AutoType *VisitAdjustedType(const AdjustedType *T) {
1584  return Visit(T->getOriginalType());
1585  }
1586  };
1587 }
1588 
1590  return GetContainedAutoVisitor().Visit(this);
1591 }
1592 
1594  if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
1595  return VT->getElementType()->isIntegerType();
1596  else
1597  return isIntegerType();
1598 }
1599 
1600 /// \brief Determine whether this type is an integral type.
1601 ///
1602 /// This routine determines whether the given type is an integral type per
1603 /// C++ [basic.fundamental]p7. Although the C standard does not define the
1604 /// term "integral type", it has a similar term "integer type", and in C++
1605 /// the two terms are equivalent. However, C's "integer type" includes
1606 /// enumeration types, while C++'s "integer type" does not. The \c ASTContext
1607 /// parameter is used to determine whether we should be following the C or
1608 /// C++ rules when determining whether this type is an integral/integer type.
1609 ///
1610 /// For cases where C permits "an integer type" and C++ permits "an integral
1611 /// type", use this routine.
1612 ///
1613 /// For cases where C permits "an integer type" and C++ permits "an integral
1614 /// or enumeration type", use \c isIntegralOrEnumerationType() instead.
1615 ///
1616 /// \param Ctx The context in which this type occurs.
1617 ///
1618 /// \returns true if the type is considered an integral type, false otherwise.
1620  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1621  return BT->getKind() >= BuiltinType::Bool &&
1622  BT->getKind() <= BuiltinType::Int128;
1623 
1624  // Complete enum types are integral in C.
1625  if (!Ctx.getLangOpts().CPlusPlus)
1626  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
1627  return ET->getDecl()->isComplete();
1628 
1629  return false;
1630 }
1631 
1632 
1634  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1635  return BT->getKind() >= BuiltinType::Bool &&
1636  BT->getKind() <= BuiltinType::Int128;
1637 
1638  // Check for a complete enum type; incomplete enum types are not properly an
1639  // enumeration type in the sense required here.
1640  // C++0x: However, if the underlying type of the enum is fixed, it is
1641  // considered complete.
1642  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
1643  return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
1644 
1645  return false;
1646 }
1647 
1648 
1649 
1650 bool Type::isCharType() const {
1651  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1652  return BT->getKind() == BuiltinType::Char_U ||
1653  BT->getKind() == BuiltinType::UChar ||
1654  BT->getKind() == BuiltinType::Char_S ||
1655  BT->getKind() == BuiltinType::SChar;
1656  return false;
1657 }
1658 
1659 bool Type::isWideCharType() const {
1660  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1661  return BT->getKind() == BuiltinType::WChar_S ||
1662  BT->getKind() == BuiltinType::WChar_U;
1663  return false;
1664 }
1665 
1666 bool Type::isChar16Type() const {
1667  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1668  return BT->getKind() == BuiltinType::Char16;
1669  return false;
1670 }
1671 
1672 bool Type::isChar32Type() const {
1673  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1674  return BT->getKind() == BuiltinType::Char32;
1675  return false;
1676 }
1677 
1678 /// \brief Determine whether this type is any of the built-in character
1679 /// types.
1681  const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType);
1682  if (!BT) return false;
1683  switch (BT->getKind()) {
1684  default: return false;
1685  case BuiltinType::Char_U:
1686  case BuiltinType::UChar:
1687  case BuiltinType::WChar_U:
1688  case BuiltinType::Char16:
1689  case BuiltinType::Char32:
1690  case BuiltinType::Char_S:
1691  case BuiltinType::SChar:
1692  case BuiltinType::WChar_S:
1693  return true;
1694  }
1695 }
1696 
1697 /// isSignedIntegerType - Return true if this is an integer type that is
1698 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
1699 /// an enum decl which has a signed representation
1701  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1702  return BT->getKind() >= BuiltinType::Char_S &&
1703  BT->getKind() <= BuiltinType::Int128;
1704  }
1705 
1706  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
1707  // Incomplete enum types are not treated as integer types.
1708  // FIXME: In C++, enum types are never integer types.
1709  if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
1710  return ET->getDecl()->getIntegerType()->isSignedIntegerType();
1711  }
1712 
1713  return false;
1714 }
1715 
1717  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1718  return BT->getKind() >= BuiltinType::Char_S &&
1719  BT->getKind() <= BuiltinType::Int128;
1720  }
1721 
1722  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
1723  if (ET->getDecl()->isComplete())
1724  return ET->getDecl()->getIntegerType()->isSignedIntegerType();
1725  }
1726 
1727  return false;
1728 }
1729 
1731  if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
1732  return VT->getElementType()->isSignedIntegerOrEnumerationType();
1733  else
1735 }
1736 
1737 /// isUnsignedIntegerType - Return true if this is an integer type that is
1738 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum
1739 /// decl which has an unsigned representation
1741  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1742  return BT->getKind() >= BuiltinType::Bool &&
1743  BT->getKind() <= BuiltinType::UInt128;
1744  }
1745 
1746  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
1747  // Incomplete enum types are not treated as integer types.
1748  // FIXME: In C++, enum types are never integer types.
1749  if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
1750  return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
1751  }
1752 
1753  return false;
1754 }
1755 
1757  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1758  return BT->getKind() >= BuiltinType::Bool &&
1759  BT->getKind() <= BuiltinType::UInt128;
1760  }
1761 
1762  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
1763  if (ET->getDecl()->isComplete())
1764  return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
1765  }
1766 
1767  return false;
1768 }
1769 
1771  if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
1772  return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
1773  else
1775 }
1776 
1777 bool Type::isFloatingType() const {
1778  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1779  return BT->getKind() >= BuiltinType::Half &&
1780  BT->getKind() <= BuiltinType::LongDouble;
1781  if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType))
1782  return CT->getElementType()->isFloatingType();
1783  return false;
1784 }
1785 
1787  if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
1788  return VT->getElementType()->isFloatingType();
1789  else
1790  return isFloatingType();
1791 }
1792 
1794  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1795  return BT->isFloatingPoint();
1796  return false;
1797 }
1798 
1799 bool Type::isRealType() const {
1800  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1801  return BT->getKind() >= BuiltinType::Bool &&
1802  BT->getKind() <= BuiltinType::LongDouble;
1803  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
1804  return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
1805  return false;
1806 }
1807 
1809  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1810  return BT->getKind() >= BuiltinType::Bool &&
1811  BT->getKind() <= BuiltinType::LongDouble;
1812  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
1813  // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2).
1814  // If a body isn't seen by the time we get here, return false.
1815  //
1816  // C++0x: Enumerations are not arithmetic types. For now, just return
1817  // false for scoped enumerations since that will disable any
1818  // unwanted implicit conversions.
1819  return !ET->getDecl()->isScoped() && ET->getDecl()->isComplete();
1820  return isa<ComplexType>(CanonicalType);
1821 }
1822 
1824  assert(isScalarType());
1825 
1826  const Type *T = CanonicalType.getTypePtr();
1827  if (const BuiltinType *BT = dyn_cast<BuiltinType>(T)) {
1828  if (BT->getKind() == BuiltinType::Bool) return STK_Bool;
1829  if (BT->getKind() == BuiltinType::NullPtr) return STK_CPointer;
1830  if (BT->isInteger()) return STK_Integral;
1831  if (BT->isFloatingPoint()) return STK_Floating;
1832  llvm_unreachable("unknown scalar builtin type");
1833  } else if (isa<PointerType>(T)) {
1834  return STK_CPointer;
1835  } else if (isa<BlockPointerType>(T)) {
1836  return STK_BlockPointer;
1837  } else if (isa<ObjCObjectPointerType>(T)) {
1838  return STK_ObjCObjectPointer;
1839  } else if (isa<MemberPointerType>(T)) {
1840  return STK_MemberPointer;
1841  } else if (isa<EnumType>(T)) {
1842  assert(cast<EnumType>(T)->getDecl()->isComplete());
1843  return STK_Integral;
1844  } else if (const ComplexType *CT = dyn_cast<ComplexType>(T)) {
1845  if (CT->getElementType()->isRealFloatingType())
1846  return STK_FloatingComplex;
1847  return STK_IntegralComplex;
1848  }
1849 
1850  llvm_unreachable("unknown scalar type");
1851 }
1852 
1853 /// \brief Determines whether the type is a C++ aggregate type or C
1854 /// aggregate or union type.
1855 ///
1856 /// An aggregate type is an array or a class type (struct, union, or
1857 /// class) that has no user-declared constructors, no private or
1858 /// protected non-static data members, no base classes, and no virtual
1859 /// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type
1860 /// subsumes the notion of C aggregates (C99 6.2.5p21) because it also
1861 /// includes union types.
1863  if (const RecordType *Record = dyn_cast<RecordType>(CanonicalType)) {
1864  if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl()))
1865  return ClassDecl->isAggregate();
1866 
1867  return true;
1868  }
1869 
1870  return isa<ArrayType>(CanonicalType);
1871 }
1872 
1873 /// isConstantSizeType - Return true if this is not a variable sized type,
1874 /// according to the rules of C99 6.7.5p3. It is not legal to call this on
1875 /// incomplete types or dependent types.
1877  assert(!isIncompleteType() && "This doesn't make sense for incomplete types");
1878  assert(!isDependentType() && "This doesn't make sense for dependent types");
1879  // The VAT must have a size, as it is known to be complete.
1880  return !isa<VariableArrayType>(CanonicalType);
1881 }
1882 
1883 /// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1)
1884 /// - a type that can describe objects, but which lacks information needed to
1885 /// determine its size.
1887  if (Def)
1888  *Def = nullptr;
1889 
1890  switch (CanonicalType->getTypeClass()) {
1891  default: return false;
1892  case Builtin:
1893  // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never
1894  // be completed.
1895  return isVoidType();
1896  case Enum: {
1897  EnumDecl *EnumD = cast<EnumType>(CanonicalType)->getDecl();
1898  if (Def)
1899  *Def = EnumD;
1900 
1901  // An enumeration with fixed underlying type is complete (C++0x 7.2p3).
1902  if (EnumD->isFixed())
1903  return false;
1904 
1905  return !EnumD->isCompleteDefinition();
1906  }
1907  case Record: {
1908  // A tagged type (struct/union/enum/class) is incomplete if the decl is a
1909  // forward declaration, but not a full definition (C99 6.2.5p22).
1910  RecordDecl *Rec = cast<RecordType>(CanonicalType)->getDecl();
1911  if (Def)
1912  *Def = Rec;
1913  return !Rec->isCompleteDefinition();
1914  }
1915  case ConstantArray:
1916  // An array is incomplete if its element type is incomplete
1917  // (C++ [dcl.array]p1).
1918  // We don't handle variable arrays (they're not allowed in C++) or
1919  // dependent-sized arrays (dependent types are never treated as incomplete).
1920  return cast<ArrayType>(CanonicalType)->getElementType()
1921  ->isIncompleteType(Def);
1922  case IncompleteArray:
1923  // An array of unknown size is an incomplete type (C99 6.2.5p22).
1924  return true;
1925  case MemberPointer: {
1926  // Member pointers in the MS ABI have special behavior in
1927  // RequireCompleteType: they attach a MSInheritanceAttr to the CXXRecordDecl
1928  // to indicate which inheritance model to use.
1929  auto *MPTy = cast<MemberPointerType>(CanonicalType);
1930  const Type *ClassTy = MPTy->getClass();
1931  // Member pointers with dependent class types don't get special treatment.
1932  if (ClassTy->isDependentType())
1933  return false;
1934  const CXXRecordDecl *RD = ClassTy->getAsCXXRecordDecl();
1935  ASTContext &Context = RD->getASTContext();
1936  // Member pointers not in the MS ABI don't get special treatment.
1937  if (!Context.getTargetInfo().getCXXABI().isMicrosoft())
1938  return false;
1939  // The inheritance attribute might only be present on the most recent
1940  // CXXRecordDecl, use that one.
1941  RD = RD->getMostRecentDecl();
1942  // Nothing interesting to do if the inheritance attribute is already set.
1943  if (RD->hasAttr<MSInheritanceAttr>())
1944  return false;
1945  return true;
1946  }
1947  case ObjCObject:
1948  return cast<ObjCObjectType>(CanonicalType)->getBaseType()
1949  ->isIncompleteType(Def);
1950  case ObjCInterface: {
1951  // ObjC interfaces are incomplete if they are @class, not @interface.
1952  ObjCInterfaceDecl *Interface
1953  = cast<ObjCInterfaceType>(CanonicalType)->getDecl();
1954  if (Def)
1955  *Def = Interface;
1956  return !Interface->hasDefinition();
1957  }
1958  }
1959 }
1960 
1961 bool QualType::isPODType(ASTContext &Context) const {
1962  // C++11 has a more relaxed definition of POD.
1963  if (Context.getLangOpts().CPlusPlus11)
1964  return isCXX11PODType(Context);
1965 
1966  return isCXX98PODType(Context);
1967 }
1968 
1969 bool QualType::isCXX98PODType(ASTContext &Context) const {
1970  // The compiler shouldn't query this for incomplete types, but the user might.
1971  // We return false for that case. Except for incomplete arrays of PODs, which
1972  // are PODs according to the standard.
1973  if (isNull())
1974  return 0;
1975 
1976  if ((*this)->isIncompleteArrayType())
1977  return Context.getBaseElementType(*this).isCXX98PODType(Context);
1978 
1979  if ((*this)->isIncompleteType())
1980  return false;
1981 
1982  if (Context.getLangOpts().ObjCAutoRefCount) {
1983  switch (getObjCLifetime()) {
1985  return true;
1986 
1988  case Qualifiers::OCL_Weak:
1990  return false;
1991 
1992  case Qualifiers::OCL_None:
1993  break;
1994  }
1995  }
1996 
1997  QualType CanonicalType = getTypePtr()->CanonicalType;
1998  switch (CanonicalType->getTypeClass()) {
1999  // Everything not explicitly mentioned is not POD.
2000  default: return false;
2001  case Type::VariableArray:
2002  case Type::ConstantArray:
2003  // IncompleteArray is handled above.
2004  return Context.getBaseElementType(*this).isCXX98PODType(Context);
2005 
2006  case Type::ObjCObjectPointer:
2007  case Type::BlockPointer:
2008  case Type::Builtin:
2009  case Type::Complex:
2010  case Type::Pointer:
2011  case Type::MemberPointer:
2012  case Type::Vector:
2013  case Type::ExtVector:
2014  return true;
2015 
2016  case Type::Enum:
2017  return true;
2018 
2019  case Type::Record:
2020  if (CXXRecordDecl *ClassDecl
2021  = dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl()))
2022  return ClassDecl->isPOD();
2023 
2024  // C struct/union is POD.
2025  return true;
2026  }
2027 }
2028 
2029 bool QualType::isTrivialType(ASTContext &Context) const {
2030  // The compiler shouldn't query this for incomplete types, but the user might.
2031  // We return false for that case. Except for incomplete arrays of PODs, which
2032  // are PODs according to the standard.
2033  if (isNull())
2034  return 0;
2035 
2036  if ((*this)->isArrayType())
2037  return Context.getBaseElementType(*this).isTrivialType(Context);
2038 
2039  // Return false for incomplete types after skipping any incomplete array
2040  // types which are expressly allowed by the standard and thus our API.
2041  if ((*this)->isIncompleteType())
2042  return false;
2043 
2044  if (Context.getLangOpts().ObjCAutoRefCount) {
2045  switch (getObjCLifetime()) {
2047  return true;
2048 
2050  case Qualifiers::OCL_Weak:
2052  return false;
2053 
2054  case Qualifiers::OCL_None:
2055  if ((*this)->isObjCLifetimeType())
2056  return false;
2057  break;
2058  }
2059  }
2060 
2061  QualType CanonicalType = getTypePtr()->CanonicalType;
2062  if (CanonicalType->isDependentType())
2063  return false;
2064 
2065  // C++0x [basic.types]p9:
2066  // Scalar types, trivial class types, arrays of such types, and
2067  // cv-qualified versions of these types are collectively called trivial
2068  // types.
2069 
2070  // As an extension, Clang treats vector types as Scalar types.
2071  if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
2072  return true;
2073  if (const RecordType *RT = CanonicalType->getAs<RecordType>()) {
2074  if (const CXXRecordDecl *ClassDecl =
2075  dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2076  // C++11 [class]p6:
2077  // A trivial class is a class that has a default constructor,
2078  // has no non-trivial default constructors, and is trivially
2079  // copyable.
2080  return ClassDecl->hasDefaultConstructor() &&
2081  !ClassDecl->hasNonTrivialDefaultConstructor() &&
2082  ClassDecl->isTriviallyCopyable();
2083  }
2084 
2085  return true;
2086  }
2087 
2088  // No other types can match.
2089  return false;
2090 }
2091 
2093  if ((*this)->isArrayType())
2094  return Context.getBaseElementType(*this).isTriviallyCopyableType(Context);
2095 
2096  if (Context.getLangOpts().ObjCAutoRefCount) {
2097  switch (getObjCLifetime()) {
2099  return true;
2100 
2102  case Qualifiers::OCL_Weak:
2104  return false;
2105 
2106  case Qualifiers::OCL_None:
2107  if ((*this)->isObjCLifetimeType())
2108  return false;
2109  break;
2110  }
2111  }
2112 
2113  // C++11 [basic.types]p9
2114  // Scalar types, trivially copyable class types, arrays of such types, and
2115  // non-volatile const-qualified versions of these types are collectively
2116  // called trivially copyable types.
2117 
2118  QualType CanonicalType = getCanonicalType();
2119  if (CanonicalType->isDependentType())
2120  return false;
2121 
2122  if (CanonicalType.isVolatileQualified())
2123  return false;
2124 
2125  // Return false for incomplete types after skipping any incomplete array types
2126  // which are expressly allowed by the standard and thus our API.
2127  if (CanonicalType->isIncompleteType())
2128  return false;
2129 
2130  // As an extension, Clang treats vector types as Scalar types.
2131  if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
2132  return true;
2133 
2134  if (const RecordType *RT = CanonicalType->getAs<RecordType>()) {
2135  if (const CXXRecordDecl *ClassDecl =
2136  dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2137  if (!ClassDecl->isTriviallyCopyable()) return false;
2138  }
2139 
2140  return true;
2141  }
2142 
2143  // No other types can match.
2144  return false;
2145 }
2146 
2147 
2148 
2149 bool Type::isLiteralType(const ASTContext &Ctx) const {
2150  if (isDependentType())
2151  return false;
2152 
2153  // C++1y [basic.types]p10:
2154  // A type is a literal type if it is:
2155  // -- cv void; or
2156  if (Ctx.getLangOpts().CPlusPlus14 && isVoidType())
2157  return true;
2158 
2159  // C++11 [basic.types]p10:
2160  // A type is a literal type if it is:
2161  // [...]
2162  // -- an array of literal type other than an array of runtime bound; or
2163  if (isVariableArrayType())
2164  return false;
2165  const Type *BaseTy = getBaseElementTypeUnsafe();
2166  assert(BaseTy && "NULL element type");
2167 
2168  // Return false for incomplete types after skipping any incomplete array
2169  // types; those are expressly allowed by the standard and thus our API.
2170  if (BaseTy->isIncompleteType())
2171  return false;
2172 
2173  // C++11 [basic.types]p10:
2174  // A type is a literal type if it is:
2175  // -- a scalar type; or
2176  // As an extension, Clang treats vector types and complex types as
2177  // literal types.
2178  if (BaseTy->isScalarType() || BaseTy->isVectorType() ||
2179  BaseTy->isAnyComplexType())
2180  return true;
2181  // -- a reference type; or
2182  if (BaseTy->isReferenceType())
2183  return true;
2184  // -- a class type that has all of the following properties:
2185  if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
2186  // -- a trivial destructor,
2187  // -- every constructor call and full-expression in the
2188  // brace-or-equal-initializers for non-static data members (if any)
2189  // is a constant expression,
2190  // -- it is an aggregate type or has at least one constexpr
2191  // constructor or constructor template that is not a copy or move
2192  // constructor, and
2193  // -- all non-static data members and base classes of literal types
2194  //
2195  // We resolve DR1361 by ignoring the second bullet.
2196  if (const CXXRecordDecl *ClassDecl =
2197  dyn_cast<CXXRecordDecl>(RT->getDecl()))
2198  return ClassDecl->isLiteral();
2199 
2200  return true;
2201  }
2202 
2203  // We treat _Atomic T as a literal type if T is a literal type.
2204  if (const AtomicType *AT = BaseTy->getAs<AtomicType>())
2205  return AT->getValueType()->isLiteralType(Ctx);
2206 
2207  // If this type hasn't been deduced yet, then conservatively assume that
2208  // it'll work out to be a literal type.
2209  if (isa<AutoType>(BaseTy->getCanonicalTypeInternal()))
2210  return true;
2211 
2212  return false;
2213 }
2214 
2216  if (isDependentType())
2217  return false;
2218 
2219  // C++0x [basic.types]p9:
2220  // Scalar types, standard-layout class types, arrays of such types, and
2221  // cv-qualified versions of these types are collectively called
2222  // standard-layout types.
2223  const Type *BaseTy = getBaseElementTypeUnsafe();
2224  assert(BaseTy && "NULL element type");
2225 
2226  // Return false for incomplete types after skipping any incomplete array
2227  // types which are expressly allowed by the standard and thus our API.
2228  if (BaseTy->isIncompleteType())
2229  return false;
2230 
2231  // As an extension, Clang treats vector types as Scalar types.
2232  if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
2233  if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
2234  if (const CXXRecordDecl *ClassDecl =
2235  dyn_cast<CXXRecordDecl>(RT->getDecl()))
2236  if (!ClassDecl->isStandardLayout())
2237  return false;
2238 
2239  // Default to 'true' for non-C++ class types.
2240  // FIXME: This is a bit dubious, but plain C structs should trivially meet
2241  // all the requirements of standard layout classes.
2242  return true;
2243  }
2244 
2245  // No other types can match.
2246  return false;
2247 }
2248 
2249 // This is effectively the intersection of isTrivialType and
2250 // isStandardLayoutType. We implement it directly to avoid redundant
2251 // conversions from a type to a CXXRecordDecl.
2252 bool QualType::isCXX11PODType(ASTContext &Context) const {
2253  const Type *ty = getTypePtr();
2254  if (ty->isDependentType())
2255  return false;
2256 
2257  if (Context.getLangOpts().ObjCAutoRefCount) {
2258  switch (getObjCLifetime()) {
2260  return true;
2261 
2263  case Qualifiers::OCL_Weak:
2265  return false;
2266 
2267  case Qualifiers::OCL_None:
2268  break;
2269  }
2270  }
2271 
2272  // C++11 [basic.types]p9:
2273  // Scalar types, POD classes, arrays of such types, and cv-qualified
2274  // versions of these types are collectively called trivial types.
2275  const Type *BaseTy = ty->getBaseElementTypeUnsafe();
2276  assert(BaseTy && "NULL element type");
2277 
2278  // Return false for incomplete types after skipping any incomplete array
2279  // types which are expressly allowed by the standard and thus our API.
2280  if (BaseTy->isIncompleteType())
2281  return false;
2282 
2283  // As an extension, Clang treats vector types as Scalar types.
2284  if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
2285  if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
2286  if (const CXXRecordDecl *ClassDecl =
2287  dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2288  // C++11 [class]p10:
2289  // A POD struct is a non-union class that is both a trivial class [...]
2290  if (!ClassDecl->isTrivial()) return false;
2291 
2292  // C++11 [class]p10:
2293  // A POD struct is a non-union class that is both a trivial class and
2294  // a standard-layout class [...]
2295  if (!ClassDecl->isStandardLayout()) return false;
2296 
2297  // C++11 [class]p10:
2298  // A POD struct is a non-union class that is both a trivial class and
2299  // a standard-layout class, and has no non-static data members of type
2300  // non-POD struct, non-POD union (or array of such types). [...]
2301  //
2302  // We don't directly query the recursive aspect as the requirements for
2303  // both standard-layout classes and trivial classes apply recursively
2304  // already.
2305  }
2306 
2307  return true;
2308  }
2309 
2310  // No other types can match.
2311  return false;
2312 }
2313 
2315  if (const BuiltinType *BT = getAs<BuiltinType>())
2316  switch (BT->getKind()) {
2317  case BuiltinType::Bool:
2318  case BuiltinType::Char_S:
2319  case BuiltinType::Char_U:
2320  case BuiltinType::SChar:
2321  case BuiltinType::UChar:
2322  case BuiltinType::Short:
2323  case BuiltinType::UShort:
2324  case BuiltinType::WChar_S:
2325  case BuiltinType::WChar_U:
2326  case BuiltinType::Char16:
2327  case BuiltinType::Char32:
2328  return true;
2329  default:
2330  return false;
2331  }
2332 
2333  // Enumerated types are promotable to their compatible integer types
2334  // (C99 6.3.1.1) a.k.a. its underlying type (C++ [conv.prom]p2).
2335  if (const EnumType *ET = getAs<EnumType>()){
2336  if (this->isDependentType() || ET->getDecl()->getPromotionType().isNull()
2337  || ET->getDecl()->isScoped())
2338  return false;
2339 
2340  return true;
2341  }
2342 
2343  return false;
2344 }
2345 
2347  // Note that this intentionally does not use the canonical type.
2348  switch (getTypeClass()) {
2349  case Builtin:
2350  case Record:
2351  case Enum:
2352  case Typedef:
2353  case Complex:
2354  case TypeOfExpr:
2355  case TypeOf:
2356  case TemplateTypeParm:
2357  case SubstTemplateTypeParm:
2358  case TemplateSpecialization:
2359  case Elaborated:
2360  case DependentName:
2361  case DependentTemplateSpecialization:
2362  case ObjCInterface:
2363  case ObjCObject:
2364  case ObjCObjectPointer: // FIXME: object pointers aren't really specifiers
2365  return true;
2366  default:
2367  return false;
2368  }
2369 }
2370 
2373  switch (TypeSpec) {
2374  default: return ETK_None;
2375  case TST_typename: return ETK_Typename;
2376  case TST_class: return ETK_Class;
2377  case TST_struct: return ETK_Struct;
2378  case TST_interface: return ETK_Interface;
2379  case TST_union: return ETK_Union;
2380  case TST_enum: return ETK_Enum;
2381  }
2382 }
2383 
2386  switch(TypeSpec) {
2387  case TST_class: return TTK_Class;
2388  case TST_struct: return TTK_Struct;
2389  case TST_interface: return TTK_Interface;
2390  case TST_union: return TTK_Union;
2391  case TST_enum: return TTK_Enum;
2392  }
2393 
2394  llvm_unreachable("Type specifier is not a tag type kind.");
2395 }
2396 
2399  switch (Kind) {
2400  case TTK_Class: return ETK_Class;
2401  case TTK_Struct: return ETK_Struct;
2402  case TTK_Interface: return ETK_Interface;
2403  case TTK_Union: return ETK_Union;
2404  case TTK_Enum: return ETK_Enum;
2405  }
2406  llvm_unreachable("Unknown tag type kind.");
2407 }
2408 
2411  switch (Keyword) {
2412  case ETK_Class: return TTK_Class;
2413  case ETK_Struct: return TTK_Struct;
2414  case ETK_Interface: return TTK_Interface;
2415  case ETK_Union: return TTK_Union;
2416  case ETK_Enum: return TTK_Enum;
2417  case ETK_None: // Fall through.
2418  case ETK_Typename:
2419  llvm_unreachable("Elaborated type keyword is not a tag type kind.");
2420  }
2421  llvm_unreachable("Unknown elaborated type keyword.");
2422 }
2423 
2424 bool
2426  switch (Keyword) {
2427  case ETK_None:
2428  case ETK_Typename:
2429  return false;
2430  case ETK_Class:
2431  case ETK_Struct:
2432  case ETK_Interface:
2433  case ETK_Union:
2434  case ETK_Enum:
2435  return true;
2436  }
2437  llvm_unreachable("Unknown elaborated type keyword.");
2438 }
2439 
2441  switch (Keyword) {
2442  case ETK_None: return "";
2443  case ETK_Typename: return "typename";
2444  case ETK_Class: return "class";
2445  case ETK_Struct: return "struct";
2446  case ETK_Interface: return "__interface";
2447  case ETK_Union: return "union";
2448  case ETK_Enum: return "enum";
2449  }
2450 
2451  llvm_unreachable("Unknown elaborated type keyword.");
2452 }
2453 
2455  ElaboratedTypeKeyword Keyword,
2457  unsigned NumArgs, const TemplateArgument *Args,
2458  QualType Canon)
2459  : TypeWithKeyword(Keyword, DependentTemplateSpecialization, Canon, true, true,
2460  /*VariablyModified=*/false,
2461  NNS && NNS->containsUnexpandedParameterPack()),
2462  NNS(NNS), Name(Name), NumArgs(NumArgs) {
2463  assert((!NNS || NNS->isDependent()) &&
2464  "DependentTemplateSpecializatonType requires dependent qualifier");
2465  for (unsigned I = 0; I != NumArgs; ++I) {
2466  if (Args[I].containsUnexpandedParameterPack())
2467  setContainsUnexpandedParameterPack();
2468 
2469  new (&getArgBuffer()[I]) TemplateArgument(Args[I]);
2470  }
2471 }
2472 
2473 void
2474 DependentTemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
2475  const ASTContext &Context,
2476  ElaboratedTypeKeyword Keyword,
2477  NestedNameSpecifier *Qualifier,
2478  const IdentifierInfo *Name,
2479  unsigned NumArgs,
2480  const TemplateArgument *Args) {
2481  ID.AddInteger(Keyword);
2482  ID.AddPointer(Qualifier);
2483  ID.AddPointer(Name);
2484  for (unsigned Idx = 0; Idx < NumArgs; ++Idx)
2485  Args[Idx].Profile(ID, Context);
2486 }
2487 
2488 bool Type::isElaboratedTypeSpecifier() const {
2489  ElaboratedTypeKeyword Keyword;
2490  if (const ElaboratedType *Elab = dyn_cast<ElaboratedType>(this))
2491  Keyword = Elab->getKeyword();
2492  else if (const DependentNameType *DepName = dyn_cast<DependentNameType>(this))
2493  Keyword = DepName->getKeyword();
2494  else if (const DependentTemplateSpecializationType *DepTST =
2495  dyn_cast<DependentTemplateSpecializationType>(this))
2496  Keyword = DepTST->getKeyword();
2497  else
2498  return false;
2499 
2500  return TypeWithKeyword::KeywordIsTagTypeKind(Keyword);
2501 }
2502 
2503 const char *Type::getTypeClassName() const {
2504  switch (TypeBits.TC) {
2505 #define ABSTRACT_TYPE(Derived, Base)
2506 #define TYPE(Derived, Base) case Derived: return #Derived;
2507 #include "clang/AST/TypeNodes.def"
2508  }
2509 
2510  llvm_unreachable("Invalid type class.");
2511 }
2512 
2513 StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
2514  switch (getKind()) {
2515  case Void:
2516  return "void";
2517  case Bool:
2518  return Policy.Bool ? "bool" : "_Bool";
2519  case Char_S:
2520  return "char";
2521  case Char_U:
2522  return "char";
2523  case SChar:
2524  return "signed char";
2525  case Short:
2526  return "short";
2527  case Int:
2528  return "int";
2529  case Long:
2530  return "long";
2531  case LongLong:
2532  return "long long";
2533  case Int128:
2534  return "__int128";
2535  case UChar:
2536  return "unsigned char";
2537  case UShort:
2538  return "unsigned short";
2539  case UInt:
2540  return "unsigned int";
2541  case ULong:
2542  return "unsigned long";
2543  case ULongLong:
2544  return "unsigned long long";
2545  case UInt128:
2546  return "unsigned __int128";
2547  case Half:
2548  return Policy.Half ? "half" : "__fp16";
2549  case Float:
2550  return "float";
2551  case Double:
2552  return "double";
2553  case LongDouble:
2554  return "long double";
2555  case WChar_S:
2556  case WChar_U:
2557  return Policy.MSWChar ? "__wchar_t" : "wchar_t";
2558  case Char16:
2559  return "char16_t";
2560  case Char32:
2561  return "char32_t";
2562  case NullPtr:
2563  return "nullptr_t";
2564  case Overload:
2565  return "<overloaded function type>";
2566  case BoundMember:
2567  return "<bound member function type>";
2568  case PseudoObject:
2569  return "<pseudo-object type>";
2570  case Dependent:
2571  return "<dependent type>";
2572  case UnknownAny:
2573  return "<unknown type>";
2574  case ARCUnbridgedCast:
2575  return "<ARC unbridged cast type>";
2576  case BuiltinFn:
2577  return "<builtin fn type>";
2578  case ObjCId:
2579  return "id";
2580  case ObjCClass:
2581  return "Class";
2582  case ObjCSel:
2583  return "SEL";
2584  case OCLImage1d:
2585  return "image1d_t";
2586  case OCLImage1dArray:
2587  return "image1d_array_t";
2588  case OCLImage1dBuffer:
2589  return "image1d_buffer_t";
2590  case OCLImage2d:
2591  return "image2d_t";
2592  case OCLImage2dArray:
2593  return "image2d_array_t";
2594  case OCLImage2dDepth:
2595  return "image2d_depth_t";
2596  case OCLImage2dArrayDepth:
2597  return "image2d_array_depth_t";
2598  case OCLImage2dMSAA:
2599  return "image2d_msaa_t";
2600  case OCLImage2dArrayMSAA:
2601  return "image2d_array_msaa_t";
2602  case OCLImage2dMSAADepth:
2603  return "image2d_msaa_depth_t";
2604  case OCLImage2dArrayMSAADepth:
2605  return "image2d_array_msaa_depth_t";
2606  case OCLImage3d:
2607  return "image3d_t";
2608  case OCLSampler:
2609  return "sampler_t";
2610  case OCLEvent:
2611  return "event_t";
2612  case OCLClkEvent:
2613  return "clk_event_t";
2614  case OCLQueue:
2615  return "queue_t";
2616  case OCLNDRange:
2617  return "ndrange_t";
2618  case OCLReserveID:
2619  return "reserve_id_t";
2620  case OMPArraySection:
2621  return "<OpenMP array section type>";
2622  }
2623 
2624  llvm_unreachable("Invalid builtin type.");
2625 }
2626 
2628  if (const ReferenceType *RefType = getTypePtr()->getAs<ReferenceType>())
2629  return RefType->getPointeeType();
2630 
2631  // C++0x [basic.lval]:
2632  // Class prvalues can have cv-qualified types; non-class prvalues always
2633  // have cv-unqualified types.
2634  //
2635  // See also C99 6.3.2.1p2.
2636  if (!Context.getLangOpts().CPlusPlus ||
2638  return getUnqualifiedType();
2639 
2640  return *this;
2641 }
2642 
2644  switch (CC) {
2645  case CC_C: return "cdecl";
2646  case CC_X86StdCall: return "stdcall";
2647  case CC_X86FastCall: return "fastcall";
2648  case CC_X86ThisCall: return "thiscall";
2649  case CC_X86Pascal: return "pascal";
2650  case CC_X86VectorCall: return "vectorcall";
2651  case CC_X86_64Win64: return "ms_abi";
2652  case CC_X86_64SysV: return "sysv_abi";
2653  case CC_AAPCS: return "aapcs";
2654  case CC_AAPCS_VFP: return "aapcs-vfp";
2655  case CC_IntelOclBicc: return "intel_ocl_bicc";
2656  case CC_SpirFunction: return "spir_function";
2657  case CC_SpirKernel: return "spir_kernel";
2658  }
2659 
2660  llvm_unreachable("Invalid calling convention.");
2661 }
2662 
2663 FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
2664  QualType canonical,
2665  const ExtProtoInfo &epi)
2666  : FunctionType(FunctionProto, result, canonical,
2667  result->isDependentType(),
2668  result->isInstantiationDependentType(),
2669  result->isVariablyModifiedType(),
2670  result->containsUnexpandedParameterPack(), epi.ExtInfo),
2671  NumParams(params.size()),
2672  NumExceptions(epi.ExceptionSpec.Exceptions.size()),
2673  ExceptionSpecType(epi.ExceptionSpec.Type),
2674  HasAnyConsumedParams(epi.ConsumedParameters != nullptr),
2675  Variadic(epi.Variadic), HasTrailingReturn(epi.HasTrailingReturn) {
2676  assert(NumParams == params.size() && "function has too many parameters");
2677 
2678  FunctionTypeBits.TypeQuals = epi.TypeQuals;
2679  FunctionTypeBits.RefQualifier = epi.RefQualifier;
2680 
2681  // Fill in the trailing argument array.
2682  QualType *argSlot = reinterpret_cast<QualType*>(this+1);
2683  for (unsigned i = 0; i != NumParams; ++i) {
2684  if (params[i]->isDependentType())
2685  setDependent();
2686  else if (params[i]->isInstantiationDependentType())
2688 
2689  if (params[i]->containsUnexpandedParameterPack())
2691 
2692  argSlot[i] = params[i];
2693  }
2694 
2695  if (getExceptionSpecType() == EST_Dynamic) {
2696  // Fill in the exception array.
2697  QualType *exnSlot = argSlot + NumParams;
2698  unsigned I = 0;
2699  for (QualType ExceptionType : epi.ExceptionSpec.Exceptions) {
2700  // Note that a dependent exception specification does *not* make
2701  // a type dependent; it's not even part of the C++ type system.
2702  if (ExceptionType->isInstantiationDependentType())
2704 
2705  if (ExceptionType->containsUnexpandedParameterPack())
2707 
2708  exnSlot[I++] = ExceptionType;
2709  }
2710  } else if (getExceptionSpecType() == EST_ComputedNoexcept) {
2711  // Store the noexcept expression and context.
2712  Expr **noexSlot = reinterpret_cast<Expr **>(argSlot + NumParams);
2713  *noexSlot = epi.ExceptionSpec.NoexceptExpr;
2714 
2715  if (epi.ExceptionSpec.NoexceptExpr) {
2716  if (epi.ExceptionSpec.NoexceptExpr->isValueDependent() ||
2717  epi.ExceptionSpec.NoexceptExpr->isInstantiationDependent())
2719 
2720  if (epi.ExceptionSpec.NoexceptExpr->containsUnexpandedParameterPack())
2722  }
2723  } else if (getExceptionSpecType() == EST_Uninstantiated) {
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  slot[1] = epi.ExceptionSpec.SourceTemplate;
2730  // This exception specification doesn't make the type dependent, because
2731  // it's not instantiated as part of instantiating the type.
2732  } else if (getExceptionSpecType() == EST_Unevaluated) {
2733  // Store the function decl from which we will resolve our
2734  // exception specification.
2735  FunctionDecl **slot =
2736  reinterpret_cast<FunctionDecl **>(argSlot + NumParams);
2737  slot[0] = epi.ExceptionSpec.SourceDecl;
2738  }
2739 
2740  if (epi.ConsumedParameters) {
2741  bool *consumedParams = const_cast<bool *>(getConsumedParamsBuffer());
2742  for (unsigned i = 0; i != NumParams; ++i)
2743  consumedParams[i] = epi.ConsumedParameters[i];
2744  }
2745 }
2746 
2748  if (Expr *NE = getNoexceptExpr())
2749  return NE->isValueDependent();
2750  for (QualType ET : exceptions())
2751  // A pack expansion with a non-dependent pattern is still dependent,
2752  // because we don't know whether the pattern is in the exception spec
2753  // or not (that depends on whether the pack has 0 expansions).
2754  if (ET->isDependentType() || ET->getAs<PackExpansionType>())
2755  return true;
2756  return false;
2757 }
2758 
2762  if (est == EST_BasicNoexcept)
2763  return NR_Nothrow;
2764 
2765  if (est != EST_ComputedNoexcept)
2766  return NR_NoNoexcept;
2767 
2768  Expr *noexceptExpr = getNoexceptExpr();
2769  if (!noexceptExpr)
2770  return NR_BadNoexcept;
2771  if (noexceptExpr->isValueDependent())
2772  return NR_Dependent;
2773 
2774  llvm::APSInt value;
2775  bool isICE = noexceptExpr->isIntegerConstantExpr(value, ctx, nullptr,
2776  /*evaluated*/false);
2777  (void)isICE;
2778  assert(isICE && "AST should not contain bad noexcept expressions.");
2779 
2780  return value.getBoolValue() ? NR_Nothrow : NR_Throw;
2781 }
2782 
2784  bool ResultIfDependent) const {
2786  assert(EST != EST_Unevaluated && EST != EST_Uninstantiated);
2787  if (EST == EST_DynamicNone || EST == EST_BasicNoexcept)
2788  return true;
2789 
2790  if (EST == EST_Dynamic && ResultIfDependent) {
2791  // A dynamic exception specification is throwing unless every exception
2792  // type is an (unexpanded) pack expansion type.
2793  for (unsigned I = 0, N = NumExceptions; I != N; ++I)
2794  if (!getExceptionType(I)->getAs<PackExpansionType>())
2795  return false;
2796  return ResultIfDependent;
2797  }
2798 
2799  if (EST != EST_ComputedNoexcept)
2800  return false;
2801 
2802  NoexceptResult NR = getNoexceptSpec(Ctx);
2803  if (NR == NR_Dependent)
2804  return ResultIfDependent;
2805  return NR == NR_Nothrow;
2806 }
2807 
2809  for (unsigned ArgIdx = getNumParams(); ArgIdx; --ArgIdx)
2810  if (isa<PackExpansionType>(getParamType(ArgIdx - 1)))
2811  return true;
2812 
2813  return false;
2814 }
2815 
2816 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
2817  const QualType *ArgTys, unsigned NumParams,
2818  const ExtProtoInfo &epi,
2819  const ASTContext &Context) {
2820 
2821  // We have to be careful not to get ambiguous profile encodings.
2822  // Note that valid type pointers are never ambiguous with anything else.
2823  //
2824  // The encoding grammar begins:
2825  // type type* bool int bool
2826  // If that final bool is true, then there is a section for the EH spec:
2827  // bool type*
2828  // This is followed by an optional "consumed argument" section of the
2829  // same length as the first type sequence:
2830  // bool*
2831  // Finally, we have the ext info and trailing return type flag:
2832  // int bool
2833  //
2834  // There is no ambiguity between the consumed arguments and an empty EH
2835  // spec because of the leading 'bool' which unambiguously indicates
2836  // whether the following bool is the EH spec or part of the arguments.
2837 
2838  ID.AddPointer(Result.getAsOpaquePtr());
2839  for (unsigned i = 0; i != NumParams; ++i)
2840  ID.AddPointer(ArgTys[i].getAsOpaquePtr());
2841  // This method is relatively performance sensitive, so as a performance
2842  // shortcut, use one AddInteger call instead of four for the next four
2843  // fields.
2844  assert(!(unsigned(epi.Variadic) & ~1) &&
2845  !(unsigned(epi.TypeQuals) & ~255) &&
2846  !(unsigned(epi.RefQualifier) & ~3) &&
2847  !(unsigned(epi.ExceptionSpec.Type) & ~15) &&
2848  "Values larger than expected.");
2849  ID.AddInteger(unsigned(epi.Variadic) +
2850  (epi.TypeQuals << 1) +
2851  (epi.RefQualifier << 9) +
2852  (epi.ExceptionSpec.Type << 11));
2853  if (epi.ExceptionSpec.Type == EST_Dynamic) {
2854  for (QualType Ex : epi.ExceptionSpec.Exceptions)
2855  ID.AddPointer(Ex.getAsOpaquePtr());
2856  } else if (epi.ExceptionSpec.Type == EST_ComputedNoexcept &&
2857  epi.ExceptionSpec.NoexceptExpr) {
2858  epi.ExceptionSpec.NoexceptExpr->Profile(ID, Context, false);
2859  } else if (epi.ExceptionSpec.Type == EST_Uninstantiated ||
2860  epi.ExceptionSpec.Type == EST_Unevaluated) {
2861  ID.AddPointer(epi.ExceptionSpec.SourceDecl->getCanonicalDecl());
2862  }
2863  if (epi.ConsumedParameters) {
2864  for (unsigned i = 0; i != NumParams; ++i)
2865  ID.AddBoolean(epi.ConsumedParameters[i]);
2866  }
2867  epi.ExtInfo.Profile(ID);
2868  ID.AddBoolean(epi.HasTrailingReturn);
2869 }
2870 
2871 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID,
2872  const ASTContext &Ctx) {
2873  Profile(ID, getReturnType(), param_type_begin(), NumParams, getExtProtoInfo(),
2874  Ctx);
2875 }
2876 
2878  return getDecl()->getUnderlyingType();
2879 }
2880 
2882  : Type(TypeOfExpr, can, E->isTypeDependent(),
2883  E->isInstantiationDependent(),
2884  E->getType()->isVariablyModifiedType(),
2885  E->containsUnexpandedParameterPack()),
2886  TOExpr(E) {
2887 }
2888 
2890  return !TOExpr->isTypeDependent();
2891 }
2892 
2894  if (isSugared())
2895  return getUnderlyingExpr()->getType();
2896 
2897  return QualType(this, 0);
2898 }
2899 
2900 void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID,
2901  const ASTContext &Context, Expr *E) {
2902  E->Profile(ID, Context, true);
2903 }
2904 
2906  // C++11 [temp.type]p2: "If an expression e involves a template parameter,
2907  // decltype(e) denotes a unique dependent type." Hence a decltype type is
2908  // type-dependent even if its expression is only instantiation-dependent.
2909  : Type(Decltype, can, E->isInstantiationDependent(),
2910  E->isInstantiationDependent(),
2911  E->getType()->isVariablyModifiedType(),
2912  E->containsUnexpandedParameterPack()),
2913  E(E),
2914  UnderlyingType(underlyingType) {
2915 }
2916 
2918 
2920  if (isSugared())
2921  return getUnderlyingType();
2922 
2923  return QualType(this, 0);
2924 }
2925 
2927  : DecltypeType(E, Context.DependentTy), Context(Context) { }
2928 
2929 void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID,
2930  const ASTContext &Context, Expr *E) {
2931  E->Profile(ID, Context, true);
2932 }
2933 
2935  : Type(TC, can, D->isDependentType(),
2936  /*InstantiationDependent=*/D->isDependentType(),
2937  /*VariablyModified=*/false,
2938  /*ContainsUnexpandedParameterPack=*/false),
2939  decl(const_cast<TagDecl*>(D)) {}
2940 
2942  for (auto I : decl->redecls()) {
2943  if (I->isCompleteDefinition() || I->isBeingDefined())
2944  return I;
2945  }
2946  // If there's no definition (not even in progress), return what we have.
2947  return decl;
2948 }
2949 
2951  QualType UnderlyingType,
2952  UTTKind UKind,
2953  QualType CanonicalType)
2954  : Type(UnaryTransform, CanonicalType, UnderlyingType->isDependentType(),
2955  UnderlyingType->isInstantiationDependentType(),
2956  UnderlyingType->isVariablyModifiedType(),
2957  BaseType->containsUnexpandedParameterPack())
2958  , BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind)
2959 {}
2960 
2962  return getInterestingTagDecl(decl);
2963 }
2964 
2966  return getDecl()->isBeingDefined();
2967 }
2968 
2970  switch (getAttrKind()) {
2971  // These are type qualifiers in the traditional C sense: they annotate
2972  // something about a specific value/variable of a type. (They aren't
2973  // always part of the canonical type, though.)
2981  return true;
2982 
2983  // These aren't qualifiers; they rewrite the modified type to be a
2984  // semantically different type.
3006  return false;
3007  }
3008  llvm_unreachable("bad attributed type kind");
3009 }
3010 
3012  switch (getAttrKind()) {
3013  default: return false;
3014  case attr_ptr32:
3015  case attr_ptr64:
3016  case attr_sptr:
3017  case attr_uptr:
3018  return true;
3019  }
3020  llvm_unreachable("invalid attr kind");
3021 }
3022 
3024  switch (getAttrKind()) {
3025  case attr_ptr32:
3026  case attr_ptr64:
3027  case attr_sptr:
3028  case attr_uptr:
3029  case attr_address_space:
3030  case attr_regparm:
3031  case attr_vector_size:
3032  case attr_neon_vector_type:
3034  case attr_objc_gc:
3035  case attr_objc_ownership:
3037  case attr_noreturn:
3038  case attr_nonnull:
3039  case attr_nullable:
3040  case attr_null_unspecified:
3041  case attr_objc_kindof:
3042  return false;
3043 
3044  case attr_pcs:
3045  case attr_pcs_vfp:
3046  case attr_cdecl:
3047  case attr_fastcall:
3048  case attr_stdcall:
3049  case attr_thiscall:
3050  case attr_vectorcall:
3051  case attr_pascal:
3052  case attr_ms_abi:
3053  case attr_sysv_abi:
3054  case attr_inteloclbicc:
3055  return true;
3056  }
3057  llvm_unreachable("invalid attr kind");
3058 }
3059 
3061  return cast<CXXRecordDecl>(getInterestingTagDecl(Decl));
3062 }
3063 
3065  return isCanonicalUnqualified() ? nullptr : getDecl()->getIdentifier();
3066 }
3067 
3068 SubstTemplateTypeParmPackType::
3069 SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
3070  QualType Canon,
3071  const TemplateArgument &ArgPack)
3072  : Type(SubstTemplateTypeParmPack, Canon, true, true, false, true),
3073  Replaced(Param),
3074  Arguments(ArgPack.pack_begin()), NumArguments(ArgPack.pack_size())
3075 {
3076 }
3077 
3079  return TemplateArgument(llvm::makeArrayRef(Arguments, NumArguments));
3080 }
3081 
3082 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
3084 }
3085 
3086 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
3087  const TemplateTypeParmType *Replaced,
3088  const TemplateArgument &ArgPack) {
3089  ID.AddPointer(Replaced);
3090  ID.AddInteger(ArgPack.pack_size());
3091  for (const auto &P : ArgPack.pack_elements())
3092  ID.AddPointer(P.getAsType().getAsOpaquePtr());
3093 }
3094 
3097  bool &InstantiationDependent) {
3098  return anyDependentTemplateArguments(Args.getArgumentArray(), Args.size(),
3099  InstantiationDependent);
3100 }
3101 
3103 anyDependentTemplateArguments(const TemplateArgumentLoc *Args, unsigned N,
3104  bool &InstantiationDependent) {
3105  for (unsigned i = 0; i != N; ++i) {
3106  if (Args[i].getArgument().isDependent()) {
3107  InstantiationDependent = true;
3108  return true;
3109  }
3110 
3111  if (Args[i].getArgument().isInstantiationDependent())
3112  InstantiationDependent = true;
3113  }
3114  return false;
3115 }
3116 
3119  const TemplateArgument *Args, unsigned NumArgs,
3120  QualType Canon, QualType AliasedType)
3121  : Type(TemplateSpecialization,
3122  Canon.isNull()? QualType(this, 0) : Canon,
3123  Canon.isNull()? true : Canon->isDependentType(),
3124  Canon.isNull()? true : Canon->isInstantiationDependentType(),
3125  false,
3126  T.containsUnexpandedParameterPack()),
3127  Template(T), NumArgs(NumArgs), TypeAlias(!AliasedType.isNull()) {
3128  assert(!T.getAsDependentTemplateName() &&
3129  "Use DependentTemplateSpecializationType for dependent template-name");
3130  assert((T.getKind() == TemplateName::Template ||
3133  "Unexpected template name for TemplateSpecializationType");
3134 
3135  TemplateArgument *TemplateArgs
3136  = reinterpret_cast<TemplateArgument *>(this + 1);
3137  for (unsigned Arg = 0; Arg < NumArgs; ++Arg) {
3138  // Update instantiation-dependent and variably-modified bits.
3139  // If the canonical type exists and is non-dependent, the template
3140  // specialization type can be non-dependent even if one of the type
3141  // arguments is. Given:
3142  // template<typename T> using U = int;
3143  // U<T> is always non-dependent, irrespective of the type T.
3144  // However, U<Ts> contains an unexpanded parameter pack, even though
3145  // its expansion (and thus its desugared type) doesn't.
3146  if (Args[Arg].isInstantiationDependent())
3147  setInstantiationDependent();
3148  if (Args[Arg].getKind() == TemplateArgument::Type &&
3149  Args[Arg].getAsType()->isVariablyModifiedType())
3150  setVariablyModified();
3151  if (Args[Arg].containsUnexpandedParameterPack())
3152  setContainsUnexpandedParameterPack();
3153  new (&TemplateArgs[Arg]) TemplateArgument(Args[Arg]);
3154  }
3155 
3156  // Store the aliased type if this is a type alias template specialization.
3157  if (TypeAlias) {
3158  TemplateArgument *Begin = reinterpret_cast<TemplateArgument *>(this + 1);
3159  *reinterpret_cast<QualType*>(Begin + getNumArgs()) = AliasedType;
3160  }
3161 }
3162 
3163 void
3164 TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
3165  TemplateName T,
3166  const TemplateArgument *Args,
3167  unsigned NumArgs,
3168  const ASTContext &Context) {
3169  T.Profile(ID);
3170  for (unsigned Idx = 0; Idx < NumArgs; ++Idx)
3171  Args[Idx].Profile(ID, Context);
3172 }
3173 
3174 QualType
3175 QualifierCollector::apply(const ASTContext &Context, QualType QT) const {
3176  if (!hasNonFastQualifiers())
3178 
3179  return Context.getQualifiedType(QT, *this);
3180 }
3181 
3182 QualType
3183 QualifierCollector::apply(const ASTContext &Context, const Type *T) const {
3184  if (!hasNonFastQualifiers())
3185  return QualType(T, getFastQualifiers());
3186 
3187  return Context.getQualifiedType(T, *this);
3188 }
3189 
3190 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID,
3191  QualType BaseType,
3192  ArrayRef<QualType> typeArgs,
3193  ArrayRef<ObjCProtocolDecl *> protocols,
3194  bool isKindOf) {
3195  ID.AddPointer(BaseType.getAsOpaquePtr());
3196  ID.AddInteger(typeArgs.size());
3197  for (auto typeArg : typeArgs)
3198  ID.AddPointer(typeArg.getAsOpaquePtr());
3199  ID.AddInteger(protocols.size());
3200  for (auto proto : protocols)
3201  ID.AddPointer(proto);
3202  ID.AddBoolean(isKindOf);
3203 }
3204 
3205 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) {
3207  llvm::makeArrayRef(qual_begin(), getNumProtocols()),
3209 }
3210 
3211 namespace {
3212 
3213 /// \brief The cached properties of a type.
3214 class CachedProperties {
3215  Linkage L;
3216  bool local;
3217 
3218 public:
3219  CachedProperties(Linkage L, bool local) : L(L), local(local) {}
3220 
3221  Linkage getLinkage() const { return L; }
3222  bool hasLocalOrUnnamedType() const { return local; }
3223 
3224  friend CachedProperties merge(CachedProperties L, CachedProperties R) {
3225  Linkage MergedLinkage = minLinkage(L.L, R.L);
3226  return CachedProperties(MergedLinkage,
3227  L.hasLocalOrUnnamedType() | R.hasLocalOrUnnamedType());
3228  }
3229 };
3230 }
3231 
3232 static CachedProperties computeCachedProperties(const Type *T);
3233 
3234 namespace clang {
3235 /// The type-property cache. This is templated so as to be
3236 /// instantiated at an internal type to prevent unnecessary symbol
3237 /// leakage.
3238 template <class Private> class TypePropertyCache {
3239 public:
3240  static CachedProperties get(QualType T) {
3241  return get(T.getTypePtr());
3242  }
3243 
3244  static CachedProperties get(const Type *T) {
3245  ensure(T);
3246  return CachedProperties(T->TypeBits.getLinkage(),
3247  T->TypeBits.hasLocalOrUnnamedType());
3248  }
3249 
3250  static void ensure(const Type *T) {
3251  // If the cache is valid, we're okay.
3252  if (T->TypeBits.isCacheValid()) return;
3253 
3254  // If this type is non-canonical, ask its canonical type for the
3255  // relevant information.
3256  if (!T->isCanonicalUnqualified()) {
3257  const Type *CT = T->getCanonicalTypeInternal().getTypePtr();
3258  ensure(CT);
3259  T->TypeBits.CacheValid = true;
3260  T->TypeBits.CachedLinkage = CT->TypeBits.CachedLinkage;
3261  T->TypeBits.CachedLocalOrUnnamed = CT->TypeBits.CachedLocalOrUnnamed;
3262  return;
3263  }
3264 
3265  // Compute the cached properties and then set the cache.
3266  CachedProperties Result = computeCachedProperties(T);
3267  T->TypeBits.CacheValid = true;
3268  T->TypeBits.CachedLinkage = Result.getLinkage();
3269  T->TypeBits.CachedLocalOrUnnamed = Result.hasLocalOrUnnamedType();
3270  }
3271 };
3272 }
3273 
3274 // Instantiate the friend template at a private class. In a
3275 // reasonable implementation, these symbols will be internal.
3276 // It is terrible that this is the best way to accomplish this.
3277 namespace { class Private {}; }
3279 
3280 static CachedProperties computeCachedProperties(const Type *T) {
3281  switch (T->getTypeClass()) {
3282 #define TYPE(Class,Base)
3283 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
3284 #include "clang/AST/TypeNodes.def"
3285  llvm_unreachable("didn't expect a non-canonical type here");
3286 
3287 #define TYPE(Class,Base)
3288 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
3289 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
3290 #include "clang/AST/TypeNodes.def"
3291  // Treat instantiation-dependent types as external.
3292  assert(T->isInstantiationDependentType());
3293  return CachedProperties(ExternalLinkage, false);
3294 
3295  case Type::Auto:
3296  // Give non-deduced 'auto' types external linkage. We should only see them
3297  // here in error recovery.
3298  return CachedProperties(ExternalLinkage, false);
3299 
3300  case Type::Builtin:
3301  // C++ [basic.link]p8:
3302  // A type is said to have linkage if and only if:
3303  // - it is a fundamental type (3.9.1); or
3304  return CachedProperties(ExternalLinkage, false);
3305 
3306  case Type::Record:
3307  case Type::Enum: {
3308  const TagDecl *Tag = cast<TagType>(T)->getDecl();
3309 
3310  // C++ [basic.link]p8:
3311  // - it is a class or enumeration type that is named (or has a name
3312  // for linkage purposes (7.1.3)) and the name has linkage; or
3313  // - it is a specialization of a class template (14); or
3314  Linkage L = Tag->getLinkageInternal();
3315  bool IsLocalOrUnnamed =
3316  Tag->getDeclContext()->isFunctionOrMethod() ||
3317  !Tag->hasNameForLinkage();
3318  return CachedProperties(L, IsLocalOrUnnamed);
3319  }
3320 
3321  // C++ [basic.link]p8:
3322  // - it is a compound type (3.9.2) other than a class or enumeration,
3323  // compounded exclusively from types that have linkage; or
3324  case Type::Complex:
3325  return Cache::get(cast<ComplexType>(T)->getElementType());
3326  case Type::Pointer:
3327  return Cache::get(cast<PointerType>(T)->getPointeeType());
3328  case Type::BlockPointer:
3329  return Cache::get(cast<BlockPointerType>(T)->getPointeeType());
3330  case Type::LValueReference:
3331  case Type::RValueReference:
3332  return Cache::get(cast<ReferenceType>(T)->getPointeeType());
3333  case Type::MemberPointer: {
3334  const MemberPointerType *MPT = cast<MemberPointerType>(T);
3335  return merge(Cache::get(MPT->getClass()),
3336  Cache::get(MPT->getPointeeType()));
3337  }
3338  case Type::ConstantArray:
3339  case Type::IncompleteArray:
3340  case Type::VariableArray:
3341  return Cache::get(cast<ArrayType>(T)->getElementType());
3342  case Type::Vector:
3343  case Type::ExtVector:
3344  return Cache::get(cast<VectorType>(T)->getElementType());
3345  case Type::FunctionNoProto:
3346  return Cache::get(cast<FunctionType>(T)->getReturnType());
3347  case Type::FunctionProto: {
3348  const FunctionProtoType *FPT = cast<FunctionProtoType>(T);
3349  CachedProperties result = Cache::get(FPT->getReturnType());
3350  for (const auto &ai : FPT->param_types())
3351  result = merge(result, Cache::get(ai));
3352  return result;
3353  }
3354  case Type::ObjCInterface: {
3355  Linkage L = cast<ObjCInterfaceType>(T)->getDecl()->getLinkageInternal();
3356  return CachedProperties(L, false);
3357  }
3358  case Type::ObjCObject:
3359  return Cache::get(cast<ObjCObjectType>(T)->getBaseType());
3360  case Type::ObjCObjectPointer:
3361  return Cache::get(cast<ObjCObjectPointerType>(T)->getPointeeType());
3362  case Type::Atomic:
3363  return Cache::get(cast<AtomicType>(T)->getValueType());
3364  case Type::Pipe:
3365  return Cache::get(cast<PipeType>(T)->getElementType());
3366  }
3367 
3368  llvm_unreachable("unhandled type class");
3369 }
3370 
3371 /// \brief Determine the linkage of this type.
3373  Cache::ensure(this);
3374  return TypeBits.getLinkage();
3375 }
3376 
3378  Cache::ensure(this);
3379  return TypeBits.hasLocalOrUnnamedType();
3380 }
3381 
3383 
3385  switch (T->getTypeClass()) {
3386 #define TYPE(Class,Base)
3387 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
3388 #include "clang/AST/TypeNodes.def"
3389  llvm_unreachable("didn't expect a non-canonical type here");
3390 
3391 #define TYPE(Class,Base)
3392 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
3393 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
3394 #include "clang/AST/TypeNodes.def"
3395  // Treat instantiation-dependent types as external.
3396  assert(T->isInstantiationDependentType());
3397  return LinkageInfo::external();
3398 
3399  case Type::Builtin:
3400  return LinkageInfo::external();
3401 
3402  case Type::Auto:
3403  return LinkageInfo::external();
3404 
3405  case Type::Record:
3406  case Type::Enum:
3407  return cast<TagType>(T)->getDecl()->getLinkageAndVisibility();
3408 
3409  case Type::Complex:
3410  return computeLinkageInfo(cast<ComplexType>(T)->getElementType());
3411  case Type::Pointer:
3412  return computeLinkageInfo(cast<PointerType>(T)->getPointeeType());
3413  case Type::BlockPointer:
3414  return computeLinkageInfo(cast<BlockPointerType>(T)->getPointeeType());
3415  case Type::LValueReference:
3416  case Type::RValueReference:
3417  return computeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
3418  case Type::MemberPointer: {
3419  const MemberPointerType *MPT = cast<MemberPointerType>(T);
3422  return LV;
3423  }
3424  case Type::ConstantArray:
3425  case Type::IncompleteArray:
3426  case Type::VariableArray:
3427  return computeLinkageInfo(cast<ArrayType>(T)->getElementType());
3428  case Type::Vector:
3429  case Type::ExtVector:
3430  return computeLinkageInfo(cast<VectorType>(T)->getElementType());
3431  case Type::FunctionNoProto:
3432  return computeLinkageInfo(cast<FunctionType>(T)->getReturnType());
3433  case Type::FunctionProto: {
3434  const FunctionProtoType *FPT = cast<FunctionProtoType>(T);
3436  for (const auto &ai : FPT->param_types())
3437  LV.merge(computeLinkageInfo(ai));
3438  return LV;
3439  }
3440  case Type::ObjCInterface:
3441  return cast<ObjCInterfaceType>(T)->getDecl()->getLinkageAndVisibility();
3442  case Type::ObjCObject:
3443  return computeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType());
3444  case Type::ObjCObjectPointer:
3445  return computeLinkageInfo(cast<ObjCObjectPointerType>(T)->getPointeeType());
3446  case Type::Atomic:
3447  return computeLinkageInfo(cast<AtomicType>(T)->getValueType());
3448  case Type::Pipe:
3449  return computeLinkageInfo(cast<PipeType>(T)->getElementType());
3450  }
3451 
3452  llvm_unreachable("unhandled type class");
3453 }
3454 
3456  return computeLinkageInfo(T.getTypePtr());
3457 }
3458 
3459 bool Type::isLinkageValid() const {
3460  if (!TypeBits.isCacheValid())
3461  return true;
3462 
3464  TypeBits.getLinkage();
3465 }
3466 
3468  if (!isCanonicalUnqualified())
3470 
3471  LinkageInfo LV = computeLinkageInfo(this);
3472  assert(LV.getLinkage() == getLinkage());
3473  return LV;
3474 }
3475 
3477  QualType type(this, 0);
3478  do {
3479  // Check whether this is an attributed type with nullability
3480  // information.
3481  if (auto attributed = dyn_cast<AttributedType>(type.getTypePtr())) {
3482  if (auto nullability = attributed->getImmediateNullability())
3483  return nullability;
3484  }
3485 
3486  // Desugar the type. If desugaring does nothing, we're done.
3487  QualType desugared = type.getSingleStepDesugaredType(context);
3488  if (desugared.getTypePtr() == type.getTypePtr())
3489  return None;
3490 
3491  type = desugared;
3492  } while (true);
3493 }
3494 
3497 
3498  switch (type->getTypeClass()) {
3499  // We'll only see canonical types here.
3500 #define NON_CANONICAL_TYPE(Class, Parent) \
3501  case Type::Class: \
3502  llvm_unreachable("non-canonical type");
3503 #define TYPE(Class, Parent)
3504 #include "clang/AST/TypeNodes.def"
3505 
3506  // Pointer types.
3507  case Type::Pointer:
3508  case Type::BlockPointer:
3509  case Type::MemberPointer:
3510  case Type::ObjCObjectPointer:
3511  return true;
3512 
3513  // Dependent types that could instantiate to pointer types.
3514  case Type::UnresolvedUsing:
3515  case Type::TypeOfExpr:
3516  case Type::TypeOf:
3517  case Type::Decltype:
3518  case Type::UnaryTransform:
3519  case Type::TemplateTypeParm:
3520  case Type::SubstTemplateTypeParmPack:
3521  case Type::DependentName:
3522  case Type::DependentTemplateSpecialization:
3523  return true;
3524 
3525  // Dependent template specializations can instantiate to pointer
3526  // types unless they're known to be specializations of a class
3527  // template.
3528  case Type::TemplateSpecialization:
3529  if (TemplateDecl *templateDecl
3530  = cast<TemplateSpecializationType>(type.getTypePtr())
3532  if (isa<ClassTemplateDecl>(templateDecl))
3533  return false;
3534  }
3535  return true;
3536 
3537  // auto is considered dependent when it isn't deduced.
3538  case Type::Auto:
3539  return !cast<AutoType>(type.getTypePtr())->isDeduced();
3540 
3541  case Type::Builtin:
3542  switch (cast<BuiltinType>(type.getTypePtr())->getKind()) {
3543  // Signed, unsigned, and floating-point types cannot have nullability.
3544 #define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
3545 #define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
3546 #define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
3547 #define BUILTIN_TYPE(Id, SingletonId)
3548 #include "clang/AST/BuiltinTypes.def"
3549  return false;
3550 
3551  // Dependent types that could instantiate to a pointer type.
3552  case BuiltinType::Dependent:
3553  case BuiltinType::Overload:
3554  case BuiltinType::BoundMember:
3555  case BuiltinType::PseudoObject:
3556  case BuiltinType::UnknownAny:
3557  case BuiltinType::ARCUnbridgedCast:
3558  return true;
3559 
3560  case BuiltinType::Void:
3561  case BuiltinType::ObjCId:
3562  case BuiltinType::ObjCClass:
3563  case BuiltinType::ObjCSel:
3564  case BuiltinType::OCLImage1d:
3565  case BuiltinType::OCLImage1dArray:
3566  case BuiltinType::OCLImage1dBuffer:
3567  case BuiltinType::OCLImage2d:
3568  case BuiltinType::OCLImage2dArray:
3569  case BuiltinType::OCLImage2dDepth:
3570  case BuiltinType::OCLImage2dArrayDepth:
3571  case BuiltinType::OCLImage2dMSAA:
3572  case BuiltinType::OCLImage2dArrayMSAA:
3573  case BuiltinType::OCLImage2dMSAADepth:
3574  case BuiltinType::OCLImage2dArrayMSAADepth:
3575  case BuiltinType::OCLImage3d:
3576  case BuiltinType::OCLSampler:
3577  case BuiltinType::OCLEvent:
3578  case BuiltinType::OCLClkEvent:
3579  case BuiltinType::OCLQueue:
3580  case BuiltinType::OCLNDRange:
3581  case BuiltinType::OCLReserveID:
3582  case BuiltinType::BuiltinFn:
3583  case BuiltinType::NullPtr:
3584  case BuiltinType::OMPArraySection:
3585  return false;
3586  }
3587 
3588  // Non-pointer types.
3589  case Type::Complex:
3590  case Type::LValueReference:
3591  case Type::RValueReference:
3592  case Type::ConstantArray:
3593  case Type::IncompleteArray:
3594  case Type::VariableArray:
3595  case Type::DependentSizedArray:
3596  case Type::DependentSizedExtVector:
3597  case Type::Vector:
3598  case Type::ExtVector:
3599  case Type::FunctionProto:
3600  case Type::FunctionNoProto:
3601  case Type::Record:
3602  case Type::Enum:
3603  case Type::InjectedClassName:
3604  case Type::PackExpansion:
3605  case Type::ObjCObject:
3606  case Type::ObjCInterface:
3607  case Type::Atomic:
3608  case Type::Pipe:
3609  return false;
3610  }
3611  llvm_unreachable("bad type kind!");
3612 }
3613 
3616  return NullabilityKind::NonNull;
3621  return None;
3622 }
3623 
3625  if (auto attributed = dyn_cast<AttributedType>(T.getTypePtr())) {
3626  if (auto nullability = attributed->getImmediateNullability()) {
3627  T = attributed->getModifiedType();
3628  return nullability;
3629  }
3630  }
3631 
3632  return None;
3633 }
3634 
3636  const ObjCObjectPointerType *objcPtr = getAs<ObjCObjectPointerType>();
3637  if (!objcPtr)
3638  return false;
3639 
3640  if (objcPtr->isObjCIdType()) {
3641  // id is always okay.
3642  return true;
3643  }
3644 
3645  // Blocks are NSObjects.
3646  if (ObjCInterfaceDecl *iface = objcPtr->getInterfaceDecl()) {
3647  if (iface->getIdentifier() != ctx.getNSObjectName())
3648  return false;
3649 
3650  // Continue to check qualifiers, below.
3651  } else if (objcPtr->isObjCQualifiedIdType()) {
3652  // Continue to check qualifiers, below.
3653  } else {
3654  return false;
3655  }
3656 
3657  // Check protocol qualifiers.
3658  for (ObjCProtocolDecl *proto : objcPtr->quals()) {
3659  // Blocks conform to NSObject and NSCopying.
3660  if (proto->getIdentifier() != ctx.getNSObjectName() &&
3661  proto->getIdentifier() != ctx.getNSCopyingName())
3662  return false;
3663  }
3664 
3665  return true;
3666 }
3667 
3671  return Qualifiers::OCL_Strong;
3672 }
3673 
3675  assert(isObjCLifetimeType() &&
3676  "cannot query implicit lifetime for non-inferrable type");
3677 
3678  const Type *canon = getCanonicalTypeInternal().getTypePtr();
3679 
3680  // Walk down to the base type. We don't care about qualifiers for this.
3681  while (const ArrayType *array = dyn_cast<ArrayType>(canon))
3682  canon = array->getElementType().getTypePtr();
3683 
3684  if (const ObjCObjectPointerType *opt
3685  = dyn_cast<ObjCObjectPointerType>(canon)) {
3686  // Class and Class<Protocol> don't require retention.
3687  if (opt->getObjectType()->isObjCClass())
3688  return true;
3689  }
3690 
3691  return false;
3692 }
3693 
3695  if (const TypedefType *typedefType = dyn_cast<TypedefType>(this))
3696  return typedefType->getDecl()->hasAttr<ObjCNSObjectAttr>();
3697  return false;
3698 }
3700  if (const TypedefType *typedefType = dyn_cast<TypedefType>(this))
3701  return typedefType->getDecl()->hasAttr<ObjCIndependentClassAttr>();
3702  return false;
3703 }
3705  return isObjCObjectPointerType() ||
3706  isBlockPointerType() ||
3708 }
3710  if (isObjCLifetimeType())
3711  return true;
3712  if (const PointerType *OPT = getAs<PointerType>())
3713  return OPT->getPointeeType()->isObjCIndirectLifetimeType();
3714  if (const ReferenceType *Ref = getAs<ReferenceType>())
3715  return Ref->getPointeeType()->isObjCIndirectLifetimeType();
3716  if (const MemberPointerType *MemPtr = getAs<MemberPointerType>())
3717  return MemPtr->getPointeeType()->isObjCIndirectLifetimeType();
3718  return false;
3719 }
3720 
3721 /// Returns true if objects of this type have lifetime semantics under
3722 /// ARC.
3724  const Type *type = this;
3725  while (const ArrayType *array = type->getAsArrayTypeUnsafe())
3726  type = array->getElementType().getTypePtr();
3727  return type->isObjCRetainableType();
3728 }
3729 
3730 /// \brief Determine whether the given type T is a "bridgable" Objective-C type,
3731 /// which is either an Objective-C object pointer type or an
3734 }
3735 
3736 /// \brief Determine whether the given type T is a "bridgeable" C type.
3738  const PointerType *Pointer = getAs<PointerType>();
3739  if (!Pointer)
3740  return false;
3741 
3742  QualType Pointee = Pointer->getPointeeType();
3743  return Pointee->isVoidType() || Pointee->isRecordType();
3744 }
3745 
3747  if (!isVariablyModifiedType()) return false;
3748 
3749  if (const PointerType *ptr = getAs<PointerType>())
3750  return ptr->getPointeeType()->hasSizedVLAType();
3751  if (const ReferenceType *ref = getAs<ReferenceType>())
3752  return ref->getPointeeType()->hasSizedVLAType();
3753  if (const ArrayType *arr = getAsArrayTypeUnsafe()) {
3754  if (isa<VariableArrayType>(arr) &&
3755  cast<VariableArrayType>(arr)->getSizeExpr())
3756  return true;
3757 
3758  return arr->getElementType()->hasSizedVLAType();
3759  }
3760 
3761  return false;
3762 }
3763 
3764 QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) {
3765  switch (type.getObjCLifetime()) {
3766  case Qualifiers::OCL_None:
3769  break;
3770 
3772  return DK_objc_strong_lifetime;
3773  case Qualifiers::OCL_Weak:
3774  return DK_objc_weak_lifetime;
3775  }
3776 
3777  /// Currently, the only destruction kind we recognize is C++ objects
3778  /// with non-trivial destructors.
3779  const CXXRecordDecl *record =
3781  if (record && record->hasDefinition() && !record->hasTrivialDestructor())
3782  return DK_cxx_destructor;
3783 
3784  return DK_none;
3785 }
3786 
3789 }
Kind getKind() const
Definition: Type.h:2028
unsigned getNumElements() const
Definition: Type.h:2749
bool hasObjCGCAttr() const
Definition: Type.h:268
unsigned getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5204
const ComplexType * getAsComplexIntegerType() const
Definition: Type.cpp:408
bool isUnspecialized() const
Determine whether this object type is "unspecialized", meaning that it has no type arguments...
Definition: Type.h:4647
DecltypeType(Expr *E, QualType underlyingType, QualType can=QualType())
Definition: Type.cpp:2905
static StringRef getKeywordName(ElaboratedTypeKeyword Keyword)
Definition: Type.cpp:2440
bool qual_empty() const
Definition: Type.h:4670
bool hasDefinition() const
Determine whether this class has been defined.
Definition: DeclObjC.h:1202
Defines the clang::ASTContext interface.
QualType getExceptionType(unsigned i) const
Definition: Type.h:3221
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:4262
QualType getUnderlyingType() const
Definition: Type.h:3458
const Type * Ty
The locally-unqualified type.
Definition: Type.h:520
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1483
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:50
The "enum" keyword introduces the elaborated-type-specifier.
Definition: Type.h:4199
void setDependent(bool D=true)
Definition: Type.h:1487
llvm::iterator_range< pack_iterator > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:329
bool isCXX98PODType(ASTContext &Context) const
Return true if this is a POD type according to the rules of the C++98 standard, regardless of the cur...
Definition: Type.cpp:1969
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2147
A (possibly-)qualified type.
Definition: Type.h:575
SourceRange getBracketsRange() const
Definition: Type.h:2596
void computeSuperClassTypeSlow() const
Definition: Type.cpp:1370
bool isCharType() const
Definition: Type.cpp:1650
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
Definition: Type.h:1527
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g., it is a floating-point type or a vector thereof.
Definition: Type.cpp:1786
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1263
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type...
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:164
bool isKindOfTypeAsWritten() const
Whether this is a "__kindof" type as written.
Definition: Type.h:4688
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:1757
unsigned getFastQualifiers() const
Definition: Type.h:331
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2627
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1673
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
Definition: Type.cpp:3668
void setInstantiationDependent(bool D=true)
Definition: Type.h:1492
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3116
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1680
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2847
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
bool canHaveNullability() const
Determine whether the given type can have a nullability specifier applied to it, i.e., if it is any kind of pointer type or a dependent type that could instantiate to any kind of pointer type.
Definition: Type.cpp:3495
unsigned MSWChar
When true, print the built-in wchar_t type as __wchar_t.
C Language Family Type Representation.
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:4328
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:171
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.cpp:3082
CXXRecordDecl * getDecl() const
Definition: Type.cpp:3060
bool isRecordType() const
Definition: Type.h:5362
QualType getUnderlyingType() const
Definition: Decl.h:2566
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:77
bool isChar16Type() const
Definition: Type.cpp:1666
ObjCObjectTypeBitfields ObjCObjectTypeBits
Definition: Type.h:1453
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2149
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.cpp:1589
Defines the C++ template declaration subclasses.
bool isVoidPointerType() const
Definition: Type.cpp:385
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:3918
QualType substObjCTypeArgs(ASTContext &ctx, ArrayRef< QualType > typeArgs, ObjCSubstitutionContext context) const
Substitute type arguments for the Objective-C type parameters used in the subject type...
Definition: Type.cpp:1065
bool isEnumeralType() const
Definition: Type.h:5365
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
Definition: Type.cpp:2871
TypePropertyCache< Private > Cache
Definition: Type.cpp:3278
bool hasDefinition() const
Definition: DeclCXX.h:680
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
TemplateSpecializationType(TemplateName T, const TemplateArgument *Args, unsigned NumArgs, QualType Canon, QualType Aliased)
Definition: Type.cpp:3118
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition: Type.cpp:2398
QualType getPointeeType() const
Definition: Type.h:2388
The base class of the type hierarchy.
Definition: Type.h:1249
DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, unsigned NumArgs, const TemplateArgument *Args, QualType Canon)
Definition: Type.cpp:2454
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2424
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:4861
DependentDecltypeType(const ASTContext &Context, Expr *E)
Definition: Type.cpp:2926
bool isBlockPointerType() const
Definition: Type.h:5311
const ObjCObjectPointerType * getAsObjCQualifiedClassType() const
Definition: Type.cpp:1482
bool isSpelledAsLValue() const
Definition: Type.h:2304
A template template parameter that has been substituted for some other template name.
Definition: TemplateName.h:200
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e.g., it is an unsigned integer type or a vector.
Definition: Type.cpp:1770
const llvm::APInt & getSize() const
Definition: Type.h:2495
void * getAsOpaquePtr() const
Definition: Type.h:623
const TemplateArgumentLoc * getArgumentArray() const
Definition: TemplateBase.h:541
static CachedProperties computeCachedProperties(const Type *T)
Definition: Type.cpp:3280
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
QualType substObjCMemberType(QualType objectType, const DeclContext *dc, ObjCSubstitutionContext context) const
Substitute type arguments from an object type for the Objective-C type parameters used in the subject...
Definition: Type.cpp:1244
The noexcept specifier has a bad expression.
Definition: Type.h:3213
ObjCLifetime getObjCLifetime() const
Definition: Type.h:290
The "union" keyword.
Definition: Type.h:4180
Extra information about a function prototype.
Definition: Type.h:3067
The "__interface" keyword.
Definition: Type.h:4178
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1793
TemplateTypeParmDecl * getDecl() const
Definition: Type.h:3783
QualType getOriginalType() const
Definition: Type.h:2211
bool isRealType() const
Definition: Type.cpp:1799
bool isTrivialType(ASTContext &Context) const
Return true if this is a trivial type per (C++0x [basic.types]p9)
Definition: Type.cpp:2029
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:35
unsigned size() const
Determine the number of type parameters in this list.
Definition: DeclObjC.h:653
bool isSpecialized() const
Determine whether this object type is "specialized", meaning that it has type arguments.
Definition: Type.cpp:571
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1521
bool isObjCRetainableType() const
Definition: Type.cpp:3704
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:3817
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:25
bool isUnionType() const
Definition: Type.cpp:391
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs, typeofs, etc., as well as any qualifiers.
Definition: Type.cpp:341
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
bool isVoidType() const
Definition: Type.h:5546
The collection of all-type qualifiers we support.
Definition: Type.h:116
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2666
bool isTemplateVariadic() const
Determines whether this function prototype contains a parameter pack at the end.
Definition: Type.cpp:2808
unsigned getNumParams() const
Definition: Type.h:3160
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3166
QualType getElementType() const
Definition: Type.h:2700
One of these records is kept for each identifier that is lexed.
unsigned getIndexTypeCVRQualifiers() const
Definition: Type.h:2465
bool isScalarType() const
Definition: Type.h:5581
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Definition: Type.cpp:3175
TagDecl * getAsTagDecl() const
Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...
Definition: Type.cpp:1526
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4381
bool hasAttr() const
Definition: DeclBase.h:498
Represents a class type in Objective C.
Definition: Type.h:4557
Expr * getSizeExpr() const
Definition: Type.h:2591
IdentifierInfo * getIdentifier() const
Definition: Type.cpp:3064
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1766
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:91
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3165
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
Definition: Type.cpp:3674
bool isSugared() const
Returns whether this type directly provides sugar.
Definition: Type.cpp:2889
bool isReferenceType() const
Definition: Type.h:5314
bool isStructureOrClassType() const
Definition: Type.cpp:378
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:2788
bool isClass() const
Definition: Decl.h:2855
An operation on a type.
Definition: TypeVisitor.h:65
NoexceptResult
Result type of getNoexceptSpec().
Definition: Type.h:3211
NameKind getKind() const
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchers.h:259
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
Definition: Type.cpp:2965
bool isChar32Type() const
Definition: Type.cpp:1672
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that that type refers to...
Definition: Type.cpp:1507
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:450
static unsigned getNumAddressingBits(ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
Definition: Type.cpp:77
Linkage getLinkage() const
Definition: Visibility.h:79
bool isSugared() const
Returns whether this type directly provides sugar.
Definition: Type.cpp:2917
QualType desugar() const
Definition: Type.cpp:2877
Values of this type can be null.
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
Definition: Type.cpp:1633
bool hasNonFastQualifiers() const
Return true if the set contains any qualifiers which require an ExtQuals node to be allocated...
Definition: Type.h:350
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:4076
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3078
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2351
param_type_range param_types() const
Definition: Type.h:3278
QualType getParenType(QualType NamedType) const
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:580
const LangOptions & getLangOpts() const
Definition: ASTContext.h:596
A convenient class for passing around template argument information.
Definition: TemplateBase.h:517
LinkageInfo getLinkageAndVisibility() const
Determine the linkage and visibility of this type.
Definition: Type.cpp:3467
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:4612
QualType getReturnType() const
Definition: Type.h:2977
The "struct" keyword introduces the elaborated-type-specifier.
Definition: Type.h:4191
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
Definition: Type.cpp:2372
Whether values of this type can be null is (explicitly) unspecified.
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:3723
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
Expr * getNoexceptExpr() const
Definition: Type.h:3225
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:146
RecordDecl * getDecl() const
Definition: Type.h:3553
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:4800
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition: Type.cpp:1740
const ObjCObjectType * getAsObjCInterfaceType() const
Definition: Type.cpp:1492
Values of this type can never be null.
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
static TagDecl * getInterestingTagDecl(TagDecl *decl)
Definition: Type.cpp:2941
TypeClass getTypeClass() const
Definition: Type.h:1501
unsigned Half
When true, print the half-precision floating-point type as 'half' instead of '__fp16'.
bool isStructureType() const
Definition: Type.cpp:363
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:1728
bool isObjCIndependentClassType() const
Definition: Type.cpp:3699
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1886
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
Represents an ObjC class declaration.
Definition: DeclObjC.h:853
bool empty() const
Definition: Type.h:359
detail::InMemoryDirectory::const_iterator I
QualType getCanonicalTypeInternal() const
Definition: Type.h:1973
TagType(TypeClass TC, const TagDecl *D, QualType can)
Definition: Type.cpp:2934
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:2686
This object can be modified without requiring retains or releases.
Definition: Type.h:137
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:3893
bool isLinkageValid() const
True if the computed linkage is valid.
Definition: Type.cpp:3459
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type...
Definition: Type.h:5692
EnumDecl * getDecl() const
Definition: Type.h:3576
AnnotatingParser & P
Represents a K&R-style 'int foo()' function, which has no information available about its arguments...
Definition: Type.h:3007
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5003
static void ensure(const Type *T)
Definition: Type.cpp:3250
ExtInfo getExtInfo() const
Definition: Type.h:2986
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type...
Definition: Type.h:5715
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
CXXRecordDecl * getMostRecentDecl()
Definition: DeclCXX.h:666
Optional< ArrayRef< QualType > > getObjCSubstitutions(const DeclContext *dc) const
Retrieve the set of substitutions required when accessing a member of the Objective-C receiver type t...
Definition: Type.cpp:1277
QualType getParamType(unsigned i) const
Definition: Type.h:3161
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3041
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3193
static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword)
Definition: Type.cpp:2425
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:980
param_type_iterator param_type_begin() const
Definition: Type.h:3281
ArraySizeModifier
Capture whether this is a normal array (e.g.
Definition: Type.h:2430
ASTContext * Context
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:188
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
ID
Defines the set of possible language-specific address spaces.
Definition: AddressSpaces.h:27
QualType desugar() const
Remove a single level of sugar.
Definition: Type.cpp:2919
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl...
bool hasSizedVLAType() const
Whether this type involves a variable-length array type with a definite size.
Definition: Type.cpp:3746
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1793
bool isObjCInertUnsafeUnretainedType() const
Was this type written with the special inert-in-MRC __unsafe_unretained qualifier?
Definition: Type.cpp:519
bool isKindOfType() const
Whether this is a "__kindof" type.
Definition: Type.h:4910
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1716
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:5097
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:155
QualType getSuperClassType() const
Retrieve the type of the superclass of this object type.
Definition: Type.h:4699
QualType getPointeeType() const
Definition: Type.h:2268
Expr - This represents one expression.
Definition: Expr.h:104
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition: Type.h:4202
static unsigned getMaxSizeBits(ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
Definition: Type.cpp:112
bool isAnyComplexType() const
Definition: Type.h:5368
bool isStruct() const
Definition: Decl.h:2853
QualType getLocallyUnqualifiedSingleStepDesugaredType() const
Pull a single level of sugar off of this locally-unqualified type.
Definition: Type.cpp:224
ASTContext & getParentASTContext() const
Definition: DeclBase.h:1229
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:4189
ObjCObjectType(QualType Canonical, QualType Base, ArrayRef< QualType > typeArgs, ArrayRef< ObjCProtocolDecl * > protocols, bool isKindOf)
Definition: Type.cpp:535
static LinkageInfo computeLinkageInfo(QualType T)
Definition: Type.cpp:3455
ObjCSubstitutionContext
The kind of type we are substituting Objective-C type arguments into.
Definition: Type.h:548
Expr * getUnderlyingExpr() const
Definition: Type.h:3391
bool isVariableArrayType() const
Definition: Type.h:5353
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3169
DeclContext * getDeclContext()
Definition: DeclBase.h:393
bool isFloatingType() const
Definition: Type.cpp:1777
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3481
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:2385
struct ExtInfo * ExtInfo
Definition: CGCleanup.h:264
Represents a C++ template name within the type system.
Definition: TemplateName.h:175
Represents the type decltype(expr) (C++11).
Definition: Type.h:3449
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
Definition: Type.h:869
There is no noexcept specifier.
Definition: Type.h:3212
bool isCXX11PODType(ASTContext &Context) const
Return true if this is a POD type according to the more relaxed rules of the C++11 standard...
Definition: Type.cpp:2252
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:518
Kind getAttrKind() const
Definition: Type.h:3661
static Optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
Definition: Type.cpp:3624
const ObjCObjectPointerType * stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const
Strip off the Objective-C "kindof" type and (with it) any protocol qualifiers.
Definition: Type.cpp:644
QualType stripObjCKindOfType(const ASTContext &ctx) const
Strip Objective-C "__kindof" types from the given type.
Definition: Type.cpp:1253
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1751
bool isFunctionOrMethod() const
Definition: DeclBase.h:1249
Qualifiers Quals
The local qualifiers.
Definition: Type.h:523
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
Definition: Type.h:4899
#define TRIVIAL_TYPE_CLASS(Class)
Definition: Type.cpp:679
ScalarTypeKind
Definition: Type.h:1735
QualType withFastQualifiers(unsigned TQs) const
Definition: Type.h:784
A helper class for Type nodes having an ElaboratedTypeKeyword.
Definition: Type.h:4211
const IdentifierInfo * getBaseTypeIdentifier() const
Retrieves a pointer to the name of the base type.
Definition: Type.cpp:47
Represents a GCC generic vector type.
Definition: Type.h:2724
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2334
class LLVM_ALIGNAS(8) TemplateSpecializationType unsigned NumArgs
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:3988
Linkage getLinkageInternal() const
Determine what kind of linkage this entity has.
Definition: Decl.cpp:1027
QualType getElementType() const
Definition: Type.h:2748
bool isStrictSupersetOf(Qualifiers Other) const
Determine whether this set of qualifiers is a strict superset of another set of qualifiers, not considering qualifier compatibility.
Definition: Type.cpp:32
The result type of a method or function.
bool isComplexIntegerType() const
Definition: Type.cpp:403
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type...
Definition: Decl.h:2874
IdentifierInfo * getNSObjectName()
Retrieve the identifier 'NSObject'.
Definition: ASTContext.h:1444
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition: Type.cpp:1756
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:3838
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:228
static LinkageInfo external()
Definition: Visibility.h:66
bool hasObjCLifetime() const
Definition: Type.h:289
QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const
Strip off the Objective-C "kindof" type and (with it) any protocol qualifiers.
Definition: Type.cpp:624
IdentifierInfo * getNSCopyingName()
Retrieve the identifier 'NSCopying'.
Definition: ASTContext.h:1453
bool hasUnnamedOrLocalType() const
Whether this type is or contains a local or unnamed type.
Definition: Type.cpp:3377
bool isNothrow(const ASTContext &Ctx, bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
Definition: Type.cpp:2783
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:3832
unsigned Bool
Whether we can use 'bool' rather than '_Bool', even if the language doesn't actually have 'bool' (bec...
CXXRecordDecl * getMostRecentCXXRecordDecl() const
Definition: Type.cpp:3787
A template template parameter pack that has been substituted for a template template argument pack...
Definition: TemplateName.h:204
There is no lifetime qualification on this type.
Definition: Type.h:133
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:236
#define false
Definition: stdbool.h:33
The "struct" keyword.
Definition: Type.h:4176
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:144
Kind
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3053
bool isInterface() const
Definition: Decl.h:2854
Encodes a location in the source.
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
Definition: Type.cpp:1593
Sugar for parentheses used when specifying types.
Definition: Type.h:2116
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3570
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5089
bool isQualifier() const
Does this attribute behave like a type qualifier?
Definition: Type.cpp:2969
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:4766
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition: Type.cpp:397
bool isConstant(ASTContext &Ctx) const
Definition: Type.h:712
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2644
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6.7.5p3.
Definition: Type.cpp:1876
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:311
VectorKind getVectorKind() const
Definition: Type.h:2757
bool qual_empty() const
Definition: Type.h:4950
bool isObjCClassOrClassKindOfType() const
Whether the type is Objective-C 'Class' or a __kindof type of an Class type, e.g., __kindof Class <NSCopying>.
Definition: Type.cpp:496
const TemplateArgument * getArgBuffer() const
Definition: Type.h:4395
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
QualType getIncompleteArrayType(QualType EltTy, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type...
The noexcept specifier evaluates to true.
Definition: Type.h:3216
bool isObjCBoxableRecordType() const
Definition: Type.cpp:368
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
Definition: Type.cpp:191
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
Definition: Type.h:4095
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:1931
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
void Profile(llvm::FoldingSetNodeID &ID)
Definition: TemplateName.h:293
SplitQualType getSplitDesugaredType() const
Definition: Type.h:873
bool hasDependentExceptionSpec() const
Return whether this function has a dependent exception spec.
Definition: Type.cpp:2747
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:5640
bool isSpecializedAsWritten() const
Determine whether this object type was written with type arguments.
Definition: Type.h:4641
TypedefNameDecl * getDecl() const
Definition: Type.h:3375
unsigned getNumProtocols() const
Return the number of qualifying protocols in this interface type, or 0 if there are none...
Definition: Type.h:4674
bool isObjCQualifiedClassType() const
True if this is equivalent to 'Class.
Definition: Type.h:4905
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:164
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5706
NoexceptResult getNoexceptSpec(const ASTContext &Ctx) const
Get the meaning of the noexcept spec on this function, if any.
Definition: Type.cpp:2760
qual_iterator qual_begin() const
Definition: Type.h:4667
QualType getAttributedType(AttributedType::Kind attrKind, QualType modifiedType, QualType equivalentType)
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent) const
C++11 deduced auto type.
bool isVectorType() const
Definition: Type.h:5371
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2314
Assigning into this object requires a lifetime extension.
Definition: Type.h:150
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5159
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
Definition: Type.cpp:2410
TypeOfExprType(Expr *E, QualType can=QualType())
Definition: Type.cpp:2881
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2231
QualType getPointeeType() const
Definition: Type.h:2161
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Represents a pack expansion of types.
Definition: Type.h:4471
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were written.
Definition: Type.h:4658
Defines various enumerations that describe declaration and type specifiers.
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments of this object type (semantically).
Definition: Type.cpp:589
const char * getTypeClassName() const
Definition: Type.cpp:2503
Linkage minLinkage(Linkage L1, Linkage L2)
Compute the minimum linkage given two linkages.
Definition: Linkage.h:96
QualType getType() const
Definition: Expr.h:125
Represents a template argument.
Definition: TemplateBase.h:40
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2195
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:238
TagTypeKind
The kind of a tag type.
Definition: Type.h:4174
CanQualType ObjCBuiltinIdTy
Definition: ASTContext.h:899
static const Type * getElementType(const Expr *BaseExpr)
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
not evaluated yet, for special member function
A qualifier set is used to build a set of qualifiers.
Definition: Type.h:5055
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1121
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type. ...
Definition: Type.cpp:1862
void setContainsUnexpandedParameterPack(bool PP=true)
Definition: Type.h:1496
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:331
static CachedProperties get(QualType T)
Definition: Type.cpp:3240
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1723
bool isKindOfType() const
Whether this ia a "__kindof" type (semantically).
Definition: Type.cpp:607
QualType IgnoreParens() const
Returns the specified type after dropping any outer-level parentheses.
Definition: Type.h:888
bool isCallingConv() const
Definition: Type.cpp:3023
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition: Type.cpp:1440
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
Definition: Type.cpp:2215
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.cpp:3205
The "union" keyword introduces the elaborated-type-specifier.
Definition: Type.h:4195
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition: Type.h:5062
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2710
The "class" keyword introduces the elaborated-type-specifier.
Definition: Type.h:4197
static const T * getAsSugar(const Type *Cur)
This will check for a T (which should be a Type which can act as sugar, such as a TypedefType) by rem...
Definition: Type.cpp:308
EnumDecl - Represents an enum.
Definition: Decl.h:2930
detail::InMemoryDirectory::const_iterator E
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2369
QualType getModifiedType() const
Definition: Type.h:3665
UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind, QualType CanonicalTy)
Definition: Type.cpp:2950
void addConsistentQualifiers(Qualifiers qs)
Add the qualifiers from the given set to this set, given that they don't conflict.
Definition: Type.h:397
const RecordType * getAsStructureType() const
Definition: Type.cpp:431
bool isWideCharType() const
Definition: Type.cpp:1659
Represents a pointer to an Objective C object.
Definition: Type.h:4821
Pointer to a block type.
Definition: Type.h:2254
FunctionTypeBitfields FunctionTypeBits
Definition: Type.h:1452
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3544
Complex values, per C99 6.2.5p11.
Definition: Type.h:2087
bool isTriviallyCopyableType(ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2092
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:421
llvm::Optional< NullabilityKind > getImmediateNullability() const
Definition: Type.cpp:3614
bool isObjCNSObjectType() const
Definition: Type.cpp:3694
bool TypeAlias
Whether this template specialization type is a substituted type alias.
Definition: Type.h:4005
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5675
QualType getCanonicalType() const
Definition: Type.h:5128
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
Definition: DeclObjC.cpp:260
bool isSpecifierType() const
Returns true if this type can be represented by some set of type specifiers.
Definition: Type.cpp:2346
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface...
Definition: Type.h:4876
const ObjCObjectType * getAsObjCQualifiedInterfaceType() const
Definition: Type.cpp:1458
VectorTypeBitfields VectorTypeBits
Definition: Type.h:1456
ExtVectorType - Extended vector type.
Definition: Type.h:2784
QualType getInnerType() const
Definition: Type.h:2130
The noexcept specifier evaluates to false.
Definition: Type.h:3215
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2287
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1522
unsigned getAddressSpace() const
Definition: Type.h:316
The template argument is a type.
Definition: TemplateBase.h:48
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
The "class" keyword.
Definition: Type.h:4182
GC getObjCGCAttr() const
Definition: Type.h:269
bool isMSTypeSpec() const
Definition: Type.cpp:3011
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3055
void merge(LinkageInfo other)
Merge both linkage and visibility.
Definition: Visibility.h:128
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3372
The type-property cache.
Definition: Type.cpp:3238
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
const Type * getClass() const
Definition: Type.h:2402
TypeBitfields TypeBits
Definition: Type.h:1447
Reading or writing from this object requires a barrier call.
Definition: Type.h:147
bool isPODType(ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:1961
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:3598
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
bool hasAddressSpace() const
Definition: Type.h:315
bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const
Definition: Type.cpp:3635
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:335
bool isObjCClassType() const
True if this is equivalent to the 'Class' type, i.e.
Definition: Type.h:4888
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type...
bool isCARCBridgableType() const
Determine whether the given type T is a "bridgeable" C type.
Definition: Type.cpp:3737
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5169
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
bool isObjCObjectPointerType() const
Definition: Type.h:5377
Represents a C array with an unspecified size.
Definition: Type.h:2530
static bool anyDependentTemplateArguments(const TemplateArgumentLoc *Args, unsigned NumArgs, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
The parameter type of a method or function.
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2459
The "enum" keyword.
Definition: Type.h:4184
qual_range quals() const
Definition: Type.h:4943
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3416
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorType::VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:615
This class is used for builtin types like 'int'.
Definition: Type.h:2011
bool isArrayType() const
Definition: Type.h:5344
Defines the clang::TargetInfo interface.
QualType getPointeeTypeAsWritten() const
Definition: Type.h:2307
TagDecl * getDecl() const
Definition: Type.cpp:2961
bool isObjCIndirectLifetimeType() const
Definition: Type.cpp:3709
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:772
QualType desugar() const
Definition: Type.h:4093
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
QualType getElementType() const
Definition: Type.h:2458
static StringRef getNameForCallConv(CallingConv CC)
Definition: Type.cpp:2643
#define true
Definition: stdbool.h:32
bool isObjCARCBridgableType() const
Determine whether the given type T is a "bridgable" Objective-C type, which is either an Objective-C ...
Definition: Type.cpp:3732
bool isInterfaceType() const
Definition: Type.cpp:373
QualType desugar() const
Remove a single level of sugar.
Definition: Type.cpp:2893
A trivial tuple used to represent a source range.
VectorType(QualType vecType, unsigned nElements, QualType canonType, VectorKind vecKind)
Definition: Type.cpp:172
NamedDecl - This represents a decl with a name.
Definition: Decl.h:145
StringRef getName(const PrintingPolicy &Policy) const
Definition: Type.cpp:2513
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2575
bool isObjCIdOrObjectKindOfType(const ASTContext &ctx, const ObjCObjectType *&bound) const
Whether the type is Objective-C 'id' or a __kindof type of an object type, e.g., __kindof NSView * or...
Definition: Type.cpp:470
bool isArithmeticType() const
Definition: Type.cpp:1808
bool isClassType() const
Definition: Type.cpp:358
No keyword precedes the qualified type name.
Definition: Type.h:4204
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1700
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5148
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g., it is an signed integer type or a vector.
Definition: Type.cpp:1730
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:642
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1499
QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced, QualType Replacement) const
Retrieve a substitution-result type.
bool isObjCIdType() const
True if this is equivalent to the 'id' type, i.e.
Definition: Type.h:4882
The noexcept specifier is dependent.
Definition: Type.h:3214
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3476
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
Definition: Type.h:882
QualType getSuperClassType() const
Retrieve the type of the superclass of this object pointer type.
Definition: Type.cpp:1449
The "__interface" keyword introduces the elaborated-type-specifier.
Definition: Type.h:4193
ArrayRef< QualType > exceptions() const
Definition: Type.h:3290
bool isBeingDefined() const
isBeingDefined - Return true if this decl is currently being defined.
Definition: Decl.h:2799
bool isIntegralType(ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1619
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2480
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3087
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
const ObjCObjectType * getSuperClassType() const
Retrieve the superclass type.
Definition: DeclObjC.h:1232
bool isObjCQualifiedInterfaceType() const
Definition: Type.cpp:1468
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:4084
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
Definition: Type.cpp:1823
A single template declaration.
Definition: TemplateName.h:189
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:5568
const ObjCObjectPointerType * getAsObjCQualifiedIdType() const
Definition: Type.cpp:1472
bool isPointerType() const
Definition: Type.h:5305