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