clang  8.0.0svn
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/Type.h"
15 #include "Linkage.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/Attr.h"
18 #include "clang/AST/CharUnits.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/DeclBase.h"
21 #include "clang/AST/DeclCXX.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Expr.h"
27 #include "clang/AST/TemplateBase.h"
28 #include "clang/AST/TemplateName.h"
29 #include "clang/AST/TypeVisitor.h"
33 #include "clang/Basic/LLVM.h"
35 #include "clang/Basic/Linkage.h"
36 #include "clang/Basic/Specifiers.h"
38 #include "clang/Basic/TargetInfo.h"
39 #include "clang/Basic/Visibility.h"
40 #include "llvm/ADT/APInt.h"
41 #include "llvm/ADT/APSInt.h"
42 #include "llvm/ADT/ArrayRef.h"
43 #include "llvm/ADT/FoldingSet.h"
44 #include "llvm/ADT/None.h"
45 #include "llvm/ADT/SmallVector.h"
46 #include "llvm/Support/Casting.h"
47 #include "llvm/Support/ErrorHandling.h"
48 #include "llvm/Support/MathExtras.h"
49 #include <algorithm>
50 #include <cassert>
51 #include <cstdint>
52 #include <cstring>
53 
54 using namespace clang;
55 
57  return (*this != Other) &&
58  // CVR qualifiers superset
59  (((Mask & CVRMask) | (Other.Mask & CVRMask)) == (Mask & CVRMask)) &&
60  // ObjC GC qualifiers superset
61  ((getObjCGCAttr() == Other.getObjCGCAttr()) ||
62  (hasObjCGCAttr() && !Other.hasObjCGCAttr())) &&
63  // Address space superset.
64  ((getAddressSpace() == Other.getAddressSpace()) ||
65  (hasAddressSpace()&& !Other.hasAddressSpace())) &&
66  // Lifetime qualifier superset.
67  ((getObjCLifetime() == Other.getObjCLifetime()) ||
68  (hasObjCLifetime() && !Other.hasObjCLifetime()));
69 }
70 
72  const Type* ty = getTypePtr();
73  NamedDecl *ND = nullptr;
74  if (ty->isPointerType() || ty->isReferenceType())
76  else if (ty->isRecordType())
77  ND = ty->getAs<RecordType>()->getDecl();
78  else if (ty->isEnumeralType())
79  ND = ty->getAs<EnumType>()->getDecl();
80  else if (ty->getTypeClass() == Type::Typedef)
81  ND = ty->getAs<TypedefType>()->getDecl();
82  else if (ty->isArrayType())
83  return ty->castAsArrayTypeUnsafe()->
84  getElementType().getBaseTypeIdentifier();
85 
86  if (ND)
87  return ND->getIdentifier();
88  return nullptr;
89 }
90 
92  const auto *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl();
93  return ClassDecl && ClassDecl->mayBeDynamicClass();
94 }
95 
97  const auto *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl();
98  return !ClassDecl || ClassDecl->mayBeNonDynamicClass();
99 }
100 
101 bool QualType::isConstant(QualType T, const ASTContext &Ctx) {
102  if (T.isConstQualified())
103  return true;
104 
105  if (const ArrayType *AT = Ctx.getAsArrayType(T))
106  return AT->getElementType().isConstant(Ctx);
107 
109 }
110 
112  QualType ElementType,
113  const llvm::APInt &NumElements) {
114  uint64_t ElementSize = Context.getTypeSizeInChars(ElementType).getQuantity();
115 
116  // Fast path the common cases so we can avoid the conservative computation
117  // below, which in common cases allocates "large" APSInt values, which are
118  // slow.
119 
120  // If the element size is a power of 2, we can directly compute the additional
121  // number of addressing bits beyond those required for the element count.
122  if (llvm::isPowerOf2_64(ElementSize)) {
123  return NumElements.getActiveBits() + llvm::Log2_64(ElementSize);
124  }
125 
126  // If both the element count and element size fit in 32-bits, we can do the
127  // computation directly in 64-bits.
128  if ((ElementSize >> 32) == 0 && NumElements.getBitWidth() <= 64 &&
129  (NumElements.getZExtValue() >> 32) == 0) {
130  uint64_t TotalSize = NumElements.getZExtValue() * ElementSize;
131  return 64 - llvm::countLeadingZeros(TotalSize);
132  }
133 
134  // Otherwise, use APSInt to handle arbitrary sized values.
135  llvm::APSInt SizeExtended(NumElements, true);
136  unsigned SizeTypeBits = Context.getTypeSize(Context.getSizeType());
137  SizeExtended = SizeExtended.extend(std::max(SizeTypeBits,
138  SizeExtended.getBitWidth()) * 2);
139 
140  llvm::APSInt TotalSize(llvm::APInt(SizeExtended.getBitWidth(), ElementSize));
141  TotalSize *= SizeExtended;
142 
143  return TotalSize.getActiveBits();
144 }
145 
147  unsigned Bits = Context.getTypeSize(Context.getSizeType());
148 
149  // Limit the number of bits in size_t so that maximal bit size fits 64 bit
150  // integer (see PR8256). We can do this as currently there is no hardware
151  // that supports full 64-bit virtual space.
152  if (Bits > 61)
153  Bits = 61;
154 
155  return Bits;
156 }
157 
158 DependentSizedArrayType::DependentSizedArrayType(const ASTContext &Context,
159  QualType et, QualType can,
160  Expr *e, ArraySizeModifier sm,
161  unsigned tq,
162  SourceRange brackets)
163  : ArrayType(DependentSizedArray, et, can, sm, tq,
165  (e && e->containsUnexpandedParameterPack()))),
166  Context(Context), SizeExpr((Stmt*) e), Brackets(brackets) {}
167 
168 void DependentSizedArrayType::Profile(llvm::FoldingSetNodeID &ID,
169  const ASTContext &Context,
170  QualType ET,
171  ArraySizeModifier SizeMod,
172  unsigned TypeQuals,
173  Expr *E) {
174  ID.AddPointer(ET.getAsOpaquePtr());
175  ID.AddInteger(SizeMod);
176  ID.AddInteger(TypeQuals);
177  E->Profile(ID, Context, true);
178 }
179 
180 DependentVectorType::DependentVectorType(
181  const ASTContext &Context, QualType ElementType, QualType CanonType,
182  Expr *SizeExpr, SourceLocation Loc, VectorType::VectorKind VecKind)
183  : Type(DependentVector, CanonType, /*Dependent=*/true,
184  /*InstantiationDependent=*/true,
185  ElementType->isVariablyModifiedType(),
186  ElementType->containsUnexpandedParameterPack() ||
187  (SizeExpr && SizeExpr->containsUnexpandedParameterPack())),
188  Context(Context), ElementType(ElementType), SizeExpr(SizeExpr), Loc(Loc) {
189  VectorTypeBits.VecKind = VecKind;
190 }
191 
192 void DependentVectorType::Profile(llvm::FoldingSetNodeID &ID,
193  const ASTContext &Context,
194  QualType ElementType, const Expr *SizeExpr,
195  VectorType::VectorKind VecKind) {
196  ID.AddPointer(ElementType.getAsOpaquePtr());
197  ID.AddInteger(VecKind);
198  SizeExpr->Profile(ID, Context, true);
199 }
200 
201 DependentSizedExtVectorType::DependentSizedExtVectorType(const
202  ASTContext &Context,
203  QualType ElementType,
204  QualType can,
205  Expr *SizeExpr,
206  SourceLocation loc)
207  : Type(DependentSizedExtVector, can, /*Dependent=*/true,
208  /*InstantiationDependent=*/true,
209  ElementType->isVariablyModifiedType(),
210  (ElementType->containsUnexpandedParameterPack() ||
211  (SizeExpr && SizeExpr->containsUnexpandedParameterPack()))),
212  Context(Context), SizeExpr(SizeExpr), ElementType(ElementType),
213  loc(loc) {}
214 
215 void
216 DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID,
217  const ASTContext &Context,
218  QualType ElementType, Expr *SizeExpr) {
219  ID.AddPointer(ElementType.getAsOpaquePtr());
220  SizeExpr->Profile(ID, Context, true);
221 }
222 
223 DependentAddressSpaceType::DependentAddressSpaceType(
224  const ASTContext &Context, QualType PointeeType, QualType can,
225  Expr *AddrSpaceExpr, SourceLocation loc)
226  : Type(DependentAddressSpace, can, /*Dependent=*/true,
227  /*InstantiationDependent=*/true,
228  PointeeType->isVariablyModifiedType(),
229  (PointeeType->containsUnexpandedParameterPack() ||
230  (AddrSpaceExpr &&
231  AddrSpaceExpr->containsUnexpandedParameterPack()))),
232  Context(Context), AddrSpaceExpr(AddrSpaceExpr), PointeeType(PointeeType),
233  loc(loc) {}
234 
235 void DependentAddressSpaceType::Profile(llvm::FoldingSetNodeID &ID,
236  const ASTContext &Context,
237  QualType PointeeType,
238  Expr *AddrSpaceExpr) {
239  ID.AddPointer(PointeeType.getAsOpaquePtr());
240  AddrSpaceExpr->Profile(ID, Context, true);
241 }
242 
243 VectorType::VectorType(QualType vecType, unsigned nElements, QualType canonType,
244  VectorKind vecKind)
245  : VectorType(Vector, vecType, nElements, canonType, vecKind) {}
246 
247 VectorType::VectorType(TypeClass tc, QualType vecType, unsigned nElements,
248  QualType canonType, VectorKind vecKind)
249  : Type(tc, canonType, vecType->isDependentType(),
250  vecType->isInstantiationDependentType(),
251  vecType->isVariablyModifiedType(),
253  ElementType(vecType) {
254  VectorTypeBits.VecKind = vecKind;
255  VectorTypeBits.NumElements = nElements;
256 }
257 
258 /// getArrayElementTypeNoTypeQual - If this is an array type, return the
259 /// element type of the array, potentially with type qualifiers missing.
260 /// This method should never be used when type qualifiers are meaningful.
262  // If this is directly an array type, return it.
263  if (const auto *ATy = dyn_cast<ArrayType>(this))
264  return ATy->getElementType().getTypePtr();
265 
266  // If the canonical form of this type isn't the right kind, reject it.
267  if (!isa<ArrayType>(CanonicalType))
268  return nullptr;
269 
270  // If this is a typedef for an array type, strip the typedef off without
271  // losing all typedef information.
272  return cast<ArrayType>(getUnqualifiedDesugaredType())
274 }
275 
276 /// getDesugaredType - Return the specified type with any "sugar" removed from
277 /// the type. This takes off typedefs, typeof's etc. If the outer level of
278 /// the type is already concrete, it returns it unmodified. This is similar
279 /// to getting the canonical type, but it doesn't remove *all* typedefs. For
280 /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
281 /// concrete.
283  SplitQualType split = getSplitDesugaredType(T);
284  return Context.getQualifiedType(split.Ty, split.Quals);
285 }
286 
287 QualType QualType::getSingleStepDesugaredTypeImpl(QualType type,
288  const ASTContext &Context) {
289  SplitQualType split = type.split();
291  return Context.getQualifiedType(desugar, split.Quals);
292 }
293 
295  switch (getTypeClass()) {
296 #define ABSTRACT_TYPE(Class, Parent)
297 #define TYPE(Class, Parent) \
298  case Type::Class: { \
299  const auto *ty = cast<Class##Type>(this); \
300  if (!ty->isSugared()) return QualType(ty, 0); \
301  return ty->desugar(); \
302  }
303 #include "clang/AST/TypeNodes.def"
304  }
305  llvm_unreachable("bad type kind!");
306 }
307 
310 
311  QualType Cur = T;
312  while (true) {
313  const Type *CurTy = Qs.strip(Cur);
314  switch (CurTy->getTypeClass()) {
315 #define ABSTRACT_TYPE(Class, Parent)
316 #define TYPE(Class, Parent) \
317  case Type::Class: { \
318  const auto *Ty = cast<Class##Type>(CurTy); \
319  if (!Ty->isSugared()) \
320  return SplitQualType(Ty, Qs); \
321  Cur = Ty->desugar(); \
322  break; \
323  }
324 #include "clang/AST/TypeNodes.def"
325  }
326  }
327 }
328 
329 SplitQualType QualType::getSplitUnqualifiedTypeImpl(QualType type) {
330  SplitQualType split = type.split();
331 
332  // All the qualifiers we've seen so far.
333  Qualifiers quals = split.Quals;
334 
335  // The last type node we saw with any nodes inside it.
336  const Type *lastTypeWithQuals = split.Ty;
337 
338  while (true) {
339  QualType next;
340 
341  // Do a single-step desugar, aborting the loop if the type isn't
342  // sugared.
343  switch (split.Ty->getTypeClass()) {
344 #define ABSTRACT_TYPE(Class, Parent)
345 #define TYPE(Class, Parent) \
346  case Type::Class: { \
347  const auto *ty = cast<Class##Type>(split.Ty); \
348  if (!ty->isSugared()) goto done; \
349  next = ty->desugar(); \
350  break; \
351  }
352 #include "clang/AST/TypeNodes.def"
353  }
354 
355  // Otherwise, split the underlying type. If that yields qualifiers,
356  // update the information.
357  split = next.split();
358  if (!split.Quals.empty()) {
359  lastTypeWithQuals = split.Ty;
360  quals.addConsistentQualifiers(split.Quals);
361  }
362  }
363 
364  done:
365  return SplitQualType(lastTypeWithQuals, quals);
366 }
367 
369  // FIXME: this seems inherently un-qualifiers-safe.
370  while (const auto *PT = T->getAs<ParenType>())
371  T = PT->getInnerType();
372  return T;
373 }
374 
375 /// This will check for a T (which should be a Type which can act as
376 /// sugar, such as a TypedefType) by removing any existing sugar until it
377 /// reaches a T or a non-sugared type.
378 template<typename T> static const T *getAsSugar(const Type *Cur) {
379  while (true) {
380  if (const auto *Sugar = dyn_cast<T>(Cur))
381  return Sugar;
382  switch (Cur->getTypeClass()) {
383 #define ABSTRACT_TYPE(Class, Parent)
384 #define TYPE(Class, Parent) \
385  case Type::Class: { \
386  const auto *Ty = cast<Class##Type>(Cur); \
387  if (!Ty->isSugared()) return 0; \
388  Cur = Ty->desugar().getTypePtr(); \
389  break; \
390  }
391 #include "clang/AST/TypeNodes.def"
392  }
393  }
394 }
395 
396 template <> const TypedefType *Type::getAs() const {
397  return getAsSugar<TypedefType>(this);
398 }
399 
400 template <> const TemplateSpecializationType *Type::getAs() const {
401  return getAsSugar<TemplateSpecializationType>(this);
402 }
403 
404 template <> const AttributedType *Type::getAs() const {
405  return getAsSugar<AttributedType>(this);
406 }
407 
408 /// getUnqualifiedDesugaredType - Pull any qualifiers and syntactic
409 /// sugar off the given type. This should produce an object of the
410 /// same dynamic type as the canonical type.
412  const Type *Cur = this;
413 
414  while (true) {
415  switch (Cur->getTypeClass()) {
416 #define ABSTRACT_TYPE(Class, Parent)
417 #define TYPE(Class, Parent) \
418  case Class: { \
419  const auto *Ty = cast<Class##Type>(Cur); \
420  if (!Ty->isSugared()) return Cur; \
421  Cur = Ty->desugar().getTypePtr(); \
422  break; \
423  }
424 #include "clang/AST/TypeNodes.def"
425  }
426  }
427 }
428 
429 bool Type::isClassType() const {
430  if (const auto *RT = getAs<RecordType>())
431  return RT->getDecl()->isClass();
432  return false;
433 }
434 
435 bool Type::isStructureType() const {
436  if (const auto *RT = getAs<RecordType>())
437  return RT->getDecl()->isStruct();
438  return false;
439 }
440 
442  if (const auto *RT = getAs<RecordType>())
443  return RT->getDecl()->hasAttr<ObjCBoxableAttr>();
444  return false;
445 }
446 
447 bool Type::isInterfaceType() const {
448  if (const auto *RT = getAs<RecordType>())
449  return RT->getDecl()->isInterface();
450  return false;
451 }
452 
454  if (const auto *RT = getAs<RecordType>()) {
455  RecordDecl *RD = RT->getDecl();
456  return RD->isStruct() || RD->isClass() || RD->isInterface();
457  }
458  return false;
459 }
460 
462  if (const auto *PT = getAs<PointerType>())
463  return PT->getPointeeType()->isVoidType();
464  return false;
465 }
466 
467 bool Type::isUnionType() const {
468  if (const auto *RT = getAs<RecordType>())
469  return RT->getDecl()->isUnion();
470  return false;
471 }
472 
473 bool Type::isComplexType() const {
474  if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
475  return CT->getElementType()->isFloatingType();
476  return false;
477 }
478 
480  // Check for GCC complex integer extension.
481  return getAsComplexIntegerType();
482 }
483 
485  if (const auto *ET = getAs<EnumType>())
486  return ET->getDecl()->isScoped();
487  return false;
488 }
489 
491  if (const auto *Complex = getAs<ComplexType>())
492  if (Complex->getElementType()->isIntegerType())
493  return Complex;
494  return nullptr;
495 }
496 
498  if (const auto *PT = getAs<PointerType>())
499  return PT->getPointeeType();
500  if (const auto *OPT = getAs<ObjCObjectPointerType>())
501  return OPT->getPointeeType();
502  if (const auto *BPT = getAs<BlockPointerType>())
503  return BPT->getPointeeType();
504  if (const auto *RT = getAs<ReferenceType>())
505  return RT->getPointeeType();
506  if (const auto *MPT = getAs<MemberPointerType>())
507  return MPT->getPointeeType();
508  if (const auto *DT = getAs<DecayedType>())
509  return DT->getPointeeType();
510  return {};
511 }
512 
514  // If this is directly a structure type, return it.
515  if (const auto *RT = dyn_cast<RecordType>(this)) {
516  if (RT->getDecl()->isStruct())
517  return RT;
518  }
519 
520  // If the canonical form of this type isn't the right kind, reject it.
521  if (const auto *RT = dyn_cast<RecordType>(CanonicalType)) {
522  if (!RT->getDecl()->isStruct())
523  return nullptr;
524 
525  // If this is a typedef for a structure type, strip the typedef off without
526  // losing all typedef information.
527  return cast<RecordType>(getUnqualifiedDesugaredType());
528  }
529  return nullptr;
530 }
531 
533  // If this is directly a union type, return it.
534  if (const auto *RT = dyn_cast<RecordType>(this)) {
535  if (RT->getDecl()->isUnion())
536  return RT;
537  }
538 
539  // If the canonical form of this type isn't the right kind, reject it.
540  if (const auto *RT = dyn_cast<RecordType>(CanonicalType)) {
541  if (!RT->getDecl()->isUnion())
542  return nullptr;
543 
544  // If this is a typedef for a union type, strip the typedef off without
545  // losing all typedef information.
546  return cast<RecordType>(getUnqualifiedDesugaredType());
547  }
548 
549  return nullptr;
550 }
551 
553  const ObjCObjectType *&bound) const {
554  bound = nullptr;
555 
556  const auto *OPT = getAs<ObjCObjectPointerType>();
557  if (!OPT)
558  return false;
559 
560  // Easy case: id.
561  if (OPT->isObjCIdType())
562  return true;
563 
564  // If it's not a __kindof type, reject it now.
565  if (!OPT->isKindOfType())
566  return false;
567 
568  // If it's Class or qualified Class, it's not an object type.
569  if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType())
570  return false;
571 
572  // Figure out the type bound for the __kindof type.
573  bound = OPT->getObjectType()->stripObjCKindOfTypeAndQuals(ctx)
574  ->getAs<ObjCObjectType>();
575  return true;
576 }
577 
579  const auto *OPT = getAs<ObjCObjectPointerType>();
580  if (!OPT)
581  return false;
582 
583  // Easy case: Class.
584  if (OPT->isObjCClassType())
585  return true;
586 
587  // If it's not a __kindof type, reject it now.
588  if (!OPT->isKindOfType())
589  return false;
590 
591  // If it's Class or qualified Class, it's a class __kindof type.
592  return OPT->isObjCClassType() || OPT->isObjCQualifiedClassType();
593 }
594 
595 ObjCTypeParamType::ObjCTypeParamType(const ObjCTypeParamDecl *D,
596  QualType can,
598  : Type(ObjCTypeParam, can, can->isDependentType(),
600  can->isVariablyModifiedType(),
601  /*ContainsUnexpandedParameterPack=*/false),
602  OTPDecl(const_cast<ObjCTypeParamDecl*>(D)) {
603  initialize(protocols);
604 }
605 
607  ArrayRef<QualType> typeArgs,
609  bool isKindOf)
610  : Type(ObjCObject, Canonical, Base->isDependentType(),
612  Base->isVariablyModifiedType(),
614  BaseType(Base) {
615  ObjCObjectTypeBits.IsKindOf = isKindOf;
616 
617  ObjCObjectTypeBits.NumTypeArgs = typeArgs.size();
618  assert(getTypeArgsAsWritten().size() == typeArgs.size() &&
619  "bitfield overflow in type argument count");
620  if (!typeArgs.empty())
621  memcpy(getTypeArgStorage(), typeArgs.data(),
622  typeArgs.size() * sizeof(QualType));
623 
624  for (auto typeArg : typeArgs) {
625  if (typeArg->isDependentType())
626  setDependent();
627  else if (typeArg->isInstantiationDependentType())
629 
630  if (typeArg->containsUnexpandedParameterPack())
632  }
633  // Initialize the protocol qualifiers. The protocol storage is known
634  // after we set number of type arguments.
635  initialize(protocols);
636 }
637 
639  // If we have type arguments written here, the type is specialized.
640  if (ObjCObjectTypeBits.NumTypeArgs > 0)
641  return true;
642 
643  // Otherwise, check whether the base type is specialized.
644  if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
645  // Terminate when we reach an interface type.
646  if (isa<ObjCInterfaceType>(objcObject))
647  return false;
648 
649  return objcObject->isSpecialized();
650  }
651 
652  // Not specialized.
653  return false;
654 }
655 
657  // We have type arguments written on this type.
659  return getTypeArgsAsWritten();
660 
661  // Look at the base type, which might have type arguments.
662  if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
663  // Terminate when we reach an interface type.
664  if (isa<ObjCInterfaceType>(objcObject))
665  return {};
666 
667  return objcObject->getTypeArgs();
668  }
669 
670  // No type arguments.
671  return {};
672 }
673 
675  if (isKindOfTypeAsWritten())
676  return true;
677 
678  // Look at the base type, which might have type arguments.
679  if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
680  // Terminate when we reach an interface type.
681  if (isa<ObjCInterfaceType>(objcObject))
682  return false;
683 
684  return objcObject->isKindOfType();
685  }
686 
687  // Not a "__kindof" type.
688  return false;
689 }
690 
692  const ASTContext &ctx) const {
693  if (!isKindOfType() && qual_empty())
694  return QualType(this, 0);
695 
696  // Recursively strip __kindof.
697  SplitQualType splitBaseType = getBaseType().split();
698  QualType baseType(splitBaseType.Ty, 0);
699  if (const auto *baseObj = splitBaseType.Ty->getAs<ObjCObjectType>())
700  baseType = baseObj->stripObjCKindOfTypeAndQuals(ctx);
701 
702  return ctx.getObjCObjectType(ctx.getQualifiedType(baseType,
703  splitBaseType.Quals),
705  /*protocols=*/{},
706  /*isKindOf=*/false);
707 }
708 
710  const ASTContext &ctx) const {
711  if (!isKindOfType() && qual_empty())
712  return this;
713 
714  QualType obj = getObjectType()->stripObjCKindOfTypeAndQuals(ctx);
716 }
717 
718 template<typename F>
719 static QualType simpleTransform(ASTContext &ctx, QualType type, F &&f);
720 
721 namespace {
722 
723 /// Visitor used by simpleTransform() to perform the transformation.
724 template<typename F>
725 struct SimpleTransformVisitor
726  : public TypeVisitor<SimpleTransformVisitor<F>, QualType> {
727  ASTContext &Ctx;
728  F &&TheFunc;
729 
730  QualType recurse(QualType type) {
731  return simpleTransform(Ctx, type, std::move(TheFunc));
732  }
733 
734 public:
735  SimpleTransformVisitor(ASTContext &ctx, F &&f)
736  : Ctx(ctx), TheFunc(std::move(f)) {}
737 
738  // None of the clients of this transformation can occur where
739  // there are dependent types, so skip dependent types.
740 #define TYPE(Class, Base)
741 #define DEPENDENT_TYPE(Class, Base) \
742  QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
743 #include "clang/AST/TypeNodes.def"
744 
745 #define TRIVIAL_TYPE_CLASS(Class) \
746  QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
747 
748  TRIVIAL_TYPE_CLASS(Builtin)
749 
750  QualType VisitComplexType(const ComplexType *T) {
751  QualType elementType = recurse(T->getElementType());
752  if (elementType.isNull())
753  return {};
754 
755  if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
756  return QualType(T, 0);
757 
758  return Ctx.getComplexType(elementType);
759  }
760 
761  QualType VisitPointerType(const PointerType *T) {
762  QualType pointeeType = recurse(T->getPointeeType());
763  if (pointeeType.isNull())
764  return {};
765 
766  if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
767  return QualType(T, 0);
768 
769  return Ctx.getPointerType(pointeeType);
770  }
771 
772  QualType VisitBlockPointerType(const BlockPointerType *T) {
773  QualType pointeeType = recurse(T->getPointeeType());
774  if (pointeeType.isNull())
775  return {};
776 
777  if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
778  return QualType(T, 0);
779 
780  return Ctx.getBlockPointerType(pointeeType);
781  }
782 
783  QualType VisitLValueReferenceType(const LValueReferenceType *T) {
784  QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
785  if (pointeeType.isNull())
786  return {};
787 
788  if (pointeeType.getAsOpaquePtr()
790  return QualType(T, 0);
791 
792  return Ctx.getLValueReferenceType(pointeeType, T->isSpelledAsLValue());
793  }
794 
795  QualType VisitRValueReferenceType(const RValueReferenceType *T) {
796  QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
797  if (pointeeType.isNull())
798  return {};
799 
800  if (pointeeType.getAsOpaquePtr()
802  return QualType(T, 0);
803 
804  return Ctx.getRValueReferenceType(pointeeType);
805  }
806 
807  QualType VisitMemberPointerType(const MemberPointerType *T) {
808  QualType pointeeType = recurse(T->getPointeeType());
809  if (pointeeType.isNull())
810  return {};
811 
812  if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
813  return QualType(T, 0);
814 
815  return Ctx.getMemberPointerType(pointeeType, T->getClass());
816  }
817 
818  QualType VisitConstantArrayType(const ConstantArrayType *T) {
819  QualType elementType = recurse(T->getElementType());
820  if (elementType.isNull())
821  return {};
822 
823  if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
824  return QualType(T, 0);
825 
826  return Ctx.getConstantArrayType(elementType, T->getSize(),
827  T->getSizeModifier(),
829  }
830 
831  QualType VisitVariableArrayType(const VariableArrayType *T) {
832  QualType elementType = recurse(T->getElementType());
833  if (elementType.isNull())
834  return {};
835 
836  if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
837  return QualType(T, 0);
838 
839  return Ctx.getVariableArrayType(elementType, T->getSizeExpr(),
840  T->getSizeModifier(),
842  T->getBracketsRange());
843  }
844 
845  QualType VisitIncompleteArrayType(const IncompleteArrayType *T) {
846  QualType elementType = recurse(T->getElementType());
847  if (elementType.isNull())
848  return {};
849 
850  if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
851  return QualType(T, 0);
852 
853  return Ctx.getIncompleteArrayType(elementType, T->getSizeModifier(),
855  }
856 
857  QualType VisitVectorType(const VectorType *T) {
858  QualType elementType = recurse(T->getElementType());
859  if (elementType.isNull())
860  return {};
861 
862  if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
863  return QualType(T, 0);
864 
865  return Ctx.getVectorType(elementType, T->getNumElements(),
866  T->getVectorKind());
867  }
868 
869  QualType VisitExtVectorType(const ExtVectorType *T) {
870  QualType elementType = recurse(T->getElementType());
871  if (elementType.isNull())
872  return {};
873 
874  if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
875  return QualType(T, 0);
876 
877  return Ctx.getExtVectorType(elementType, T->getNumElements());
878  }
879 
880  QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
881  QualType returnType = recurse(T->getReturnType());
882  if (returnType.isNull())
883  return {};
884 
885  if (returnType.getAsOpaquePtr() == T->getReturnType().getAsOpaquePtr())
886  return QualType(T, 0);
887 
888  return Ctx.getFunctionNoProtoType(returnType, T->getExtInfo());
889  }
890 
891  QualType VisitFunctionProtoType(const FunctionProtoType *T) {
892  QualType returnType = recurse(T->getReturnType());
893  if (returnType.isNull())
894  return {};
895 
896  // Transform parameter types.
897  SmallVector<QualType, 4> paramTypes;
898  bool paramChanged = false;
899  for (auto paramType : T->getParamTypes()) {
900  QualType newParamType = recurse(paramType);
901  if (newParamType.isNull())
902  return {};
903 
904  if (newParamType.getAsOpaquePtr() != paramType.getAsOpaquePtr())
905  paramChanged = true;
906 
907  paramTypes.push_back(newParamType);
908  }
909 
910  // Transform extended info.
912  bool exceptionChanged = false;
913  if (info.ExceptionSpec.Type == EST_Dynamic) {
914  SmallVector<QualType, 4> exceptionTypes;
915  for (auto exceptionType : info.ExceptionSpec.Exceptions) {
916  QualType newExceptionType = recurse(exceptionType);
917  if (newExceptionType.isNull())
918  return {};
919 
920  if (newExceptionType.getAsOpaquePtr() != exceptionType.getAsOpaquePtr())
921  exceptionChanged = true;
922 
923  exceptionTypes.push_back(newExceptionType);
924  }
925 
926  if (exceptionChanged) {
928  llvm::makeArrayRef(exceptionTypes).copy(Ctx);
929  }
930  }
931 
932  if (returnType.getAsOpaquePtr() == T->getReturnType().getAsOpaquePtr() &&
933  !paramChanged && !exceptionChanged)
934  return QualType(T, 0);
935 
936  return Ctx.getFunctionType(returnType, paramTypes, info);
937  }
938 
939  QualType VisitParenType(const ParenType *T) {
940  QualType innerType = recurse(T->getInnerType());
941  if (innerType.isNull())
942  return {};
943 
944  if (innerType.getAsOpaquePtr() == T->getInnerType().getAsOpaquePtr())
945  return QualType(T, 0);
946 
947  return Ctx.getParenType(innerType);
948  }
949 
950  TRIVIAL_TYPE_CLASS(Typedef)
951  TRIVIAL_TYPE_CLASS(ObjCTypeParam)
952 
953  QualType VisitAdjustedType(const AdjustedType *T) {
954  QualType originalType = recurse(T->getOriginalType());
955  if (originalType.isNull())
956  return {};
957 
958  QualType adjustedType = recurse(T->getAdjustedType());
959  if (adjustedType.isNull())
960  return {};
961 
962  if (originalType.getAsOpaquePtr()
963  == T->getOriginalType().getAsOpaquePtr() &&
964  adjustedType.getAsOpaquePtr() == T->getAdjustedType().getAsOpaquePtr())
965  return QualType(T, 0);
966 
967  return Ctx.getAdjustedType(originalType, adjustedType);
968  }
969 
970  QualType VisitDecayedType(const DecayedType *T) {
971  QualType originalType = recurse(T->getOriginalType());
972  if (originalType.isNull())
973  return {};
974 
975  if (originalType.getAsOpaquePtr()
977  return QualType(T, 0);
978 
979  return Ctx.getDecayedType(originalType);
980  }
981 
982  TRIVIAL_TYPE_CLASS(TypeOfExpr)
983  TRIVIAL_TYPE_CLASS(TypeOf)
984  TRIVIAL_TYPE_CLASS(Decltype)
985  TRIVIAL_TYPE_CLASS(UnaryTransform)
986  TRIVIAL_TYPE_CLASS(Record)
987  TRIVIAL_TYPE_CLASS(Enum)
988 
989  // FIXME: Non-trivial to implement, but important for C++
990  TRIVIAL_TYPE_CLASS(Elaborated)
991 
992  QualType VisitAttributedType(const AttributedType *T) {
993  QualType modifiedType = recurse(T->getModifiedType());
994  if (modifiedType.isNull())
995  return {};
996 
997  QualType equivalentType = recurse(T->getEquivalentType());
998  if (equivalentType.isNull())
999  return {};
1000 
1001  if (modifiedType.getAsOpaquePtr()
1002  == T->getModifiedType().getAsOpaquePtr() &&
1003  equivalentType.getAsOpaquePtr()
1005  return QualType(T, 0);
1006 
1007  return Ctx.getAttributedType(T->getAttrKind(), modifiedType,
1008  equivalentType);
1009  }
1010 
1011  QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
1012  QualType replacementType = recurse(T->getReplacementType());
1013  if (replacementType.isNull())
1014  return {};
1015 
1016  if (replacementType.getAsOpaquePtr()
1018  return QualType(T, 0);
1019 
1021  replacementType);
1022  }
1023 
1024  // FIXME: Non-trivial to implement, but important for C++
1025  TRIVIAL_TYPE_CLASS(TemplateSpecialization)
1026 
1027  QualType VisitAutoType(const AutoType *T) {
1028  if (!T->isDeduced())
1029  return QualType(T, 0);
1030 
1031  QualType deducedType = recurse(T->getDeducedType());
1032  if (deducedType.isNull())
1033  return {};
1034 
1035  if (deducedType.getAsOpaquePtr()
1036  == T->getDeducedType().getAsOpaquePtr())
1037  return QualType(T, 0);
1038 
1039  return Ctx.getAutoType(deducedType, T->getKeyword(),
1040  T->isDependentType());
1041  }
1042 
1043  // FIXME: Non-trivial to implement, but important for C++
1044  TRIVIAL_TYPE_CLASS(PackExpansion)
1045 
1046  QualType VisitObjCObjectType(const ObjCObjectType *T) {
1047  QualType baseType = recurse(T->getBaseType());
1048  if (baseType.isNull())
1049  return {};
1050 
1051  // Transform type arguments.
1052  bool typeArgChanged = false;
1053  SmallVector<QualType, 4> typeArgs;
1054  for (auto typeArg : T->getTypeArgsAsWritten()) {
1055  QualType newTypeArg = recurse(typeArg);
1056  if (newTypeArg.isNull())
1057  return {};
1058 
1059  if (newTypeArg.getAsOpaquePtr() != typeArg.getAsOpaquePtr())
1060  typeArgChanged = true;
1061 
1062  typeArgs.push_back(newTypeArg);
1063  }
1064 
1065  if (baseType.getAsOpaquePtr() == T->getBaseType().getAsOpaquePtr() &&
1066  !typeArgChanged)
1067  return QualType(T, 0);
1068 
1069  return Ctx.getObjCObjectType(baseType, typeArgs,
1070  llvm::makeArrayRef(T->qual_begin(),
1071  T->getNumProtocols()),
1072  T->isKindOfTypeAsWritten());
1073  }
1074 
1075  TRIVIAL_TYPE_CLASS(ObjCInterface)
1076 
1077  QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1078  QualType pointeeType = recurse(T->getPointeeType());
1079  if (pointeeType.isNull())
1080  return {};
1081 
1082  if (pointeeType.getAsOpaquePtr()
1083  == T->getPointeeType().getAsOpaquePtr())
1084  return QualType(T, 0);
1085 
1086  return Ctx.getObjCObjectPointerType(pointeeType);
1087  }
1088 
1089  QualType VisitAtomicType(const AtomicType *T) {
1090  QualType valueType = recurse(T->getValueType());
1091  if (valueType.isNull())
1092  return {};
1093 
1094  if (valueType.getAsOpaquePtr()
1095  == T->getValueType().getAsOpaquePtr())
1096  return QualType(T, 0);
1097 
1098  return Ctx.getAtomicType(valueType);
1099  }
1100 
1101 #undef TRIVIAL_TYPE_CLASS
1102 };
1103 
1104 } // namespace
1105 
1106 /// Perform a simple type transformation that does not change the
1107 /// semantics of the type.
1108 template<typename F>
1109 static QualType simpleTransform(ASTContext &ctx, QualType type, F &&f) {
1110  // Transform the type. If it changed, return the transformed result.
1111  QualType transformed = f(type);
1112  if (transformed.getAsOpaquePtr() != type.getAsOpaquePtr())
1113  return transformed;
1114 
1115  // Split out the qualifiers from the type.
1116  SplitQualType splitType = type.split();
1117 
1118  // Visit the type itself.
1119  SimpleTransformVisitor<F> visitor(ctx, std::forward<F>(f));
1120  QualType result = visitor.Visit(splitType.Ty);
1121  if (result.isNull())
1122  return result;
1123 
1124  // Reconstruct the transformed type by applying the local qualifiers
1125  // from the split type.
1126  return ctx.getQualifiedType(result, splitType.Quals);
1127 }
1128 
1129 /// Substitute the given type arguments for Objective-C type
1130 /// parameters within the given type, recursively.
1132  ASTContext &ctx,
1133  ArrayRef<QualType> typeArgs,
1134  ObjCSubstitutionContext context) const {
1135  return simpleTransform(ctx, *this,
1136  [&](QualType type) -> QualType {
1137  SplitQualType splitType = type.split();
1138 
1139  // Replace an Objective-C type parameter reference with the corresponding
1140  // type argument.
1141  if (const auto *OTPTy = dyn_cast<ObjCTypeParamType>(splitType.Ty)) {
1142  ObjCTypeParamDecl *typeParam = OTPTy->getDecl();
1143  // If we have type arguments, use them.
1144  if (!typeArgs.empty()) {
1145  QualType argType = typeArgs[typeParam->getIndex()];
1146  if (OTPTy->qual_empty())
1147  return ctx.getQualifiedType(argType, splitType.Quals);
1148 
1149  // Apply protocol lists if exists.
1150  bool hasError;
1151  SmallVector<ObjCProtocolDecl*, 8> protocolsVec;
1152  protocolsVec.append(OTPTy->qual_begin(),
1153  OTPTy->qual_end());
1154  ArrayRef<ObjCProtocolDecl *> protocolsToApply = protocolsVec;
1155  QualType resultTy = ctx.applyObjCProtocolQualifiers(argType,
1156  protocolsToApply, hasError, true/*allowOnPointerType*/);
1157 
1158  return ctx.getQualifiedType(resultTy, splitType.Quals);
1159  }
1160 
1161  switch (context) {
1165  // Substitute the bound.
1166  return ctx.getQualifiedType(typeParam->getUnderlyingType(),
1167  splitType.Quals);
1168 
1171  // Substitute the __kindof form of the underlying type.
1172  const auto *objPtr = typeParam->getUnderlyingType()
1174 
1175  // __kindof types, id, and Class don't need an additional
1176  // __kindof.
1177  if (objPtr->isKindOfType() || objPtr->isObjCIdOrClassType())
1178  return ctx.getQualifiedType(typeParam->getUnderlyingType(),
1179  splitType.Quals);
1180 
1181  // Add __kindof.
1182  const auto *obj = objPtr->getObjectType();
1183  QualType resultTy = ctx.getObjCObjectType(obj->getBaseType(),
1184  obj->getTypeArgsAsWritten(),
1185  obj->getProtocols(),
1186  /*isKindOf=*/true);
1187 
1188  // Rebuild object pointer type.
1189  resultTy = ctx.getObjCObjectPointerType(resultTy);
1190  return ctx.getQualifiedType(resultTy, splitType.Quals);
1191  }
1192  }
1193  }
1194 
1195  // If we have a function type, update the context appropriately.
1196  if (const auto *funcType = dyn_cast<FunctionType>(splitType.Ty)) {
1197  // Substitute result type.
1198  QualType returnType = funcType->getReturnType().substObjCTypeArgs(
1199  ctx,
1200  typeArgs,
1202  if (returnType.isNull())
1203  return {};
1204 
1205  // Handle non-prototyped functions, which only substitute into the result
1206  // type.
1207  if (isa<FunctionNoProtoType>(funcType)) {
1208  // If the return type was unchanged, do nothing.
1209  if (returnType.getAsOpaquePtr()
1210  == funcType->getReturnType().getAsOpaquePtr())
1211  return type;
1212 
1213  // Otherwise, build a new type.
1214  return ctx.getFunctionNoProtoType(returnType, funcType->getExtInfo());
1215  }
1216 
1217  const auto *funcProtoType = cast<FunctionProtoType>(funcType);
1218 
1219  // Transform parameter types.
1220  SmallVector<QualType, 4> paramTypes;
1221  bool paramChanged = false;
1222  for (auto paramType : funcProtoType->getParamTypes()) {
1223  QualType newParamType = paramType.substObjCTypeArgs(
1224  ctx,
1225  typeArgs,
1227  if (newParamType.isNull())
1228  return {};
1229 
1230  if (newParamType.getAsOpaquePtr() != paramType.getAsOpaquePtr())
1231  paramChanged = true;
1232 
1233  paramTypes.push_back(newParamType);
1234  }
1235 
1236  // Transform extended info.
1237  FunctionProtoType::ExtProtoInfo info = funcProtoType->getExtProtoInfo();
1238  bool exceptionChanged = false;
1239  if (info.ExceptionSpec.Type == EST_Dynamic) {
1240  SmallVector<QualType, 4> exceptionTypes;
1241  for (auto exceptionType : info.ExceptionSpec.Exceptions) {
1242  QualType newExceptionType = exceptionType.substObjCTypeArgs(
1243  ctx,
1244  typeArgs,
1246  if (newExceptionType.isNull())
1247  return {};
1248 
1249  if (newExceptionType.getAsOpaquePtr()
1250  != exceptionType.getAsOpaquePtr())
1251  exceptionChanged = true;
1252 
1253  exceptionTypes.push_back(newExceptionType);
1254  }
1255 
1256  if (exceptionChanged) {
1257  info.ExceptionSpec.Exceptions =
1258  llvm::makeArrayRef(exceptionTypes).copy(ctx);
1259  }
1260  }
1261 
1262  if (returnType.getAsOpaquePtr()
1263  == funcProtoType->getReturnType().getAsOpaquePtr() &&
1264  !paramChanged && !exceptionChanged)
1265  return type;
1266 
1267  return ctx.getFunctionType(returnType, paramTypes, info);
1268  }
1269 
1270  // Substitute into the type arguments of a specialized Objective-C object
1271  // type.
1272  if (const auto *objcObjectType = dyn_cast<ObjCObjectType>(splitType.Ty)) {
1273  if (objcObjectType->isSpecializedAsWritten()) {
1274  SmallVector<QualType, 4> newTypeArgs;
1275  bool anyChanged = false;
1276  for (auto typeArg : objcObjectType->getTypeArgsAsWritten()) {
1277  QualType newTypeArg = typeArg.substObjCTypeArgs(
1278  ctx, typeArgs,
1280  if (newTypeArg.isNull())
1281  return {};
1282 
1283  if (newTypeArg.getAsOpaquePtr() != typeArg.getAsOpaquePtr()) {
1284  // If we're substituting based on an unspecialized context type,
1285  // produce an unspecialized type.
1286  ArrayRef<ObjCProtocolDecl *> protocols(
1287  objcObjectType->qual_begin(),
1288  objcObjectType->getNumProtocols());
1289  if (typeArgs.empty() &&
1291  return ctx.getObjCObjectType(
1292  objcObjectType->getBaseType(), {},
1293  protocols,
1294  objcObjectType->isKindOfTypeAsWritten());
1295  }
1296 
1297  anyChanged = true;
1298  }
1299 
1300  newTypeArgs.push_back(newTypeArg);
1301  }
1302 
1303  if (anyChanged) {
1304  ArrayRef<ObjCProtocolDecl *> protocols(
1305  objcObjectType->qual_begin(),
1306  objcObjectType->getNumProtocols());
1307  return ctx.getObjCObjectType(objcObjectType->getBaseType(),
1308  newTypeArgs, protocols,
1309  objcObjectType->isKindOfTypeAsWritten());
1310  }
1311  }
1312 
1313  return type;
1314  }
1315 
1316  return type;
1317  });
1318 }
1319 
1321  const DeclContext *dc,
1322  ObjCSubstitutionContext context) const {
1323  if (auto subs = objectType->getObjCSubstitutions(dc))
1324  return substObjCTypeArgs(dc->getParentASTContext(), *subs, context);
1325 
1326  return *this;
1327 }
1328 
1330  // FIXME: Because ASTContext::getAttributedType() is non-const.
1331  auto &ctx = const_cast<ASTContext &>(constCtx);
1332  return simpleTransform(ctx, *this,
1333  [&](QualType type) -> QualType {
1334  SplitQualType splitType = type.split();
1335  if (auto *objType = splitType.Ty->getAs<ObjCObjectType>()) {
1336  if (!objType->isKindOfType())
1337  return type;
1338 
1339  QualType baseType
1340  = objType->getBaseType().stripObjCKindOfType(ctx);
1341  return ctx.getQualifiedType(
1342  ctx.getObjCObjectType(baseType,
1343  objType->getTypeArgsAsWritten(),
1344  objType->getProtocols(),
1345  /*isKindOf=*/false),
1346  splitType.Quals);
1347  }
1348 
1349  return type;
1350  });
1351 }
1352 
1354  if (const auto AT = getTypePtr()->getAs<AtomicType>())
1355  return AT->getValueType().getUnqualifiedType();
1356  return getUnqualifiedType();
1357 }
1358 
1360  const DeclContext *dc) const {
1361  // Look through method scopes.
1362  if (const auto method = dyn_cast<ObjCMethodDecl>(dc))
1363  dc = method->getDeclContext();
1364 
1365  // Find the class or category in which the type we're substituting
1366  // was declared.
1367  const auto *dcClassDecl = dyn_cast<ObjCInterfaceDecl>(dc);
1368  const ObjCCategoryDecl *dcCategoryDecl = nullptr;
1369  ObjCTypeParamList *dcTypeParams = nullptr;
1370  if (dcClassDecl) {
1371  // If the class does not have any type parameters, there's no
1372  // substitution to do.
1373  dcTypeParams = dcClassDecl->getTypeParamList();
1374  if (!dcTypeParams)
1375  return None;
1376  } else {
1377  // If we are in neither a class nor a category, there's no
1378  // substitution to perform.
1379  dcCategoryDecl = dyn_cast<ObjCCategoryDecl>(dc);
1380  if (!dcCategoryDecl)
1381  return None;
1382 
1383  // If the category does not have any type parameters, there's no
1384  // substitution to do.
1385  dcTypeParams = dcCategoryDecl->getTypeParamList();
1386  if (!dcTypeParams)
1387  return None;
1388 
1389  dcClassDecl = dcCategoryDecl->getClassInterface();
1390  if (!dcClassDecl)
1391  return None;
1392  }
1393  assert(dcTypeParams && "No substitutions to perform");
1394  assert(dcClassDecl && "No class context");
1395 
1396  // Find the underlying object type.
1397  const ObjCObjectType *objectType;
1398  if (const auto *objectPointerType = getAs<ObjCObjectPointerType>()) {
1399  objectType = objectPointerType->getObjectType();
1400  } else if (getAs<BlockPointerType>()) {
1401  ASTContext &ctx = dc->getParentASTContext();
1402  objectType = ctx.getObjCObjectType(ctx.ObjCBuiltinIdTy, {}, {})
1403  ->castAs<ObjCObjectType>();
1404  } else {
1405  objectType = getAs<ObjCObjectType>();
1406  }
1407 
1408  /// Extract the class from the receiver object type.
1409  ObjCInterfaceDecl *curClassDecl = objectType ? objectType->getInterface()
1410  : nullptr;
1411  if (!curClassDecl) {
1412  // If we don't have a context type (e.g., this is "id" or some
1413  // variant thereof), substitute the bounds.
1414  return llvm::ArrayRef<QualType>();
1415  }
1416 
1417  // Follow the superclass chain until we've mapped the receiver type
1418  // to the same class as the context.
1419  while (curClassDecl != dcClassDecl) {
1420  // Map to the superclass type.
1421  QualType superType = objectType->getSuperClassType();
1422  if (superType.isNull()) {
1423  objectType = nullptr;
1424  break;
1425  }
1426 
1427  objectType = superType->castAs<ObjCObjectType>();
1428  curClassDecl = objectType->getInterface();
1429  }
1430 
1431  // If we don't have a receiver type, or the receiver type does not
1432  // have type arguments, substitute in the defaults.
1433  if (!objectType || objectType->isUnspecialized()) {
1434  return llvm::ArrayRef<QualType>();
1435  }
1436 
1437  // The receiver type has the type arguments we want.
1438  return objectType->getTypeArgs();
1439 }
1440 
1442  if (auto *IfaceT = getAsObjCInterfaceType()) {
1443  if (auto *ID = IfaceT->getInterface()) {
1444  if (ID->getTypeParamList())
1445  return true;
1446  }
1447  }
1448 
1449  return false;
1450 }
1451 
1453  // Retrieve the class declaration for this type. If there isn't one
1454  // (e.g., this is some variant of "id" or "Class"), then there is no
1455  // superclass type.
1456  ObjCInterfaceDecl *classDecl = getInterface();
1457  if (!classDecl) {
1458  CachedSuperClassType.setInt(true);
1459  return;
1460  }
1461 
1462  // Extract the superclass type.
1463  const ObjCObjectType *superClassObjTy = classDecl->getSuperClassType();
1464  if (!superClassObjTy) {
1465  CachedSuperClassType.setInt(true);
1466  return;
1467  }
1468 
1469  ObjCInterfaceDecl *superClassDecl = superClassObjTy->getInterface();
1470  if (!superClassDecl) {
1471  CachedSuperClassType.setInt(true);
1472  return;
1473  }
1474 
1475  // If the superclass doesn't have type parameters, then there is no
1476  // substitution to perform.
1477  QualType superClassType(superClassObjTy, 0);
1478  ObjCTypeParamList *superClassTypeParams = superClassDecl->getTypeParamList();
1479  if (!superClassTypeParams) {
1480  CachedSuperClassType.setPointerAndInt(
1481  superClassType->castAs<ObjCObjectType>(), true);
1482  return;
1483  }
1484 
1485  // If the superclass reference is unspecialized, return it.
1486  if (superClassObjTy->isUnspecialized()) {
1487  CachedSuperClassType.setPointerAndInt(superClassObjTy, true);
1488  return;
1489  }
1490 
1491  // If the subclass is not parameterized, there aren't any type
1492  // parameters in the superclass reference to substitute.
1493  ObjCTypeParamList *typeParams = classDecl->getTypeParamList();
1494  if (!typeParams) {
1495  CachedSuperClassType.setPointerAndInt(
1496  superClassType->castAs<ObjCObjectType>(), true);
1497  return;
1498  }
1499 
1500  // If the subclass type isn't specialized, return the unspecialized
1501  // superclass.
1502  if (isUnspecialized()) {
1503  QualType unspecializedSuper
1504  = classDecl->getASTContext().getObjCInterfaceType(
1505  superClassObjTy->getInterface());
1506  CachedSuperClassType.setPointerAndInt(
1507  unspecializedSuper->castAs<ObjCObjectType>(),
1508  true);
1509  return;
1510  }
1511 
1512  // Substitute the provided type arguments into the superclass type.
1513  ArrayRef<QualType> typeArgs = getTypeArgs();
1514  assert(typeArgs.size() == typeParams->size());
1515  CachedSuperClassType.setPointerAndInt(
1516  superClassType.substObjCTypeArgs(classDecl->getASTContext(), typeArgs,
1518  ->castAs<ObjCObjectType>(),
1519  true);
1520 }
1521 
1523  if (auto interfaceDecl = getObjectType()->getInterface()) {
1524  return interfaceDecl->getASTContext().getObjCInterfaceType(interfaceDecl)
1526  }
1527 
1528  return nullptr;
1529 }
1530 
1532  QualType superObjectType = getObjectType()->getSuperClassType();
1533  if (superObjectType.isNull())
1534  return superObjectType;
1535 
1536  ASTContext &ctx = getInterfaceDecl()->getASTContext();
1537  return ctx.getObjCObjectPointerType(superObjectType);
1538 }
1539 
1541  // There is no sugar for ObjCObjectType's, just return the canonical
1542  // type pointer if it is the right class. There is no typedef information to
1543  // return and these cannot be Address-space qualified.
1544  if (const auto *T = getAs<ObjCObjectType>())
1545  if (T->getNumProtocols() && T->getInterface())
1546  return T;
1547  return nullptr;
1548 }
1549 
1551  return getAsObjCQualifiedInterfaceType() != nullptr;
1552 }
1553 
1555  // There is no sugar for ObjCQualifiedIdType's, just return the canonical
1556  // type pointer if it is the right class.
1557  if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
1558  if (OPT->isObjCQualifiedIdType())
1559  return OPT;
1560  }
1561  return nullptr;
1562 }
1563 
1565  // There is no sugar for ObjCQualifiedClassType's, just return the canonical
1566  // type pointer if it is the right class.
1567  if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
1568  if (OPT->isObjCQualifiedClassType())
1569  return OPT;
1570  }
1571  return nullptr;
1572 }
1573 
1575  if (const auto *OT = getAs<ObjCObjectType>()) {
1576  if (OT->getInterface())
1577  return OT;
1578  }
1579  return nullptr;
1580 }
1581 
1583  if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
1584  if (OPT->getInterfaceType())
1585  return OPT;
1586  }
1587  return nullptr;
1588 }
1589 
1591  QualType PointeeType;
1592  if (const auto *PT = getAs<PointerType>())
1593  PointeeType = PT->getPointeeType();
1594  else if (const auto *RT = getAs<ReferenceType>())
1595  PointeeType = RT->getPointeeType();
1596  else
1597  return nullptr;
1598 
1599  if (const auto *RT = PointeeType->getAs<RecordType>())
1600  return dyn_cast<CXXRecordDecl>(RT->getDecl());
1601 
1602  return nullptr;
1603 }
1604 
1606  return dyn_cast_or_null<CXXRecordDecl>(getAsTagDecl());
1607 }
1608 
1610  return dyn_cast_or_null<RecordDecl>(getAsTagDecl());
1611 }
1612 
1614  if (const auto *TT = getAs<TagType>())
1615  return TT->getDecl();
1616  if (const auto *Injected = getAs<InjectedClassNameType>())
1617  return Injected->getDecl();
1618 
1619  return nullptr;
1620 }
1621 
1622 bool Type::hasAttr(attr::Kind AK) const {
1623  const Type *Cur = this;
1624  while (const auto *AT = Cur->getAs<AttributedType>()) {
1625  if (AT->getAttrKind() == AK)
1626  return true;
1627  Cur = AT->getEquivalentType().getTypePtr();
1628  }
1629  return false;
1630 }
1631 
1632 namespace {
1633 
1634  class GetContainedDeducedTypeVisitor :
1635  public TypeVisitor<GetContainedDeducedTypeVisitor, Type*> {
1636  bool Syntactic;
1637 
1638  public:
1639  GetContainedDeducedTypeVisitor(bool Syntactic = false)
1640  : Syntactic(Syntactic) {}
1641 
1643 
1644  Type *Visit(QualType T) {
1645  if (T.isNull())
1646  return nullptr;
1647  return Visit(T.getTypePtr());
1648  }
1649 
1650  // The deduced type itself.
1651  Type *VisitDeducedType(const DeducedType *AT) {
1652  return const_cast<DeducedType*>(AT);
1653  }
1654 
1655  // Only these types can contain the desired 'auto' type.
1656 
1657  Type *VisitElaboratedType(const ElaboratedType *T) {
1658  return Visit(T->getNamedType());
1659  }
1660 
1661  Type *VisitPointerType(const PointerType *T) {
1662  return Visit(T->getPointeeType());
1663  }
1664 
1665  Type *VisitBlockPointerType(const BlockPointerType *T) {
1666  return Visit(T->getPointeeType());
1667  }
1668 
1669  Type *VisitReferenceType(const ReferenceType *T) {
1670  return Visit(T->getPointeeTypeAsWritten());
1671  }
1672 
1673  Type *VisitMemberPointerType(const MemberPointerType *T) {
1674  return Visit(T->getPointeeType());
1675  }
1676 
1677  Type *VisitArrayType(const ArrayType *T) {
1678  return Visit(T->getElementType());
1679  }
1680 
1681  Type *VisitDependentSizedExtVectorType(
1682  const DependentSizedExtVectorType *T) {
1683  return Visit(T->getElementType());
1684  }
1685 
1686  Type *VisitVectorType(const VectorType *T) {
1687  return Visit(T->getElementType());
1688  }
1689 
1690  Type *VisitFunctionProtoType(const FunctionProtoType *T) {
1691  if (Syntactic && T->hasTrailingReturn())
1692  return const_cast<FunctionProtoType*>(T);
1693  return VisitFunctionType(T);
1694  }
1695 
1696  Type *VisitFunctionType(const FunctionType *T) {
1697  return Visit(T->getReturnType());
1698  }
1699 
1700  Type *VisitParenType(const ParenType *T) {
1701  return Visit(T->getInnerType());
1702  }
1703 
1704  Type *VisitAttributedType(const AttributedType *T) {
1705  return Visit(T->getModifiedType());
1706  }
1707 
1708  Type *VisitAdjustedType(const AdjustedType *T) {
1709  return Visit(T->getOriginalType());
1710  }
1711  };
1712 
1713 } // namespace
1714 
1716  return cast_or_null<DeducedType>(
1717  GetContainedDeducedTypeVisitor().Visit(this));
1718 }
1719 
1721  return dyn_cast_or_null<FunctionType>(
1722  GetContainedDeducedTypeVisitor(true).Visit(this));
1723 }
1724 
1726  if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
1727  return VT->getElementType()->isIntegerType();
1728  else
1729  return isIntegerType();
1730 }
1731 
1732 /// Determine whether this type is an integral type.
1733 ///
1734 /// This routine determines whether the given type is an integral type per
1735 /// C++ [basic.fundamental]p7. Although the C standard does not define the
1736 /// term "integral type", it has a similar term "integer type", and in C++
1737 /// the two terms are equivalent. However, C's "integer type" includes
1738 /// enumeration types, while C++'s "integer type" does not. The \c ASTContext
1739 /// parameter is used to determine whether we should be following the C or
1740 /// C++ rules when determining whether this type is an integral/integer type.
1741 ///
1742 /// For cases where C permits "an integer type" and C++ permits "an integral
1743 /// type", use this routine.
1744 ///
1745 /// For cases where C permits "an integer type" and C++ permits "an integral
1746 /// or enumeration type", use \c isIntegralOrEnumerationType() instead.
1747 ///
1748 /// \param Ctx The context in which this type occurs.
1749 ///
1750 /// \returns true if the type is considered an integral type, false otherwise.
1751 bool Type::isIntegralType(const ASTContext &Ctx) const {
1752  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1753  return BT->getKind() >= BuiltinType::Bool &&
1754  BT->getKind() <= BuiltinType::Int128;
1755 
1756  // Complete enum types are integral in C.
1757  if (!Ctx.getLangOpts().CPlusPlus)
1758  if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
1759  return ET->getDecl()->isComplete();
1760 
1761  return false;
1762 }
1763 
1765  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1766  return BT->getKind() >= BuiltinType::Bool &&
1767  BT->getKind() <= BuiltinType::Int128;
1768 
1769  // Check for a complete enum type; incomplete enum types are not properly an
1770  // enumeration type in the sense required here.
1771  // C++0x: However, if the underlying type of the enum is fixed, it is
1772  // considered complete.
1773  if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
1774  return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
1775 
1776  return false;
1777 }
1778 
1779 bool Type::isCharType() const {
1780  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1781  return BT->getKind() == BuiltinType::Char_U ||
1782  BT->getKind() == BuiltinType::UChar ||
1783  BT->getKind() == BuiltinType::Char_S ||
1784  BT->getKind() == BuiltinType::SChar;
1785  return false;
1786 }
1787 
1788 bool Type::isWideCharType() const {
1789  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1790  return BT->getKind() == BuiltinType::WChar_S ||
1791  BT->getKind() == BuiltinType::WChar_U;
1792  return false;
1793 }
1794 
1795 bool Type::isChar8Type() const {
1796  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
1797  return BT->getKind() == BuiltinType::Char8;
1798  return false;
1799 }
1800 
1801 bool Type::isChar16Type() const {
1802  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1803  return BT->getKind() == BuiltinType::Char16;
1804  return false;
1805 }
1806 
1807 bool Type::isChar32Type() const {
1808  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1809  return BT->getKind() == BuiltinType::Char32;
1810  return false;
1811 }
1812 
1813 /// Determine whether this type is any of the built-in character
1814 /// types.
1816  const auto *BT = dyn_cast<BuiltinType>(CanonicalType);
1817  if (!BT) return false;
1818  switch (BT->getKind()) {
1819  default: return false;
1820  case BuiltinType::Char_U:
1821  case BuiltinType::UChar:
1822  case BuiltinType::WChar_U:
1823  case BuiltinType::Char8:
1824  case BuiltinType::Char16:
1825  case BuiltinType::Char32:
1826  case BuiltinType::Char_S:
1827  case BuiltinType::SChar:
1828  case BuiltinType::WChar_S:
1829  return true;
1830  }
1831 }
1832 
1833 /// isSignedIntegerType - Return true if this is an integer type that is
1834 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
1835 /// an enum decl which has a signed representation
1837  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1838  return BT->getKind() >= BuiltinType::Char_S &&
1839  BT->getKind() <= BuiltinType::Int128;
1840  }
1841 
1842  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
1843  // Incomplete enum types are not treated as integer types.
1844  // FIXME: In C++, enum types are never integer types.
1845  if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
1846  return ET->getDecl()->getIntegerType()->isSignedIntegerType();
1847  }
1848 
1849  return false;
1850 }
1851 
1853  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1854  return BT->getKind() >= BuiltinType::Char_S &&
1855  BT->getKind() <= BuiltinType::Int128;
1856  }
1857 
1858  if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
1859  if (ET->getDecl()->isComplete())
1860  return ET->getDecl()->getIntegerType()->isSignedIntegerType();
1861  }
1862 
1863  return false;
1864 }
1865 
1867  if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
1868  return VT->getElementType()->isSignedIntegerOrEnumerationType();
1869  else
1871 }
1872 
1873 /// isUnsignedIntegerType - Return true if this is an integer type that is
1874 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum
1875 /// decl which has an unsigned representation
1877  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1878  return BT->getKind() >= BuiltinType::Bool &&
1879  BT->getKind() <= BuiltinType::UInt128;
1880  }
1881 
1882  if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
1883  // Incomplete enum types are not treated as integer types.
1884  // FIXME: In C++, enum types are never integer types.
1885  if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
1886  return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
1887  }
1888 
1889  return false;
1890 }
1891 
1893  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
1894  return BT->getKind() >= BuiltinType::Bool &&
1895  BT->getKind() <= BuiltinType::UInt128;
1896  }
1897 
1898  if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
1899  if (ET->getDecl()->isComplete())
1900  return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
1901  }
1902 
1903  return false;
1904 }
1905 
1907  if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
1908  return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
1909  else
1911 }
1912 
1913 bool Type::isFloatingType() const {
1914  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1915  return BT->getKind() >= BuiltinType::Half &&
1916  BT->getKind() <= BuiltinType::Float128;
1917  if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
1918  return CT->getElementType()->isFloatingType();
1919  return false;
1920 }
1921 
1923  if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
1924  return VT->getElementType()->isFloatingType();
1925  else
1926  return isFloatingType();
1927 }
1928 
1930  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1931  return BT->isFloatingPoint();
1932  return false;
1933 }
1934 
1935 bool Type::isRealType() const {
1936  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1937  return BT->getKind() >= BuiltinType::Bool &&
1938  BT->getKind() <= BuiltinType::Float128;
1939  if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
1940  return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
1941  return false;
1942 }
1943 
1945  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
1946  return BT->getKind() >= BuiltinType::Bool &&
1947  BT->getKind() <= BuiltinType::Float128;
1948  if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
1949  // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2).
1950  // If a body isn't seen by the time we get here, return false.
1951  //
1952  // C++0x: Enumerations are not arithmetic types. For now, just return
1953  // false for scoped enumerations since that will disable any
1954  // unwanted implicit conversions.
1955  return !ET->getDecl()->isScoped() && ET->getDecl()->isComplete();
1956  return isa<ComplexType>(CanonicalType);
1957 }
1958 
1960  assert(isScalarType());
1961 
1962  const Type *T = CanonicalType.getTypePtr();
1963  if (const auto *BT = dyn_cast<BuiltinType>(T)) {
1964  if (BT->getKind() == BuiltinType::Bool) return STK_Bool;
1965  if (BT->getKind() == BuiltinType::NullPtr) return STK_CPointer;
1966  if (BT->isInteger()) return STK_Integral;
1967  if (BT->isFloatingPoint()) return STK_Floating;
1968  if (BT->isFixedPointType()) return STK_FixedPoint;
1969  llvm_unreachable("unknown scalar builtin type");
1970  } else if (isa<PointerType>(T)) {
1971  return STK_CPointer;
1972  } else if (isa<BlockPointerType>(T)) {
1973  return STK_BlockPointer;
1974  } else if (isa<ObjCObjectPointerType>(T)) {
1975  return STK_ObjCObjectPointer;
1976  } else if (isa<MemberPointerType>(T)) {
1977  return STK_MemberPointer;
1978  } else if (isa<EnumType>(T)) {
1979  assert(cast<EnumType>(T)->getDecl()->isComplete());
1980  return STK_Integral;
1981  } else if (const auto *CT = dyn_cast<ComplexType>(T)) {
1982  if (CT->getElementType()->isRealFloatingType())
1983  return STK_FloatingComplex;
1984  return STK_IntegralComplex;
1985  }
1986 
1987  llvm_unreachable("unknown scalar type");
1988 }
1989 
1990 /// Determines whether the type is a C++ aggregate type or C
1991 /// aggregate or union type.
1992 ///
1993 /// An aggregate type is an array or a class type (struct, union, or
1994 /// class) that has no user-declared constructors, no private or
1995 /// protected non-static data members, no base classes, and no virtual
1996 /// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type
1997 /// subsumes the notion of C aggregates (C99 6.2.5p21) because it also
1998 /// includes union types.
2000  if (const auto *Record = dyn_cast<RecordType>(CanonicalType)) {
2001  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl()))
2002  return ClassDecl->isAggregate();
2003 
2004  return true;
2005  }
2006 
2007  return isa<ArrayType>(CanonicalType);
2008 }
2009 
2010 /// isConstantSizeType - Return true if this is not a variable sized type,
2011 /// according to the rules of C99 6.7.5p3. It is not legal to call this on
2012 /// incomplete types or dependent types.
2014  assert(!isIncompleteType() && "This doesn't make sense for incomplete types");
2015  assert(!isDependentType() && "This doesn't make sense for dependent types");
2016  // The VAT must have a size, as it is known to be complete.
2017  return !isa<VariableArrayType>(CanonicalType);
2018 }
2019 
2020 /// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1)
2021 /// - a type that can describe objects, but which lacks information needed to
2022 /// determine its size.
2024  if (Def)
2025  *Def = nullptr;
2026 
2027  switch (CanonicalType->getTypeClass()) {
2028  default: return false;
2029  case Builtin:
2030  // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never
2031  // be completed.
2032  return isVoidType();
2033  case Enum: {
2034  EnumDecl *EnumD = cast<EnumType>(CanonicalType)->getDecl();
2035  if (Def)
2036  *Def = EnumD;
2037  return !EnumD->isComplete();
2038  }
2039  case Record: {
2040  // A tagged type (struct/union/enum/class) is incomplete if the decl is a
2041  // forward declaration, but not a full definition (C99 6.2.5p22).
2042  RecordDecl *Rec = cast<RecordType>(CanonicalType)->getDecl();
2043  if (Def)
2044  *Def = Rec;
2045  return !Rec->isCompleteDefinition();
2046  }
2047  case ConstantArray:
2048  // An array is incomplete if its element type is incomplete
2049  // (C++ [dcl.array]p1).
2050  // We don't handle variable arrays (they're not allowed in C++) or
2051  // dependent-sized arrays (dependent types are never treated as incomplete).
2052  return cast<ArrayType>(CanonicalType)->getElementType()
2053  ->isIncompleteType(Def);
2054  case IncompleteArray:
2055  // An array of unknown size is an incomplete type (C99 6.2.5p22).
2056  return true;
2057  case MemberPointer: {
2058  // Member pointers in the MS ABI have special behavior in
2059  // RequireCompleteType: they attach a MSInheritanceAttr to the CXXRecordDecl
2060  // to indicate which inheritance model to use.
2061  auto *MPTy = cast<MemberPointerType>(CanonicalType);
2062  const Type *ClassTy = MPTy->getClass();
2063  // Member pointers with dependent class types don't get special treatment.
2064  if (ClassTy->isDependentType())
2065  return false;
2066  const CXXRecordDecl *RD = ClassTy->getAsCXXRecordDecl();
2067  ASTContext &Context = RD->getASTContext();
2068  // Member pointers not in the MS ABI don't get special treatment.
2069  if (!Context.getTargetInfo().getCXXABI().isMicrosoft())
2070  return false;
2071  // The inheritance attribute might only be present on the most recent
2072  // CXXRecordDecl, use that one.
2073  RD = RD->getMostRecentNonInjectedDecl();
2074  // Nothing interesting to do if the inheritance attribute is already set.
2075  if (RD->hasAttr<MSInheritanceAttr>())
2076  return false;
2077  return true;
2078  }
2079  case ObjCObject:
2080  return cast<ObjCObjectType>(CanonicalType)->getBaseType()
2081  ->isIncompleteType(Def);
2082  case ObjCInterface: {
2083  // ObjC interfaces are incomplete if they are @class, not @interface.
2084  ObjCInterfaceDecl *Interface
2085  = cast<ObjCInterfaceType>(CanonicalType)->getDecl();
2086  if (Def)
2087  *Def = Interface;
2088  return !Interface->hasDefinition();
2089  }
2090  }
2091 }
2092 
2093 bool QualType::isPODType(const ASTContext &Context) const {
2094  // C++11 has a more relaxed definition of POD.
2095  if (Context.getLangOpts().CPlusPlus11)
2096  return isCXX11PODType(Context);
2097 
2098  return isCXX98PODType(Context);
2099 }
2100 
2101 bool QualType::isCXX98PODType(const ASTContext &Context) const {
2102  // The compiler shouldn't query this for incomplete types, but the user might.
2103  // We return false for that case. Except for incomplete arrays of PODs, which
2104  // are PODs according to the standard.
2105  if (isNull())
2106  return false;
2107 
2108  if ((*this)->isIncompleteArrayType())
2109  return Context.getBaseElementType(*this).isCXX98PODType(Context);
2110 
2111  if ((*this)->isIncompleteType())
2112  return false;
2113 
2114  if (hasNonTrivialObjCLifetime())
2115  return false;
2116 
2117  QualType CanonicalType = getTypePtr()->CanonicalType;
2118  switch (CanonicalType->getTypeClass()) {
2119  // Everything not explicitly mentioned is not POD.
2120  default: return false;
2121  case Type::VariableArray:
2122  case Type::ConstantArray:
2123  // IncompleteArray is handled above.
2124  return Context.getBaseElementType(*this).isCXX98PODType(Context);
2125 
2126  case Type::ObjCObjectPointer:
2127  case Type::BlockPointer:
2128  case Type::Builtin:
2129  case Type::Complex:
2130  case Type::Pointer:
2131  case Type::MemberPointer:
2132  case Type::Vector:
2133  case Type::ExtVector:
2134  return true;
2135 
2136  case Type::Enum:
2137  return true;
2138 
2139  case Type::Record:
2140  if (const auto *ClassDecl =
2141  dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl()))
2142  return ClassDecl->isPOD();
2143 
2144  // C struct/union is POD.
2145  return true;
2146  }
2147 }
2148 
2149 bool QualType::isTrivialType(const ASTContext &Context) const {
2150  // The compiler shouldn't query this for incomplete types, but the user might.
2151  // We return false for that case. Except for incomplete arrays of PODs, which
2152  // are PODs according to the standard.
2153  if (isNull())
2154  return false;
2155 
2156  if ((*this)->isArrayType())
2157  return Context.getBaseElementType(*this).isTrivialType(Context);
2158 
2159  // Return false for incomplete types after skipping any incomplete array
2160  // types which are expressly allowed by the standard and thus our API.
2161  if ((*this)->isIncompleteType())
2162  return false;
2163 
2164  if (hasNonTrivialObjCLifetime())
2165  return false;
2166 
2167  QualType CanonicalType = getTypePtr()->CanonicalType;
2168  if (CanonicalType->isDependentType())
2169  return false;
2170 
2171  // C++0x [basic.types]p9:
2172  // Scalar types, trivial class types, arrays of such types, and
2173  // cv-qualified versions of these types are collectively called trivial
2174  // types.
2175 
2176  // As an extension, Clang treats vector types as Scalar types.
2177  if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
2178  return true;
2179  if (const auto *RT = CanonicalType->getAs<RecordType>()) {
2180  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2181  // C++11 [class]p6:
2182  // A trivial class is a class that has a default constructor,
2183  // has no non-trivial default constructors, and is trivially
2184  // copyable.
2185  return ClassDecl->hasDefaultConstructor() &&
2186  !ClassDecl->hasNonTrivialDefaultConstructor() &&
2187  ClassDecl->isTriviallyCopyable();
2188  }
2189 
2190  return true;
2191  }
2192 
2193  // No other types can match.
2194  return false;
2195 }
2196 
2197 bool QualType::isTriviallyCopyableType(const ASTContext &Context) const {
2198  if ((*this)->isArrayType())
2199  return Context.getBaseElementType(*this).isTriviallyCopyableType(Context);
2200 
2201  if (hasNonTrivialObjCLifetime())
2202  return false;
2203 
2204  // C++11 [basic.types]p9 - See Core 2094
2205  // Scalar types, trivially copyable class types, arrays of such types, and
2206  // cv-qualified versions of these types are collectively
2207  // called trivially copyable types.
2208 
2209  QualType CanonicalType = getCanonicalType();
2210  if (CanonicalType->isDependentType())
2211  return false;
2212 
2213  // Return false for incomplete types after skipping any incomplete array types
2214  // which are expressly allowed by the standard and thus our API.
2215  if (CanonicalType->isIncompleteType())
2216  return false;
2217 
2218  // As an extension, Clang treats vector types as Scalar types.
2219  if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
2220  return true;
2221 
2222  if (const auto *RT = CanonicalType->getAs<RecordType>()) {
2223  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2224  if (!ClassDecl->isTriviallyCopyable()) return false;
2225  }
2226 
2227  return true;
2228  }
2229 
2230  // No other types can match.
2231  return false;
2232 }
2233 
2235  return !Context.getLangOpts().ObjCAutoRefCount &&
2236  Context.getLangOpts().ObjCWeak &&
2237  getObjCLifetime() != Qualifiers::OCL_Weak;
2238 }
2239 
2242  if (const auto *RT =
2243  getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>())
2244  if (RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize())
2245  return PDIK_Struct;
2246 
2247  switch (getQualifiers().getObjCLifetime()) {
2249  return PDIK_ARCStrong;
2250  case Qualifiers::OCL_Weak:
2251  return PDIK_ARCWeak;
2252  default:
2253  return PDIK_Trivial;
2254  }
2255 }
2256 
2258  if (const auto *RT =
2259  getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>())
2260  if (RT->getDecl()->isNonTrivialToPrimitiveCopy())
2261  return PCK_Struct;
2262 
2263  Qualifiers Qs = getQualifiers();
2264  switch (Qs.getObjCLifetime()) {
2266  return PCK_ARCStrong;
2267  case Qualifiers::OCL_Weak:
2268  return PCK_ARCWeak;
2269  default:
2270  return Qs.hasVolatile() ? PCK_VolatileTrivial : PCK_Trivial;
2271  }
2272 }
2273 
2276  return isNonTrivialToPrimitiveCopy();
2277 }
2278 
2279 bool Type::isLiteralType(const ASTContext &Ctx) const {
2280  if (isDependentType())
2281  return false;
2282 
2283  // C++1y [basic.types]p10:
2284  // A type is a literal type if it is:
2285  // -- cv void; or
2286  if (Ctx.getLangOpts().CPlusPlus14 && isVoidType())
2287  return true;
2288 
2289  // C++11 [basic.types]p10:
2290  // A type is a literal type if it is:
2291  // [...]
2292  // -- an array of literal type other than an array of runtime bound; or
2293  if (isVariableArrayType())
2294  return false;
2295  const Type *BaseTy = getBaseElementTypeUnsafe();
2296  assert(BaseTy && "NULL element type");
2297 
2298  // Return false for incomplete types after skipping any incomplete array
2299  // types; those are expressly allowed by the standard and thus our API.
2300  if (BaseTy->isIncompleteType())
2301  return false;
2302 
2303  // C++11 [basic.types]p10:
2304  // A type is a literal type if it is:
2305  // -- a scalar type; or
2306  // As an extension, Clang treats vector types and complex types as
2307  // literal types.
2308  if (BaseTy->isScalarType() || BaseTy->isVectorType() ||
2309  BaseTy->isAnyComplexType())
2310  return true;
2311  // -- a reference type; or
2312  if (BaseTy->isReferenceType())
2313  return true;
2314  // -- a class type that has all of the following properties:
2315  if (const auto *RT = BaseTy->getAs<RecordType>()) {
2316  // -- a trivial destructor,
2317  // -- every constructor call and full-expression in the
2318  // brace-or-equal-initializers for non-static data members (if any)
2319  // is a constant expression,
2320  // -- it is an aggregate type or has at least one constexpr
2321  // constructor or constructor template that is not a copy or move
2322  // constructor, and
2323  // -- all non-static data members and base classes of literal types
2324  //
2325  // We resolve DR1361 by ignoring the second bullet.
2326  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))
2327  return ClassDecl->isLiteral();
2328 
2329  return true;
2330  }
2331 
2332  // We treat _Atomic T as a literal type if T is a literal type.
2333  if (const auto *AT = BaseTy->getAs<AtomicType>())
2334  return AT->getValueType()->isLiteralType(Ctx);
2335 
2336  // If this type hasn't been deduced yet, then conservatively assume that
2337  // it'll work out to be a literal type.
2338  if (isa<AutoType>(BaseTy->getCanonicalTypeInternal()))
2339  return true;
2340 
2341  return false;
2342 }
2343 
2345  if (isDependentType())
2346  return false;
2347 
2348  // C++0x [basic.types]p9:
2349  // Scalar types, standard-layout class types, arrays of such types, and
2350  // cv-qualified versions of these types are collectively called
2351  // standard-layout types.
2352  const Type *BaseTy = getBaseElementTypeUnsafe();
2353  assert(BaseTy && "NULL element type");
2354 
2355  // Return false for incomplete types after skipping any incomplete array
2356  // types which are expressly allowed by the standard and thus our API.
2357  if (BaseTy->isIncompleteType())
2358  return false;
2359 
2360  // As an extension, Clang treats vector types as Scalar types.
2361  if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
2362  if (const auto *RT = BaseTy->getAs<RecordType>()) {
2363  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))
2364  if (!ClassDecl->isStandardLayout())
2365  return false;
2366 
2367  // Default to 'true' for non-C++ class types.
2368  // FIXME: This is a bit dubious, but plain C structs should trivially meet
2369  // all the requirements of standard layout classes.
2370  return true;
2371  }
2372 
2373  // No other types can match.
2374  return false;
2375 }
2376 
2377 // This is effectively the intersection of isTrivialType and
2378 // isStandardLayoutType. We implement it directly to avoid redundant
2379 // conversions from a type to a CXXRecordDecl.
2380 bool QualType::isCXX11PODType(const ASTContext &Context) const {
2381  const Type *ty = getTypePtr();
2382  if (ty->isDependentType())
2383  return false;
2384 
2385  if (hasNonTrivialObjCLifetime())
2386  return false;
2387 
2388  // C++11 [basic.types]p9:
2389  // Scalar types, POD classes, arrays of such types, and cv-qualified
2390  // versions of these types are collectively called trivial types.
2391  const Type *BaseTy = ty->getBaseElementTypeUnsafe();
2392  assert(BaseTy && "NULL element type");
2393 
2394  // Return false for incomplete types after skipping any incomplete array
2395  // types which are expressly allowed by the standard and thus our API.
2396  if (BaseTy->isIncompleteType())
2397  return false;
2398 
2399  // As an extension, Clang treats vector types as Scalar types.
2400  if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
2401  if (const auto *RT = BaseTy->getAs<RecordType>()) {
2402  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
2403  // C++11 [class]p10:
2404  // A POD struct is a non-union class that is both a trivial class [...]
2405  if (!ClassDecl->isTrivial()) return false;
2406 
2407  // C++11 [class]p10:
2408  // A POD struct is a non-union class that is both a trivial class and
2409  // a standard-layout class [...]
2410  if (!ClassDecl->isStandardLayout()) return false;
2411 
2412  // C++11 [class]p10:
2413  // A POD struct is a non-union class that is both a trivial class and
2414  // a standard-layout class, and has no non-static data members of type
2415  // non-POD struct, non-POD union (or array of such types). [...]
2416  //
2417  // We don't directly query the recursive aspect as the requirements for
2418  // both standard-layout classes and trivial classes apply recursively
2419  // already.
2420  }
2421 
2422  return true;
2423  }
2424 
2425  // No other types can match.
2426  return false;
2427 }
2428 
2429 bool Type::isAlignValT() const {
2430  if (const auto *ET = getAs<EnumType>()) {
2431  IdentifierInfo *II = ET->getDecl()->getIdentifier();
2432  if (II && II->isStr("align_val_t") && ET->getDecl()->isInStdNamespace())
2433  return true;
2434  }
2435  return false;
2436 }
2437 
2438 bool Type::isStdByteType() const {
2439  if (const auto *ET = getAs<EnumType>()) {
2440  IdentifierInfo *II = ET->getDecl()->getIdentifier();
2441  if (II && II->isStr("byte") && ET->getDecl()->isInStdNamespace())
2442  return true;
2443  }
2444  return false;
2445 }
2446 
2448  if (const auto *BT = getAs<BuiltinType>())
2449  switch (BT->getKind()) {
2450  case BuiltinType::Bool:
2451  case BuiltinType::Char_S:
2452  case BuiltinType::Char_U:
2453  case BuiltinType::SChar:
2454  case BuiltinType::UChar:
2455  case BuiltinType::Short:
2456  case BuiltinType::UShort:
2457  case BuiltinType::WChar_S:
2458  case BuiltinType::WChar_U:
2459  case BuiltinType::Char8:
2460  case BuiltinType::Char16:
2461  case BuiltinType::Char32:
2462  return true;
2463  default:
2464  return false;
2465  }
2466 
2467  // Enumerated types are promotable to their compatible integer types
2468  // (C99 6.3.1.1) a.k.a. its underlying type (C++ [conv.prom]p2).
2469  if (const auto *ET = getAs<EnumType>()){
2470  if (this->isDependentType() || ET->getDecl()->getPromotionType().isNull()
2471  || ET->getDecl()->isScoped())
2472  return false;
2473 
2474  return true;
2475  }
2476 
2477  return false;
2478 }
2479 
2481  // Note that this intentionally does not use the canonical type.
2482  switch (getTypeClass()) {
2483  case Builtin:
2484  case Record:
2485  case Enum:
2486  case Typedef:
2487  case Complex:
2488  case TypeOfExpr:
2489  case TypeOf:
2490  case TemplateTypeParm:
2491  case SubstTemplateTypeParm:
2492  case TemplateSpecialization:
2493  case Elaborated:
2494  case DependentName:
2495  case DependentTemplateSpecialization:
2496  case ObjCInterface:
2497  case ObjCObject:
2498  case ObjCObjectPointer: // FIXME: object pointers aren't really specifiers
2499  return true;
2500  default:
2501  return false;
2502  }
2503 }
2504 
2507  switch (TypeSpec) {
2508  default: return ETK_None;
2509  case TST_typename: return ETK_Typename;
2510  case TST_class: return ETK_Class;
2511  case TST_struct: return ETK_Struct;
2512  case TST_interface: return ETK_Interface;
2513  case TST_union: return ETK_Union;
2514  case TST_enum: return ETK_Enum;
2515  }
2516 }
2517 
2520  switch(TypeSpec) {
2521  case TST_class: return TTK_Class;
2522  case TST_struct: return TTK_Struct;
2523  case TST_interface: return TTK_Interface;
2524  case TST_union: return TTK_Union;
2525  case TST_enum: return TTK_Enum;
2526  }
2527 
2528  llvm_unreachable("Type specifier is not a tag type kind.");
2529 }
2530 
2533  switch (Kind) {
2534  case TTK_Class: return ETK_Class;
2535  case TTK_Struct: return ETK_Struct;
2536  case TTK_Interface: return ETK_Interface;
2537  case TTK_Union: return ETK_Union;
2538  case TTK_Enum: return ETK_Enum;
2539  }
2540  llvm_unreachable("Unknown tag type kind.");
2541 }
2542 
2545  switch (Keyword) {
2546  case ETK_Class: return TTK_Class;
2547  case ETK_Struct: return TTK_Struct;
2548  case ETK_Interface: return TTK_Interface;
2549  case ETK_Union: return TTK_Union;
2550  case ETK_Enum: return TTK_Enum;
2551  case ETK_None: // Fall through.
2552  case ETK_Typename:
2553  llvm_unreachable("Elaborated type keyword is not a tag type kind.");
2554  }
2555  llvm_unreachable("Unknown elaborated type keyword.");
2556 }
2557 
2558 bool
2560  switch (Keyword) {
2561  case ETK_None:
2562  case ETK_Typename:
2563  return false;
2564  case ETK_Class:
2565  case ETK_Struct:
2566  case ETK_Interface:
2567  case ETK_Union:
2568  case ETK_Enum:
2569  return true;
2570  }
2571  llvm_unreachable("Unknown elaborated type keyword.");
2572 }
2573 
2575  switch (Keyword) {
2576  case ETK_None: return {};
2577  case ETK_Typename: return "typename";
2578  case ETK_Class: return "class";
2579  case ETK_Struct: return "struct";
2580  case ETK_Interface: return "__interface";
2581  case ETK_Union: return "union";
2582  case ETK_Enum: return "enum";
2583  }
2584 
2585  llvm_unreachable("Unknown elaborated type keyword.");
2586 }
2587 
2588 DependentTemplateSpecializationType::DependentTemplateSpecializationType(
2589  ElaboratedTypeKeyword Keyword,
2590  NestedNameSpecifier *NNS, const IdentifierInfo *Name,
2592  QualType Canon)
2593  : TypeWithKeyword(Keyword, DependentTemplateSpecialization, Canon, true, true,
2594  /*VariablyModified=*/false,
2595  NNS && NNS->containsUnexpandedParameterPack()),
2596  NNS(NNS), Name(Name) {
2597  DependentTemplateSpecializationTypeBits.NumArgs = Args.size();
2598  assert((!NNS || NNS->isDependent()) &&
2599  "DependentTemplateSpecializatonType requires dependent qualifier");
2600  TemplateArgument *ArgBuffer = getArgBuffer();
2601  for (const TemplateArgument &Arg : Args) {
2602  if (Arg.containsUnexpandedParameterPack())
2604 
2605  new (ArgBuffer++) TemplateArgument(Arg);
2606  }
2607 }
2608 
2609 void
2611  const ASTContext &Context,
2612  ElaboratedTypeKeyword Keyword,
2613  NestedNameSpecifier *Qualifier,
2614  const IdentifierInfo *Name,
2616  ID.AddInteger(Keyword);
2617  ID.AddPointer(Qualifier);
2618  ID.AddPointer(Name);
2619  for (const TemplateArgument &Arg : Args)
2620  Arg.Profile(ID, Context);
2621 }
2622 
2624  ElaboratedTypeKeyword Keyword;
2625  if (const auto *Elab = dyn_cast<ElaboratedType>(this))
2626  Keyword = Elab->getKeyword();
2627  else if (const auto *DepName = dyn_cast<DependentNameType>(this))
2628  Keyword = DepName->getKeyword();
2629  else if (const auto *DepTST =
2630  dyn_cast<DependentTemplateSpecializationType>(this))
2631  Keyword = DepTST->getKeyword();
2632  else
2633  return false;
2634 
2635  return TypeWithKeyword::KeywordIsTagTypeKind(Keyword);
2636 }
2637 
2638 const char *Type::getTypeClassName() const {
2639  switch (TypeBits.TC) {
2640 #define ABSTRACT_TYPE(Derived, Base)
2641 #define TYPE(Derived, Base) case Derived: return #Derived;
2642 #include "clang/AST/TypeNodes.def"
2643  }
2644 
2645  llvm_unreachable("Invalid type class.");
2646 }
2647 
2648 StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
2649  switch (getKind()) {
2650  case Void:
2651  return "void";
2652  case Bool:
2653  return Policy.Bool ? "bool" : "_Bool";
2654  case Char_S:
2655  return "char";
2656  case Char_U:
2657  return "char";
2658  case SChar:
2659  return "signed char";
2660  case Short:
2661  return "short";
2662  case Int:
2663  return "int";
2664  case Long:
2665  return "long";
2666  case LongLong:
2667  return "long long";
2668  case Int128:
2669  return "__int128";
2670  case UChar:
2671  return "unsigned char";
2672  case UShort:
2673  return "unsigned short";
2674  case UInt:
2675  return "unsigned int";
2676  case ULong:
2677  return "unsigned long";
2678  case ULongLong:
2679  return "unsigned long long";
2680  case UInt128:
2681  return "unsigned __int128";
2682  case Half:
2683  return Policy.Half ? "half" : "__fp16";
2684  case Float:
2685  return "float";
2686  case Double:
2687  return "double";
2688  case LongDouble:
2689  return "long double";
2690  case ShortAccum:
2691  return "short _Accum";
2692  case Accum:
2693  return "_Accum";
2694  case LongAccum:
2695  return "long _Accum";
2696  case UShortAccum:
2697  return "unsigned short _Accum";
2698  case UAccum:
2699  return "unsigned _Accum";
2700  case ULongAccum:
2701  return "unsigned long _Accum";
2702  case BuiltinType::ShortFract:
2703  return "short _Fract";
2704  case BuiltinType::Fract:
2705  return "_Fract";
2706  case BuiltinType::LongFract:
2707  return "long _Fract";
2708  case BuiltinType::UShortFract:
2709  return "unsigned short _Fract";
2710  case BuiltinType::UFract:
2711  return "unsigned _Fract";
2712  case BuiltinType::ULongFract:
2713  return "unsigned long _Fract";
2714  case BuiltinType::SatShortAccum:
2715  return "_Sat short _Accum";
2716  case BuiltinType::SatAccum:
2717  return "_Sat _Accum";
2718  case BuiltinType::SatLongAccum:
2719  return "_Sat long _Accum";
2720  case BuiltinType::SatUShortAccum:
2721  return "_Sat unsigned short _Accum";
2722  case BuiltinType::SatUAccum:
2723  return "_Sat unsigned _Accum";
2724  case BuiltinType::SatULongAccum:
2725  return "_Sat unsigned long _Accum";
2726  case BuiltinType::SatShortFract:
2727  return "_Sat short _Fract";
2728  case BuiltinType::SatFract:
2729  return "_Sat _Fract";
2730  case BuiltinType::SatLongFract:
2731  return "_Sat long _Fract";
2732  case BuiltinType::SatUShortFract:
2733  return "_Sat unsigned short _Fract";
2734  case BuiltinType::SatUFract:
2735  return "_Sat unsigned _Fract";
2736  case BuiltinType::SatULongFract:
2737  return "_Sat unsigned long _Fract";
2738  case Float16:
2739  return "_Float16";
2740  case Float128:
2741  return "__float128";
2742  case WChar_S:
2743  case WChar_U:
2744  return Policy.MSWChar ? "__wchar_t" : "wchar_t";
2745  case Char8:
2746  return "char8_t";
2747  case Char16:
2748  return "char16_t";
2749  case Char32:
2750  return "char32_t";
2751  case NullPtr:
2752  return "nullptr_t";
2753  case Overload:
2754  return "<overloaded function type>";
2755  case BoundMember:
2756  return "<bound member function type>";
2757  case PseudoObject:
2758  return "<pseudo-object type>";
2759  case Dependent:
2760  return "<dependent type>";
2761  case UnknownAny:
2762  return "<unknown type>";
2763  case ARCUnbridgedCast:
2764  return "<ARC unbridged cast type>";
2765  case BuiltinFn:
2766  return "<builtin fn type>";
2767  case ObjCId:
2768  return "id";
2769  case ObjCClass:
2770  return "Class";
2771  case ObjCSel:
2772  return "SEL";
2773 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2774  case Id: \
2775  return "__" #Access " " #ImgType "_t";
2776 #include "clang/Basic/OpenCLImageTypes.def"
2777  case OCLSampler:
2778  return "sampler_t";
2779  case OCLEvent:
2780  return "event_t";
2781  case OCLClkEvent:
2782  return "clk_event_t";
2783  case OCLQueue:
2784  return "queue_t";
2785  case OCLReserveID:
2786  return "reserve_id_t";
2787  case OMPArraySection:
2788  return "<OpenMP array section type>";
2789 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2790  case Id: \
2791  return #ExtType;
2792 #include "clang/Basic/OpenCLExtensionTypes.def"
2793  }
2794 
2795  llvm_unreachable("Invalid builtin type.");
2796 }
2797 
2799  if (const auto *RefType = getTypePtr()->getAs<ReferenceType>())
2800  return RefType->getPointeeType();
2801 
2802  // C++0x [basic.lval]:
2803  // Class prvalues can have cv-qualified types; non-class prvalues always
2804  // have cv-unqualified types.
2805  //
2806  // See also C99 6.3.2.1p2.
2807  if (!Context.getLangOpts().CPlusPlus ||
2808  (!getTypePtr()->isDependentType() && !getTypePtr()->isRecordType()))
2809  return getUnqualifiedType();
2810 
2811  return *this;
2812 }
2813 
2815  switch (CC) {
2816  case CC_C: return "cdecl";
2817  case CC_X86StdCall: return "stdcall";
2818  case CC_X86FastCall: return "fastcall";
2819  case CC_X86ThisCall: return "thiscall";
2820  case CC_X86Pascal: return "pascal";
2821  case CC_X86VectorCall: return "vectorcall";
2822  case CC_Win64: return "ms_abi";
2823  case CC_X86_64SysV: return "sysv_abi";
2824  case CC_X86RegCall : return "regcall";
2825  case CC_AAPCS: return "aapcs";
2826  case CC_AAPCS_VFP: return "aapcs-vfp";
2827  case CC_IntelOclBicc: return "intel_ocl_bicc";
2828  case CC_SpirFunction: return "spir_function";
2829  case CC_OpenCLKernel: return "opencl_kernel";
2830  case CC_Swift: return "swiftcall";
2831  case CC_PreserveMost: return "preserve_most";
2832  case CC_PreserveAll: return "preserve_all";
2833  }
2834 
2835  llvm_unreachable("Invalid calling convention.");
2836 }
2837 
2838 FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
2839  QualType canonical,
2840  const ExtProtoInfo &epi)
2841  : FunctionType(FunctionProto, result, canonical, result->isDependentType(),
2842  result->isInstantiationDependentType(),
2843  result->isVariablyModifiedType(),
2844  result->containsUnexpandedParameterPack(), epi.ExtInfo) {
2845  FunctionTypeBits.TypeQuals = epi.TypeQuals;
2846  FunctionTypeBits.RefQualifier = epi.RefQualifier;
2847  FunctionTypeBits.NumParams = params.size();
2848  assert(getNumParams() == params.size() && "NumParams overflow!");
2849  FunctionTypeBits.ExceptionSpecType = epi.ExceptionSpec.Type;
2850  FunctionTypeBits.HasExtParameterInfos = !!epi.ExtParameterInfos;
2851  FunctionTypeBits.Variadic = epi.Variadic;
2852  FunctionTypeBits.HasTrailingReturn = epi.HasTrailingReturn;
2853 
2854  // Fill in the extra trailing bitfields if present.
2855  if (hasExtraBitfields(epi.ExceptionSpec.Type)) {
2856  auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
2857  ExtraBits.NumExceptionType = epi.ExceptionSpec.Exceptions.size();
2858  }
2859 
2860  // Fill in the trailing argument array.
2861  auto *argSlot = getTrailingObjects<QualType>();
2862  for (unsigned i = 0; i != getNumParams(); ++i) {
2863  if (params[i]->isDependentType())
2864  setDependent();
2865  else if (params[i]->isInstantiationDependentType())
2867 
2868  if (params[i]->containsUnexpandedParameterPack())
2870 
2871  argSlot[i] = params[i];
2872  }
2873 
2874  // Fill in the exception type array if present.
2875  if (getExceptionSpecType() == EST_Dynamic) {
2876  assert(hasExtraBitfields() && "missing trailing extra bitfields!");
2877  auto *exnSlot =
2878  reinterpret_cast<QualType *>(getTrailingObjects<ExceptionType>());
2879  unsigned I = 0;
2880  for (QualType ExceptionType : epi.ExceptionSpec.Exceptions) {
2881  // Note that, before C++17, a dependent exception specification does
2882  // *not* make a type dependent; it's not even part of the C++ type
2883  // system.
2884  if (ExceptionType->isInstantiationDependentType())
2886 
2887  if (ExceptionType->containsUnexpandedParameterPack())
2889 
2890  exnSlot[I++] = ExceptionType;
2891  }
2892  }
2893  // Fill in the Expr * in the exception specification if present.
2894  else if (isComputedNoexcept(getExceptionSpecType())) {
2895  assert(epi.ExceptionSpec.NoexceptExpr && "computed noexcept with no expr");
2896  assert((getExceptionSpecType() == EST_DependentNoexcept) ==
2897  epi.ExceptionSpec.NoexceptExpr->isValueDependent());
2898 
2899  // Store the noexcept expression and context.
2900  *getTrailingObjects<Expr *>() = epi.ExceptionSpec.NoexceptExpr;
2901 
2902  if (epi.ExceptionSpec.NoexceptExpr->isValueDependent() ||
2903  epi.ExceptionSpec.NoexceptExpr->isInstantiationDependent())
2905 
2906  if (epi.ExceptionSpec.NoexceptExpr->containsUnexpandedParameterPack())
2908  }
2909  // Fill in the FunctionDecl * in the exception specification if present.
2910  else if (getExceptionSpecType() == EST_Uninstantiated) {
2911  // Store the function decl from which we will resolve our
2912  // exception specification.
2913  auto **slot = getTrailingObjects<FunctionDecl *>();
2914  slot[0] = epi.ExceptionSpec.SourceDecl;
2915  slot[1] = epi.ExceptionSpec.SourceTemplate;
2916  // This exception specification doesn't make the type dependent, because
2917  // it's not instantiated as part of instantiating the type.
2918  } else if (getExceptionSpecType() == EST_Unevaluated) {
2919  // Store the function decl from which we will resolve our
2920  // exception specification.
2921  auto **slot = getTrailingObjects<FunctionDecl *>();
2922  slot[0] = epi.ExceptionSpec.SourceDecl;
2923  }
2924 
2925  // If this is a canonical type, and its exception specification is dependent,
2926  // then it's a dependent type. This only happens in C++17 onwards.
2927  if (isCanonicalUnqualified()) {
2928  if (getExceptionSpecType() == EST_Dynamic ||
2929  getExceptionSpecType() == EST_DependentNoexcept) {
2930  assert(hasDependentExceptionSpec() && "type should not be canonical");
2931  setDependent();
2932  }
2933  } else if (getCanonicalTypeInternal()->isDependentType()) {
2934  // Ask our canonical type whether our exception specification was dependent.
2935  setDependent();
2936  }
2937 
2938  // Fill in the extra parameter info if present.
2939  if (epi.ExtParameterInfos) {
2940  auto *extParamInfos = getTrailingObjects<ExtParameterInfo>();
2941  for (unsigned i = 0; i != getNumParams(); ++i)
2942  extParamInfos[i] = epi.ExtParameterInfos[i];
2943  }
2944 }
2945 
2947  if (Expr *NE = getNoexceptExpr())
2948  return NE->isValueDependent();
2949  for (QualType ET : exceptions())
2950  // A pack expansion with a non-dependent pattern is still dependent,
2951  // because we don't know whether the pattern is in the exception spec
2952  // or not (that depends on whether the pack has 0 expansions).
2953  if (ET->isDependentType() || ET->getAs<PackExpansionType>())
2954  return true;
2955  return false;
2956 }
2957 
2959  if (Expr *NE = getNoexceptExpr())
2960  return NE->isInstantiationDependent();
2961  for (QualType ET : exceptions())
2962  if (ET->isInstantiationDependentType())
2963  return true;
2964  return false;
2965 }
2966 
2968  switch (getExceptionSpecType()) {
2969  case EST_Unparsed:
2970  case EST_Unevaluated:
2971  case EST_Uninstantiated:
2972  llvm_unreachable("should not call this with unresolved exception specs");
2973 
2974  case EST_DynamicNone:
2975  case EST_BasicNoexcept:
2976  case EST_NoexceptTrue:
2977  return CT_Cannot;
2978 
2979  case EST_None:
2980  case EST_MSAny:
2981  case EST_NoexceptFalse:
2982  return CT_Can;
2983 
2984  case EST_Dynamic:
2985  // A dynamic exception specification is throwing unless every exception
2986  // type is an (unexpanded) pack expansion type.
2987  for (unsigned I = 0; I != getNumExceptions(); ++I)
2988  if (!getExceptionType(I)->getAs<PackExpansionType>())
2989  return CT_Can;
2990  return CT_Dependent;
2991 
2992  case EST_DependentNoexcept:
2993  return CT_Dependent;
2994  }
2995 
2996  llvm_unreachable("unexpected exception specification kind");
2997 }
2998 
3000  for (unsigned ArgIdx = getNumParams(); ArgIdx; --ArgIdx)
3001  if (isa<PackExpansionType>(getParamType(ArgIdx - 1)))
3002  return true;
3003 
3004  return false;
3005 }
3006 
3007 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
3008  const QualType *ArgTys, unsigned NumParams,
3009  const ExtProtoInfo &epi,
3010  const ASTContext &Context, bool Canonical) {
3011  // We have to be careful not to get ambiguous profile encodings.
3012  // Note that valid type pointers are never ambiguous with anything else.
3013  //
3014  // The encoding grammar begins:
3015  // type type* bool int bool
3016  // If that final bool is true, then there is a section for the EH spec:
3017  // bool type*
3018  // This is followed by an optional "consumed argument" section of the
3019  // same length as the first type sequence:
3020  // bool*
3021  // Finally, we have the ext info and trailing return type flag:
3022  // int bool
3023  //
3024  // There is no ambiguity between the consumed arguments and an empty EH
3025  // spec because of the leading 'bool' which unambiguously indicates
3026  // whether the following bool is the EH spec or part of the arguments.
3027 
3028  ID.AddPointer(Result.getAsOpaquePtr());
3029  for (unsigned i = 0; i != NumParams; ++i)
3030  ID.AddPointer(ArgTys[i].getAsOpaquePtr());
3031  // This method is relatively performance sensitive, so as a performance
3032  // shortcut, use one AddInteger call instead of four for the next four
3033  // fields.
3034  assert(!(unsigned(epi.Variadic) & ~1) &&
3035  !(unsigned(epi.TypeQuals) & ~255) &&
3036  !(unsigned(epi.RefQualifier) & ~3) &&
3037  !(unsigned(epi.ExceptionSpec.Type) & ~15) &&
3038  "Values larger than expected.");
3039  ID.AddInteger(unsigned(epi.Variadic) +
3040  (epi.TypeQuals << 1) +
3041  (epi.RefQualifier << 9) +
3042  (epi.ExceptionSpec.Type << 11));
3043  if (epi.ExceptionSpec.Type == EST_Dynamic) {
3044  for (QualType Ex : epi.ExceptionSpec.Exceptions)
3045  ID.AddPointer(Ex.getAsOpaquePtr());
3046  } else if (isComputedNoexcept(epi.ExceptionSpec.Type)) {
3047  epi.ExceptionSpec.NoexceptExpr->Profile(ID, Context, Canonical);
3048  } else if (epi.ExceptionSpec.Type == EST_Uninstantiated ||
3050  ID.AddPointer(epi.ExceptionSpec.SourceDecl->getCanonicalDecl());
3051  }
3052  if (epi.ExtParameterInfos) {
3053  for (unsigned i = 0; i != NumParams; ++i)
3054  ID.AddInteger(epi.ExtParameterInfos[i].getOpaqueValue());
3055  }
3056  epi.ExtInfo.Profile(ID);
3057  ID.AddBoolean(epi.HasTrailingReturn);
3058 }
3059 
3060 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID,
3061  const ASTContext &Ctx) {
3062  Profile(ID, getReturnType(), param_type_begin(), getNumParams(),
3063  getExtProtoInfo(), Ctx, isCanonicalUnqualified());
3064 }
3065 
3067  return getDecl()->getUnderlyingType();
3068 }
3069 
3071  : Type(TypeOfExpr, can, E->isTypeDependent(),
3072  E->isInstantiationDependent(),
3073  E->getType()->isVariablyModifiedType(),
3075  TOExpr(E) {}
3076 
3078  return !TOExpr->isTypeDependent();
3079 }
3080 
3082  if (isSugared())
3083  return getUnderlyingExpr()->getType();
3084 
3085  return QualType(this, 0);
3086 }
3087 
3088 void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID,
3089  const ASTContext &Context, Expr *E) {
3090  E->Profile(ID, Context, true);
3091 }
3092 
3094  // C++11 [temp.type]p2: "If an expression e involves a template parameter,
3095  // decltype(e) denotes a unique dependent type." Hence a decltype type is
3096  // type-dependent even if its expression is only instantiation-dependent.
3097  : Type(Decltype, can, E->isInstantiationDependent(),
3098  E->isInstantiationDependent(),
3099  E->getType()->isVariablyModifiedType(),
3101  E(E), UnderlyingType(underlyingType) {}
3102 
3104 
3106  if (isSugared())
3107  return getUnderlyingType();
3108 
3109  return QualType(this, 0);
3110 }
3111 
3113  : DecltypeType(E, Context.DependentTy), Context(Context) {}
3114 
3115 void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID,
3116  const ASTContext &Context, Expr *E) {
3117  E->Profile(ID, Context, true);
3118 }
3119 
3121  QualType UnderlyingType,
3122  UTTKind UKind,
3123  QualType CanonicalType)
3124  : Type(UnaryTransform, CanonicalType, BaseType->isDependentType(),
3125  BaseType->isInstantiationDependentType(),
3126  BaseType->isVariablyModifiedType(),
3127  BaseType->containsUnexpandedParameterPack()),
3128  BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind) {}
3129 
3131  QualType BaseType,
3132  UTTKind UKind)
3133  : UnaryTransformType(BaseType, C.DependentTy, UKind, QualType()) {}
3134 
3136  : Type(TC, can, D->isDependentType(),
3137  /*InstantiationDependent=*/D->isDependentType(),
3138  /*VariablyModified=*/false,
3139  /*ContainsUnexpandedParameterPack=*/false),
3140  decl(const_cast<TagDecl*>(D)) {}
3141 
3143  for (auto I : decl->redecls()) {
3144  if (I->isCompleteDefinition() || I->isBeingDefined())
3145  return I;
3146  }
3147  // If there's no definition (not even in progress), return what we have.
3148  return decl;
3149 }
3150 
3152  return getInterestingTagDecl(decl);
3153 }
3154 
3156  return getDecl()->isBeingDefined();
3157 }
3158 
3160  for (FieldDecl *FD : getDecl()->fields()) {
3161  QualType FieldTy = FD->getType();
3162  if (FieldTy.isConstQualified())
3163  return true;
3164  FieldTy = FieldTy.getCanonicalType();
3165  if (const auto *FieldRecTy = FieldTy->getAs<RecordType>())
3166  if (FieldRecTy->hasConstFields())
3167  return true;
3168  }
3169  return false;
3170 }
3171 
3173  // FIXME: Generate this with TableGen.
3174  switch (getAttrKind()) {
3175  // These are type qualifiers in the traditional C sense: they annotate
3176  // something about a specific value/variable of a type. (They aren't
3177  // always part of the canonical type, though.)
3178  case attr::ObjCGC:
3179  case attr::ObjCOwnership:
3180  case attr::ObjCInertUnsafeUnretained:
3181  case attr::TypeNonNull:
3182  case attr::TypeNullable:
3183  case attr::TypeNullUnspecified:
3184  case attr::LifetimeBound:
3185  return true;
3186 
3187  // All other type attributes aren't qualifiers; they rewrite the modified
3188  // type to be a semantically different type.
3189  default:
3190  return false;
3191  }
3192 }
3193 
3195  // FIXME: Generate this with TableGen?
3196  switch (getAttrKind()) {
3197  default: return false;
3198  case attr::Ptr32:
3199  case attr::Ptr64:
3200  case attr::SPtr:
3201  case attr::UPtr:
3202  return true;
3203  }
3204  llvm_unreachable("invalid attr kind");
3205 }
3206 
3208  // FIXME: Generate this with TableGen.
3209  switch (getAttrKind()) {
3210  default: return false;
3211  case attr::Pcs:
3212  case attr::CDecl:
3213  case attr::FastCall:
3214  case attr::StdCall:
3215  case attr::ThisCall:
3216  case attr::RegCall:
3217  case attr::SwiftCall:
3218  case attr::VectorCall:
3219  case attr::Pascal:
3220  case attr::MSABI:
3221  case attr::SysVABI:
3222  case attr::IntelOclBicc:
3223  case attr::PreserveMost:
3224  case attr::PreserveAll:
3225  return true;
3226  }
3227  llvm_unreachable("invalid attr kind");
3228 }
3229 
3231  return cast<CXXRecordDecl>(getInterestingTagDecl(Decl));
3232 }
3233 
3235  return isCanonicalUnqualified() ? nullptr : getDecl()->getIdentifier();
3236 }
3237 
3238 SubstTemplateTypeParmPackType::
3239 SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
3240  QualType Canon,
3241  const TemplateArgument &ArgPack)
3242  : Type(SubstTemplateTypeParmPack, Canon, true, true, false, true),
3243  Replaced(Param), Arguments(ArgPack.pack_begin()) {
3244  SubstTemplateTypeParmPackTypeBits.NumArgs = ArgPack.pack_size();
3245 }
3246 
3248  return TemplateArgument(llvm::makeArrayRef(Arguments, getNumArgs()));
3249 }
3250 
3251 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
3252  Profile(ID, getReplacedParameter(), getArgumentPack());
3253 }
3254 
3255 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
3256  const TemplateTypeParmType *Replaced,
3257  const TemplateArgument &ArgPack) {
3258  ID.AddPointer(Replaced);
3259  ID.AddInteger(ArgPack.pack_size());
3260  for (const auto &P : ArgPack.pack_elements())
3261  ID.AddPointer(P.getAsType().getAsOpaquePtr());
3262 }
3263 
3266  bool &InstantiationDependent) {
3267  return anyDependentTemplateArguments(Args.arguments(),
3268  InstantiationDependent);
3269 }
3270 
3273  bool &InstantiationDependent) {
3274  for (const TemplateArgumentLoc &ArgLoc : Args) {
3275  if (ArgLoc.getArgument().isDependent()) {
3276  InstantiationDependent = true;
3277  return true;
3278  }
3279 
3280  if (ArgLoc.getArgument().isInstantiationDependent())
3281  InstantiationDependent = true;
3282  }
3283  return false;
3284 }
3285 
3286 TemplateSpecializationType::
3287 TemplateSpecializationType(TemplateName T,
3289  QualType Canon, QualType AliasedType)
3290  : Type(TemplateSpecialization,
3291  Canon.isNull()? QualType(this, 0) : Canon,
3292  Canon.isNull()? true : Canon->isDependentType(),
3293  Canon.isNull()? true : Canon->isInstantiationDependentType(),
3294  false,
3295  T.containsUnexpandedParameterPack()), Template(T) {
3296  TemplateSpecializationTypeBits.NumArgs = Args.size();
3297  TemplateSpecializationTypeBits.TypeAlias = !AliasedType.isNull();
3298 
3299  assert(!T.getAsDependentTemplateName() &&
3300  "Use DependentTemplateSpecializationType for dependent template-name");
3301  assert((T.getKind() == TemplateName::Template ||
3304  "Unexpected template name for TemplateSpecializationType");
3305 
3306  auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1);
3307  for (const TemplateArgument &Arg : Args) {
3308  // Update instantiation-dependent and variably-modified bits.
3309  // If the canonical type exists and is non-dependent, the template
3310  // specialization type can be non-dependent even if one of the type
3311  // arguments is. Given:
3312  // template<typename T> using U = int;
3313  // U<T> is always non-dependent, irrespective of the type T.
3314  // However, U<Ts> contains an unexpanded parameter pack, even though
3315  // its expansion (and thus its desugared type) doesn't.
3316  if (Arg.isInstantiationDependent())
3318  if (Arg.getKind() == TemplateArgument::Type &&
3319  Arg.getAsType()->isVariablyModifiedType())
3321  if (Arg.containsUnexpandedParameterPack())
3323  new (TemplateArgs++) TemplateArgument(Arg);
3324  }
3325 
3326  // Store the aliased type if this is a type alias template specialization.
3327  if (isTypeAlias()) {
3328  auto *Begin = reinterpret_cast<TemplateArgument *>(this + 1);
3329  *reinterpret_cast<QualType*>(Begin + getNumArgs()) = AliasedType;
3330  }
3331 }
3332 
3333 void
3334 TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
3335  TemplateName T,
3337  const ASTContext &Context) {
3338  T.Profile(ID);
3339  for (const TemplateArgument &Arg : Args)
3340  Arg.Profile(ID, Context);
3341 }
3342 
3343 QualType
3344 QualifierCollector::apply(const ASTContext &Context, QualType QT) const {
3345  if (!hasNonFastQualifiers())
3346  return QT.withFastQualifiers(getFastQualifiers());
3347 
3348  return Context.getQualifiedType(QT, *this);
3349 }
3350 
3351 QualType
3352 QualifierCollector::apply(const ASTContext &Context, const Type *T) const {
3353  if (!hasNonFastQualifiers())
3354  return QualType(T, getFastQualifiers());
3355 
3356  return Context.getQualifiedType(T, *this);
3357 }
3358 
3359 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID,
3360  QualType BaseType,
3361  ArrayRef<QualType> typeArgs,
3362  ArrayRef<ObjCProtocolDecl *> protocols,
3363  bool isKindOf) {
3364  ID.AddPointer(BaseType.getAsOpaquePtr());
3365  ID.AddInteger(typeArgs.size());
3366  for (auto typeArg : typeArgs)
3367  ID.AddPointer(typeArg.getAsOpaquePtr());
3368  ID.AddInteger(protocols.size());
3369  for (auto proto : protocols)
3370  ID.AddPointer(proto);
3371  ID.AddBoolean(isKindOf);
3372 }
3373 
3374 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) {
3375  Profile(ID, getBaseType(), getTypeArgsAsWritten(),
3376  llvm::makeArrayRef(qual_begin(), getNumProtocols()),
3377  isKindOfTypeAsWritten());
3378 }
3379 
3380 void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID,
3381  const ObjCTypeParamDecl *OTPDecl,
3382  ArrayRef<ObjCProtocolDecl *> protocols) {
3383  ID.AddPointer(OTPDecl);
3384  ID.AddInteger(protocols.size());
3385  for (auto proto : protocols)
3386  ID.AddPointer(proto);
3387 }
3388 
3389 void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID) {
3390  Profile(ID, getDecl(),
3391  llvm::makeArrayRef(qual_begin(), getNumProtocols()));
3392 }
3393 
3394 namespace {
3395 
3396 /// The cached properties of a type.
3397 class CachedProperties {
3398  Linkage L;
3399  bool local;
3400 
3401 public:
3402  CachedProperties(Linkage L, bool local) : L(L), local(local) {}
3403 
3404  Linkage getLinkage() const { return L; }
3405  bool hasLocalOrUnnamedType() const { return local; }
3406 
3407  friend CachedProperties merge(CachedProperties L, CachedProperties R) {
3408  Linkage MergedLinkage = minLinkage(L.L, R.L);
3409  return CachedProperties(MergedLinkage,
3410  L.hasLocalOrUnnamedType() | R.hasLocalOrUnnamedType());
3411  }
3412 };
3413 
3414 } // namespace
3415 
3416 static CachedProperties computeCachedProperties(const Type *T);
3417 
3418 namespace clang {
3419 
3420 /// The type-property cache. This is templated so as to be
3421 /// instantiated at an internal type to prevent unnecessary symbol
3422 /// leakage.
3423 template <class Private> class TypePropertyCache {
3424 public:
3425  static CachedProperties get(QualType T) {
3426  return get(T.getTypePtr());
3427  }
3428 
3429  static CachedProperties get(const Type *T) {
3430  ensure(T);
3431  return CachedProperties(T->TypeBits.getLinkage(),
3432  T->TypeBits.hasLocalOrUnnamedType());
3433  }
3434 
3435  static void ensure(const Type *T) {
3436  // If the cache is valid, we're okay.
3437  if (T->TypeBits.isCacheValid()) return;
3438 
3439  // If this type is non-canonical, ask its canonical type for the
3440  // relevant information.
3441  if (!T->isCanonicalUnqualified()) {
3442  const Type *CT = T->getCanonicalTypeInternal().getTypePtr();
3443  ensure(CT);
3444  T->TypeBits.CacheValid = true;
3445  T->TypeBits.CachedLinkage = CT->TypeBits.CachedLinkage;
3446  T->TypeBits.CachedLocalOrUnnamed = CT->TypeBits.CachedLocalOrUnnamed;
3447  return;
3448  }
3449 
3450  // Compute the cached properties and then set the cache.
3451  CachedProperties Result = computeCachedProperties(T);
3452  T->TypeBits.CacheValid = true;
3453  T->TypeBits.CachedLinkage = Result.getLinkage();
3454  T->TypeBits.CachedLocalOrUnnamed = Result.hasLocalOrUnnamedType();
3455  }
3456 };
3457 
3458 } // namespace clang
3459 
3460 // Instantiate the friend template at a private class. In a
3461 // reasonable implementation, these symbols will be internal.
3462 // It is terrible that this is the best way to accomplish this.
3463 namespace {
3464 
3465 class Private {};
3466 
3467 } // namespace
3468 
3470 
3471 static CachedProperties computeCachedProperties(const Type *T) {
3472  switch (T->getTypeClass()) {
3473 #define TYPE(Class,Base)
3474 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
3475 #include "clang/AST/TypeNodes.def"
3476  llvm_unreachable("didn't expect a non-canonical type here");
3477 
3478 #define TYPE(Class,Base)
3479 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
3480 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
3481 #include "clang/AST/TypeNodes.def"
3482  // Treat instantiation-dependent types as external.
3483  assert(T->isInstantiationDependentType());
3484  return CachedProperties(ExternalLinkage, false);
3485 
3486  case Type::Auto:
3487  case Type::DeducedTemplateSpecialization:
3488  // Give non-deduced 'auto' types external linkage. We should only see them
3489  // here in error recovery.
3490  return CachedProperties(ExternalLinkage, false);
3491 
3492  case Type::Builtin:
3493  // C++ [basic.link]p8:
3494  // A type is said to have linkage if and only if:
3495  // - it is a fundamental type (3.9.1); or
3496  return CachedProperties(ExternalLinkage, false);
3497 
3498  case Type::Record:
3499  case Type::Enum: {
3500  const TagDecl *Tag = cast<TagType>(T)->getDecl();
3501 
3502  // C++ [basic.link]p8:
3503  // - it is a class or enumeration type that is named (or has a name
3504  // for linkage purposes (7.1.3)) and the name has linkage; or
3505  // - it is a specialization of a class template (14); or
3506  Linkage L = Tag->getLinkageInternal();
3507  bool IsLocalOrUnnamed =
3508  Tag->getDeclContext()->isFunctionOrMethod() ||
3509  !Tag->hasNameForLinkage();
3510  return CachedProperties(L, IsLocalOrUnnamed);
3511  }
3512 
3513  // C++ [basic.link]p8:
3514  // - it is a compound type (3.9.2) other than a class or enumeration,
3515  // compounded exclusively from types that have linkage; or
3516  case Type::Complex:
3517  return Cache::get(cast<ComplexType>(T)->getElementType());
3518  case Type::Pointer:
3519  return Cache::get(cast<PointerType>(T)->getPointeeType());
3520  case Type::BlockPointer:
3521  return Cache::get(cast<BlockPointerType>(T)->getPointeeType());
3522  case Type::LValueReference:
3523  case Type::RValueReference:
3524  return Cache::get(cast<ReferenceType>(T)->getPointeeType());
3525  case Type::MemberPointer: {
3526  const auto *MPT = cast<MemberPointerType>(T);
3527  return merge(Cache::get(MPT->getClass()),
3528  Cache::get(MPT->getPointeeType()));
3529  }
3530  case Type::ConstantArray:
3531  case Type::IncompleteArray:
3532  case Type::VariableArray:
3533  return Cache::get(cast<ArrayType>(T)->getElementType());
3534  case Type::Vector:
3535  case Type::ExtVector:
3536  return Cache::get(cast<VectorType>(T)->getElementType());
3537  case Type::FunctionNoProto:
3538  return Cache::get(cast<FunctionType>(T)->getReturnType());
3539  case Type::FunctionProto: {
3540  const auto *FPT = cast<FunctionProtoType>(T);
3541  CachedProperties result = Cache::get(FPT->getReturnType());
3542  for (const auto &ai : FPT->param_types())
3543  result = merge(result, Cache::get(ai));
3544  return result;
3545  }
3546  case Type::ObjCInterface: {
3547  Linkage L = cast<ObjCInterfaceType>(T)->getDecl()->getLinkageInternal();
3548  return CachedProperties(L, false);
3549  }
3550  case Type::ObjCObject:
3551  return Cache::get(cast<ObjCObjectType>(T)->getBaseType());
3552  case Type::ObjCObjectPointer:
3553  return Cache::get(cast<ObjCObjectPointerType>(T)->getPointeeType());
3554  case Type::Atomic:
3555  return Cache::get(cast<AtomicType>(T)->getValueType());
3556  case Type::Pipe:
3557  return Cache::get(cast<PipeType>(T)->getElementType());
3558  }
3559 
3560  llvm_unreachable("unhandled type class");
3561 }
3562 
3563 /// Determine the linkage of this type.
3565  Cache::ensure(this);
3566  return TypeBits.getLinkage();
3567 }
3568 
3570  Cache::ensure(this);
3571  return TypeBits.hasLocalOrUnnamedType();
3572 }
3573 
3575  switch (T->getTypeClass()) {
3576 #define TYPE(Class,Base)
3577 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
3578 #include "clang/AST/TypeNodes.def"
3579  llvm_unreachable("didn't expect a non-canonical type here");
3580 
3581 #define TYPE(Class,Base)
3582 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
3583 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
3584 #include "clang/AST/TypeNodes.def"
3585  // Treat instantiation-dependent types as external.
3586  assert(T->isInstantiationDependentType());
3587  return LinkageInfo::external();
3588 
3589  case Type::Builtin:
3590  return LinkageInfo::external();
3591 
3592  case Type::Auto:
3593  case Type::DeducedTemplateSpecialization:
3594  return LinkageInfo::external();
3595 
3596  case Type::Record:
3597  case Type::Enum:
3598  return getDeclLinkageAndVisibility(cast<TagType>(T)->getDecl());
3599 
3600  case Type::Complex:
3601  return computeTypeLinkageInfo(cast<ComplexType>(T)->getElementType());
3602  case Type::Pointer:
3603  return computeTypeLinkageInfo(cast<PointerType>(T)->getPointeeType());
3604  case Type::BlockPointer:
3605  return computeTypeLinkageInfo(cast<BlockPointerType>(T)->getPointeeType());
3606  case Type::LValueReference:
3607  case Type::RValueReference:
3608  return computeTypeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
3609  case Type::MemberPointer: {
3610  const auto *MPT = cast<MemberPointerType>(T);
3611  LinkageInfo LV = computeTypeLinkageInfo(MPT->getClass());
3612  LV.merge(computeTypeLinkageInfo(MPT->getPointeeType()));
3613  return LV;
3614  }
3615  case Type::ConstantArray:
3616  case Type::IncompleteArray:
3617  case Type::VariableArray:
3618  return computeTypeLinkageInfo(cast<ArrayType>(T)->getElementType());
3619  case Type::Vector:
3620  case Type::ExtVector:
3621  return computeTypeLinkageInfo(cast<VectorType>(T)->getElementType());
3622  case Type::FunctionNoProto:
3623  return computeTypeLinkageInfo(cast<FunctionType>(T)->getReturnType());
3624  case Type::FunctionProto: {
3625  const auto *FPT = cast<FunctionProtoType>(T);
3626  LinkageInfo LV = computeTypeLinkageInfo(FPT->getReturnType());
3627  for (const auto &ai : FPT->param_types())
3628  LV.merge(computeTypeLinkageInfo(ai));
3629  return LV;
3630  }
3631  case Type::ObjCInterface:
3632  return getDeclLinkageAndVisibility(cast<ObjCInterfaceType>(T)->getDecl());
3633  case Type::ObjCObject:
3634  return computeTypeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType());
3635  case Type::ObjCObjectPointer:
3636  return computeTypeLinkageInfo(
3637  cast<ObjCObjectPointerType>(T)->getPointeeType());
3638  case Type::Atomic:
3639  return computeTypeLinkageInfo(cast<AtomicType>(T)->getValueType());
3640  case Type::Pipe:
3641  return computeTypeLinkageInfo(cast<PipeType>(T)->getElementType());
3642  }
3643 
3644  llvm_unreachable("unhandled type class");
3645 }
3646 
3647 bool Type::isLinkageValid() const {
3648  if (!TypeBits.isCacheValid())
3649  return true;
3650 
3651  Linkage L = LinkageComputer{}
3653  .getLinkage();
3654  return L == TypeBits.getLinkage();
3655 }
3656 
3658  if (!T->isCanonicalUnqualified())
3659  return computeTypeLinkageInfo(T->getCanonicalTypeInternal());
3660 
3661  LinkageInfo LV = computeTypeLinkageInfo(T);
3662  assert(LV.getLinkage() == T->getLinkage());
3663  return LV;
3664 }
3665 
3668 }
3669 
3671 Type::getNullability(const ASTContext &Context) const {
3672  QualType Type(this, 0);
3673  while (const auto *AT = Type->getAs<AttributedType>()) {
3674  // Check whether this is an attributed type with nullability
3675  // information.
3676  if (auto Nullability = AT->getImmediateNullability())
3677  return Nullability;
3678 
3679  Type = AT->getEquivalentType();
3680  }
3681  return None;
3682 }
3683 
3684 bool Type::canHaveNullability(bool ResultIfUnknown) const {
3686 
3687  switch (type->getTypeClass()) {
3688  // We'll only see canonical types here.
3689 #define NON_CANONICAL_TYPE(Class, Parent) \
3690  case Type::Class: \
3691  llvm_unreachable("non-canonical type");
3692 #define TYPE(Class, Parent)
3693 #include "clang/AST/TypeNodes.def"
3694 
3695  // Pointer types.
3696  case Type::Pointer:
3697  case Type::BlockPointer:
3698  case Type::MemberPointer:
3699  case Type::ObjCObjectPointer:
3700  return true;
3701 
3702  // Dependent types that could instantiate to pointer types.
3703  case Type::UnresolvedUsing:
3704  case Type::TypeOfExpr:
3705  case Type::TypeOf:
3706  case Type::Decltype:
3707  case Type::UnaryTransform:
3708  case Type::TemplateTypeParm:
3709  case Type::SubstTemplateTypeParmPack:
3710  case Type::DependentName:
3711  case Type::DependentTemplateSpecialization:
3712  case Type::Auto:
3713  return ResultIfUnknown;
3714 
3715  // Dependent template specializations can instantiate to pointer
3716  // types unless they're known to be specializations of a class
3717  // template.
3718  case Type::TemplateSpecialization:
3719  if (TemplateDecl *templateDecl
3720  = cast<TemplateSpecializationType>(type.getTypePtr())
3721  ->getTemplateName().getAsTemplateDecl()) {
3722  if (isa<ClassTemplateDecl>(templateDecl))
3723  return false;
3724  }
3725  return ResultIfUnknown;
3726 
3727  case Type::Builtin:
3728  switch (cast<BuiltinType>(type.getTypePtr())->getKind()) {
3729  // Signed, unsigned, and floating-point types cannot have nullability.
3730 #define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
3731 #define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
3732 #define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
3733 #define BUILTIN_TYPE(Id, SingletonId)
3734 #include "clang/AST/BuiltinTypes.def"
3735  return false;
3736 
3737  // Dependent types that could instantiate to a pointer type.
3738  case BuiltinType::Dependent:
3739  case BuiltinType::Overload:
3740  case BuiltinType::BoundMember:
3741  case BuiltinType::PseudoObject:
3742  case BuiltinType::UnknownAny:
3743  case BuiltinType::ARCUnbridgedCast:
3744  return ResultIfUnknown;
3745 
3746  case BuiltinType::Void:
3747  case BuiltinType::ObjCId:
3748  case BuiltinType::ObjCClass:
3749  case BuiltinType::ObjCSel:
3750 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3751  case BuiltinType::Id:
3752 #include "clang/Basic/OpenCLImageTypes.def"
3753 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
3754  case BuiltinType::Id:
3755 #include "clang/Basic/OpenCLExtensionTypes.def"
3756  case BuiltinType::OCLSampler:
3757  case BuiltinType::OCLEvent:
3758  case BuiltinType::OCLClkEvent:
3759  case BuiltinType::OCLQueue:
3760  case BuiltinType::OCLReserveID:
3761  case BuiltinType::BuiltinFn:
3762  case BuiltinType::NullPtr:
3763  case BuiltinType::OMPArraySection:
3764  return false;
3765  }
3766  llvm_unreachable("unknown builtin type");
3767 
3768  // Non-pointer types.
3769  case Type::Complex:
3770  case Type::LValueReference:
3771  case Type::RValueReference:
3772  case Type::ConstantArray:
3773  case Type::IncompleteArray:
3774  case Type::VariableArray:
3775  case Type::DependentSizedArray:
3776  case Type::DependentVector:
3777  case Type::DependentSizedExtVector:
3778  case Type::Vector:
3779  case Type::ExtVector:
3780  case Type::DependentAddressSpace:
3781  case Type::FunctionProto:
3782  case Type::FunctionNoProto:
3783  case Type::Record:
3784  case Type::DeducedTemplateSpecialization:
3785  case Type::Enum:
3786  case Type::InjectedClassName:
3787  case Type::PackExpansion:
3788  case Type::ObjCObject:
3789  case Type::ObjCInterface:
3790  case Type::Atomic:
3791  case Type::Pipe:
3792  return false;
3793  }
3794  llvm_unreachable("bad type kind!");
3795 }
3796 
3799  if (getAttrKind() == attr::TypeNonNull)
3800  return NullabilityKind::NonNull;
3801  if (getAttrKind() == attr::TypeNullable)
3803  if (getAttrKind() == attr::TypeNullUnspecified)
3805  return None;
3806 }
3807 
3809  if (auto attributed = dyn_cast<AttributedType>(T.getTypePtr())) {
3810  if (auto nullability = attributed->getImmediateNullability()) {
3811  T = attributed->getModifiedType();
3812  return nullability;
3813  }
3814  }
3815 
3816  return None;
3817 }
3818 
3820  const auto *objcPtr = getAs<ObjCObjectPointerType>();
3821  if (!objcPtr)
3822  return false;
3823 
3824  if (objcPtr->isObjCIdType()) {
3825  // id is always okay.
3826  return true;
3827  }
3828 
3829  // Blocks are NSObjects.
3830  if (ObjCInterfaceDecl *iface = objcPtr->getInterfaceDecl()) {
3831  if (iface->getIdentifier() != ctx.getNSObjectName())
3832  return false;
3833 
3834  // Continue to check qualifiers, below.
3835  } else if (objcPtr->isObjCQualifiedIdType()) {
3836  // Continue to check qualifiers, below.
3837  } else {
3838  return false;
3839  }
3840 
3841  // Check protocol qualifiers.
3842  for (ObjCProtocolDecl *proto : objcPtr->quals()) {
3843  // Blocks conform to NSObject and NSCopying.
3844  if (proto->getIdentifier() != ctx.getNSObjectName() &&
3845  proto->getIdentifier() != ctx.getNSCopyingName())
3846  return false;
3847  }
3848 
3849  return true;
3850 }
3851 
3855  return Qualifiers::OCL_Strong;
3856 }
3857 
3859  assert(isObjCLifetimeType() &&
3860  "cannot query implicit lifetime for non-inferrable type");
3861 
3862  const Type *canon = getCanonicalTypeInternal().getTypePtr();
3863 
3864  // Walk down to the base type. We don't care about qualifiers for this.
3865  while (const auto *array = dyn_cast<ArrayType>(canon))
3866  canon = array->getElementType().getTypePtr();
3867 
3868  if (const auto *opt = dyn_cast<ObjCObjectPointerType>(canon)) {
3869  // Class and Class<Protocol> don't require retention.
3870  if (opt->getObjectType()->isObjCClass())
3871  return true;
3872  }
3873 
3874  return false;
3875 }
3876 
3878  const Type *cur = this;
3879  while (true) {
3880  if (const auto *typedefType = dyn_cast<TypedefType>(cur))
3881  return typedefType->getDecl()->hasAttr<ObjCNSObjectAttr>();
3882 
3883  // Single-step desugar until we run out of sugar.
3885  if (next.getTypePtr() == cur) return false;
3886  cur = next.getTypePtr();
3887  }
3888 }
3889 
3891  if (const auto *typedefType = dyn_cast<TypedefType>(this))
3892  return typedefType->getDecl()->hasAttr<ObjCIndependentClassAttr>();
3893  return false;
3894 }
3895 
3897  return isObjCObjectPointerType() ||
3898  isBlockPointerType() ||
3900 }
3901 
3903  if (isObjCLifetimeType())
3904  return true;
3905  if (const auto *OPT = getAs<PointerType>())
3906  return OPT->getPointeeType()->isObjCIndirectLifetimeType();
3907  if (const auto *Ref = getAs<ReferenceType>())
3908  return Ref->getPointeeType()->isObjCIndirectLifetimeType();
3909  if (const auto *MemPtr = getAs<MemberPointerType>())
3910  return MemPtr->getPointeeType()->isObjCIndirectLifetimeType();
3911  return false;
3912 }
3913 
3914 /// Returns true if objects of this type have lifetime semantics under
3915 /// ARC.
3917  const Type *type = this;
3918  while (const ArrayType *array = type->getAsArrayTypeUnsafe())
3919  type = array->getElementType().getTypePtr();
3920  return type->isObjCRetainableType();
3921 }
3922 
3923 /// Determine whether the given type T is a "bridgable" Objective-C type,
3924 /// which is either an Objective-C object pointer type or an
3927 }
3928 
3929 /// Determine whether the given type T is a "bridgeable" C type.
3931  const auto *Pointer = getAs<PointerType>();
3932  if (!Pointer)
3933  return false;
3934 
3935  QualType Pointee = Pointer->getPointeeType();
3936  return Pointee->isVoidType() || Pointee->isRecordType();
3937 }
3938 
3940  if (!isVariablyModifiedType()) return false;
3941 
3942  if (const auto *ptr = getAs<PointerType>())
3943  return ptr->getPointeeType()->hasSizedVLAType();
3944  if (const auto *ref = getAs<ReferenceType>())
3945  return ref->getPointeeType()->hasSizedVLAType();
3946  if (const ArrayType *arr = getAsArrayTypeUnsafe()) {
3947  if (isa<VariableArrayType>(arr) &&
3948  cast<VariableArrayType>(arr)->getSizeExpr())
3949  return true;
3950 
3951  return arr->getElementType()->hasSizedVLAType();
3952  }
3953 
3954  return false;
3955 }
3956 
3957 QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) {
3958  switch (type.getObjCLifetime()) {
3959  case Qualifiers::OCL_None:
3962  break;
3963 
3965  return DK_objc_strong_lifetime;
3966  case Qualifiers::OCL_Weak:
3967  return DK_objc_weak_lifetime;
3968  }
3969 
3970  if (const auto *RT =
3972  const RecordDecl *RD = RT->getDecl();
3973  if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3974  /// Check if this is a C++ object with a non-trivial destructor.
3975  if (CXXRD->hasDefinition() && !CXXRD->hasTrivialDestructor())
3976  return DK_cxx_destructor;
3977  } else {
3978  /// Check if this is a C struct that is non-trivial to destroy or an array
3979  /// that contains such a struct.
3981  return DK_nontrivial_c_struct;
3982  }
3983  }
3984 
3985  return DK_none;
3986 }
3987 
3989  return getClass()->getAsCXXRecordDecl()->getMostRecentNonInjectedDecl();
3990 }
3991 
3993  llvm::APSInt Val, unsigned Scale) {
3994  if (Val.isSigned() && Val.isNegative() && Val != -Val) {
3995  Val = -Val;
3996  Str.push_back('-');
3997  }
3998 
3999  llvm::APSInt IntPart = Val >> Scale;
4000 
4001  // Add 4 digits to hold the value after multiplying 10 (the radix)
4002  unsigned Width = Val.getBitWidth() + 4;
4003  llvm::APInt FractPart = Val.zextOrTrunc(Scale).zext(Width);
4004  llvm::APInt FractPartMask = llvm::APInt::getAllOnesValue(Scale).zext(Width);
4005  llvm::APInt RadixInt = llvm::APInt(Width, 10);
4006 
4007  IntPart.toString(Str, /*radix=*/10);
4008  Str.push_back('.');
4009  do {
4010  (FractPart * RadixInt)
4011  .lshr(Scale)
4012  .toString(Str, /*radix=*/10, Val.isSigned());
4013  FractPart = (FractPart * RadixInt) & FractPartMask;
4014  } while (FractPart != 0);
4015 }
DecltypeType(Expr *E, QualType underlyingType, QualType can=QualType())
Definition: Type.cpp:3093
static StringRef getKeywordName(ElaboratedTypeKeyword Keyword)
Definition: Type.cpp:2574
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition: Type.cpp:1522
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Defines the clang::ASTContext interface.
bool hasDefinition() const
Determine whether this class has been defined.
Definition: DeclObjC.h:1527
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
Definition: Type.cpp:2234
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it&#39;s either not been deduced or was deduce...
Definition: Type.h:4721
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:5115
const Type * Ty
The locally-unqualified type.
Definition: Type.h:583
bool isStruct() const
Definition: Decl.h:3245
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
Definition: Type.h:4918
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
Definition: Type.cpp:1622
bool isKindOfTypeAsWritten() const
Whether this is a "__kindof" type as written.
Definition: Type.h:5641
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:60
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:56
The "enum" keyword introduces the elaborated-type-specifier.
Definition: Type.h:5050
DependentUnaryTransformType(const ASTContext &C, QualType BaseType, UTTKind UKind)
Definition: Type.cpp:3130
void setDependent(bool D=true)
Definition: Type.h:1795
no exception specification
bool isTemplateVariadic() const
Determines whether this function prototype contains a parameter pack at the end.
Definition: Type.cpp:2999
StringRef getName(const PrintingPolicy &Policy) const
Definition: Type.cpp:2648
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2543
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were written.
Definition: Type.h:5635
QualType getPointeeType() const
Definition: Type.h:2556
A (possibly-)qualified type.
Definition: Type.h:642
bool isBlockPointerType() const
Definition: Type.h:6290
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:1131
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2093
bool isArrayType() const
Definition: Type.h:6331
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition: Type.cpp:1892
static QualType getObjectType(APValue::LValueBase B)
Retrieves the "underlying object type" of the given expression, as used by __builtin_object_size.
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
Definition: Type.h:942
PrimitiveDefaultInitializeKind isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C struct types.
Definition: Type.cpp:2241
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: Type.h:3581
bool isArithmeticType() const
Definition: Type.cpp:1944
void setInstantiationDependent(bool D=true)
Definition: Type.h:1801
Stmt - This represents one statement.
Definition: Stmt.h:66
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3361
bool isObjCClassOrClassKindOfType() const
Whether the type is Objective-C &#39;Class&#39; or a __kindof type of an Class type, e.g., __kindof Class <NSCopying>.
Definition: Type.cpp:578
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:497
bool isElaboratedTypeSpecifier() const
Determine wither this type is a C++ elaborated-type-specifier.
Definition: Type.cpp:2623
unsigned MSWChar
When true, print the built-in wchar_t type as __wchar_t.
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1929
C Language Family Type Representation.
bool isObjCARCBridgableType() const
Determine whether the given type T is a "bridgable" Objective-C type, which is either an Objective-C ...
Definition: Type.cpp:3925
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.cpp:3251
bool isRecordType() const
Definition: Type.h:6355
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1932
const ObjCObjectType * getAsObjCInterfaceType() const
Definition: Type.cpp:1574
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
TagDecl * getDecl() const
Definition: Type.cpp:3151
ObjCObjectTypeBitfields ObjCObjectTypeBits
Definition: Type.h:1719
const RecordType * getAsStructureType() const
Definition: Type.cpp:513
SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits
Definition: Type.h:1724
Defines the C++ template declaration subclasses.
StringRef P
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4735
QualType desugar() const
Remove a single level of sugar.
Definition: Type.cpp:3105
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
Definition: Type.cpp:3060
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
Definition: DeclObjC.cpp:308
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition: Type.cpp:2532
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
The base class of the type hierarchy.
Definition: Type.h:1415
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2818
bool isObjCBoxableRecordType() const
Definition: Type.cpp:441
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1582
DependentDecltypeType(const ASTContext &Context, Expr *E)
Definition: Type.cpp:3112
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:689
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5969
bool isCARCBridgableType() const
Determine whether the given type T is a "bridgeable" C type.
Definition: Type.cpp:3930
bool isUnspecialized() const
Determine whether this object type is "unspecialized", meaning that it has no type arguments...
Definition: Type.h:5624
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3564
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
A template template parameter that has been substituted for some other template name.
Definition: TemplateName.h:206
QualType getElementType() const
Definition: Type.h:2853
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3165
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:532
QualType withFastQualifiers(unsigned TQs) const
Definition: Type.h:857
static CachedProperties computeCachedProperties(const Type *T)
Definition: Type.cpp:3471
bool isTrivialType(const ASTContext &Context) const
Return true if this is a trivial type per (C++0x [basic.types]p9)
Definition: Type.cpp:2149
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:1876
bool isInterface() const
Definition: Decl.h:3246
bool isStructureType() const
Definition: Type.cpp:435
bool isEnumeralType() const
Definition: Type.h:6359
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6716
The "union" keyword.
Definition: Type.h:5025
Extra information about a function prototype.
Definition: Type.h:3762
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type...
Definition: Type.h:6788
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical) const
Produce a unique representation of the given statement.
The "__interface" keyword.
Definition: Type.h:5022
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 ...
bool isChar32Type() const
Definition: Type.cpp:1807
bool isCallingConv() const
Definition: Type.cpp:3207
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
LinkageInfo computeTypeLinkageInfo(const Type *T)
Definition: Type.cpp:3574
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4589
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:24
noexcept(expression), value-dependent
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
Definition: Type.cpp:2344
The collection of all-type qualifiers we support.
Definition: Type.h:141
bool isVariableArrayType() const
Definition: Type.h:6343
bool isSugared() const
Returns whether this type directly provides sugar.
Definition: Type.cpp:3103
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:1922
bool isClass() const
Definition: Decl.h:3247
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3071
bool canHaveNullability(bool ResultIfUnknown=true) const
Determine whether the given type can have a nullability specifier applied to it, i.e., if it is any kind of pointer type.
Definition: Type.cpp:3684
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
Represents a struct/union/class.
Definition: Decl.h:3589
QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced, QualType Replacement) const
Retrieve a substitution-result type.
QualType getOriginalType() const
Definition: Type.h:2607
bool isWideCharType() const
Definition: Type.cpp:1788
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3763
bool isComplete() const
Returns true if this can be considered a complete type.
Definition: Decl.h:3530
One of these records is kept for each identifier that is lexed.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1018
bool isObjCIdOrObjectKindOfType(const ASTContext &ctx, const ObjCObjectType *&bound) const
Whether the type is Objective-C &#39;id&#39; or a __kindof type of an object type, e.g., __kindof NSView * or...
Definition: Type.cpp:552
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
QualType IgnoreParens() const
Returns the specified type after dropping any outer-level parentheses.
Definition: Type.h:961
Represents a class type in Objective C.
Definition: Type.h:5524
bool isObjCIndependentClassType() const
Definition: Type.cpp:3890
QualType getPointeeType() const
Definition: Type.h:2660
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
bool isStdByteType() const
Definition: Type.cpp:2438
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3886
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:3916
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
Definition: Type.cpp:3272
bool isCharType() const
Definition: Type.cpp:1779
bool isSpelledAsLValue() const
Definition: Type.h:2695
Represents a member of a struct/union/class.
Definition: Decl.h:2575
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
Definition: Type.h:1843
Defines the ExceptionSpecificationType enumeration and various utility functions. ...
An operation on a type.
Definition: TypeVisitor.h:65
const ObjCObjectPointerType * getAsObjCQualifiedIdType() const
Definition: Type.cpp:1554
bool isReferenceType() const
Definition: Type.h:6294
qual_iterator qual_begin() const
Definition: Type.h:5425
unsigned char getOpaqueValue() const
Definition: Type.h:3436
const AstTypeMatcher< TypedefType > typedefType
Matches typedef types.
unsigned getIndex() const
Retrieve the index into its type parameter list.
Definition: DeclObjC.h:607
const ObjCObjectPointerType * stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const
Strip off the Objective-C "kindof" type and (with it) any protocol qualifiers.
Definition: Type.cpp:709
Values of this type can be null.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3116
Type(TypeClass tc, QualType canon, bool Dependent, bool InstantiationDependent, bool VariablyModified, bool ContainsUnexpandedParameterPack)
Definition: Type.h:1776
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2744
bool isMSTypeSpec() const
Definition: Type.cpp:3194
const ObjCObjectType * getAsObjCQualifiedInterfaceType() const
Definition: Type.cpp:1540
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:2380
Microsoft throw(...) extension.
A convenient class for passing around template argument information.
Definition: TemplateBase.h:552
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments of this object type (semantically).
Definition: Type.cpp:656
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2197
bool hasAddressSpace() const
Definition: Type.h:355
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type...
Definition: Type.h:6765
The "struct" keyword introduces the elaborated-type-specifier.
Definition: Type.h:5038
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
Definition: Type.cpp:2506
Whether values of this type can be null is (explicitly) unspecified.
const ObjCObjectPointerType * getAsObjCQualifiedClassType() const
Definition: Type.cpp:1564
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1837
LangAS getAddressSpace() const
Definition: Type.h:356
const Type * getClass() const
Definition: Type.h:2796
CXXRecordDecl * getDecl() const
Definition: Type.cpp:3230
Values of this type can never be null.
Expr * getSizeExpr() const
Definition: Type.h:2997
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6058
LinkageInfo getTypeLinkageAndVisibility(const Type *T)
Definition: Type.cpp:3657
static QualType simpleTransform(ASTContext &ctx, QualType type, F &&f)
Perform a simple type transformation that does not change the semantics of the type.
Definition: Type.cpp:1109
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:111
Defines the Linkage enumeration and various utility functions.
static TagDecl * getInterestingTagDecl(TagDecl *decl)
Definition: Type.cpp:3142
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type...
Definition: Decl.h:3266
unsigned Half
When true, print the half-precision floating-point type as &#39;half&#39; instead of &#39;__fp16&#39;.
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2056
bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const
Definition: Type.cpp:3819
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:167
bool isScalarType() const
Definition: Type.h:6615
void * getAsOpaquePtr() const
Definition: Type.h:687
Represents an ObjC class declaration.
Definition: DeclObjC.h:1164
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:411
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5759
PrimitiveDefaultInitializeKind
Definition: Type.h:1081
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3748
SplitQualType getSplitDesugaredType() const
Definition: Type.h:946
QualType getPointeeTypeAsWritten() const
Definition: Type.h:2698
TagType(TypeClass TC, const TagDecl *D, QualType can)
Definition: Type.cpp:3135
unsigned getNumProtocols() const
Return the number of qualifying protocols in this type, or 0 if there are none.
Definition: Type.h:5432
QualType getElementType() const
Definition: Type.h:3150
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:1906
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:3134
This object can be modified without requiring retains or releases.
Definition: Type.h:162
CXXRecordDecl * getMostRecentNonInjectedDecl()
Definition: DeclCXX.h:754
Defines the clang::Visibility enumeration and various utility functions.
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
Definition: Type.cpp:1764
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3649
Provides definitions for the various language-specific address spaces.
bool isSpecializedAsWritten() const
Determine whether this object type was written with type arguments.
Definition: Type.h:5618
bool hasAttr() const
Definition: DeclBase.h:531
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:5587
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Definition: Type.cpp:1609
static void ensure(const Type *T)
Definition: Type.cpp:3435
bool acceptsObjCTypeParams() const
Determines if this is an ObjC interface type that may accept type parameters.
Definition: Type.cpp:1441
bool containsUnexpandedParameterPack() const
Determines whether this template name contains an unexpanded parameter pack (for C++0x variadic templ...
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2447
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1605
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3686
const ObjCObjectType * getSuperClassType() const
Retrieve the superclass type.
Definition: DeclObjC.h:1557
static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword)
Definition: Type.cpp:2559
QualType applyObjCProtocolQualifiers(QualType type, ArrayRef< ObjCProtocolDecl *> protocols, bool &hasError, bool allowOnPointerType=false) const
Apply Objective-C protocol qualifiers to the given type.
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition: Type.cpp:473
IdentifierInfo * getNSObjectName() const
Retrieve the identifier &#39;NSObject&#39;.
Definition: ASTContext.h:1673
ArraySizeModifier
Capture whether this is a normal array (e.g.
Definition: Type.h:2824
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
DependentTemplateSpecializationTypeBitfields DependentTemplateSpecializationTypeBits
Definition: Type.h:1727
Defines the TargetCXXABI class, which abstracts details of the C++ ABI that we&#39;re targeting...
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Definition: Type.cpp:2275
QualType getElementType() const
Definition: Type.h:2496
IdentifierInfo * getIdentifier() const
Definition: Type.cpp:3234
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.
This represents one expression.
Definition: Expr.h:106
Defines the clang::LangOptions interface.
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition: Type.h:5054
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
Definition: Type.cpp:3858
QualType desugar() const
Definition: Type.h:3217
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to...
Definition: Type.cpp:1590
const IdentifierInfo * getBaseTypeIdentifier() const
Retrieves a pointer to the name of the base type.
Definition: Type.cpp:71
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6779
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:5036
bool isObjCRetainableType() const
Definition: Type.cpp:3896
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
QualType getParenType(QualType NamedType) const
ObjCSubstitutionContext
The kind of type we are substituting Objective-C type arguments into.
Definition: Type.h:611
bool isChar16Type() const
Definition: Type.cpp:1801
const char * getTypeClassName() const
Definition: Type.cpp:2638
Linkage getLinkage() const
Definition: Visibility.h:84
ObjCLifetime getObjCLifetime() const
Definition: Type.h:330
DeclContext * getDeclContext()
Definition: DeclBase.h:427
bool isAnyComplexType() const
Definition: Type.h:6363
SourceLocation Begin
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4266
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition: Type.cpp:2519
ObjCObjectType(QualType Canonical, QualType Base, ArrayRef< QualType > typeArgs, ArrayRef< ObjCProtocolDecl *> protocols, bool isKindOf)
Definition: Type.cpp:606
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
Definition: Type.cpp:1959
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
Represents the type decltype(expr) (C++11).
Definition: Type.h:4232
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:581
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:1836
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3278
QualType desugar() const
Remove a single level of sugar.
Definition: Type.cpp:3081
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
QualType getType() const
Definition: Expr.h:128
bool isFunctionOrMethod() const
Definition: DeclBase.h:1799
static Optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it&#39;s there.
Definition: Type.cpp:3808
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:1613
A unary type transform, which is a type constructed from another.
Definition: Type.h:4275
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...
Qualifiers Quals
The local qualifiers.
Definition: Type.h:586
bool isSpecifierType() const
Returns true if this type can be represented by some set of type specifiers.
Definition: Type.cpp:2480
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:1320
#define TRIVIAL_TYPE_CLASS(Class)
Definition: Type.cpp:745
ScalarTypeKind
Definition: Type.h:2067
bool hasInstantiationDependentExceptionSpec() const
Return whether this function has an instantiation-dependent exception spec.
Definition: Type.cpp:2958
A helper class for Type nodes having an ElaboratedTypeKeyword.
Definition: Type.h:5064
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl...
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1379
Represents a GCC generic vector type.
Definition: Type.h:3174
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2855
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2726
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition: Type.h:4695
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6674
The result type of a method or function.
bool isUnionType() const
Definition: Type.cpp:467
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:707
bool hasAutoForTrailingReturnType() const
Determine whether this type was written with a leading &#39;auto&#39; corresponding to a trailing return type...
Definition: Type.cpp:1720
bool isChar8Type() const
Definition: Type.cpp:1795
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:236
static LinkageInfo external()
Definition: Visibility.h:68
Expr * getUnderlyingExpr() const
Definition: Type.h:4171
bool isNonTrivialToPrimitiveDestroy() const
Definition: Decl.h:3704
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType)
bool isVoidPointerType() const
Definition: Type.cpp:461
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6117
IdentifierInfo * getNSCopyingName()
Retrieve the identifier &#39;NSCopying&#39;.
Definition: ASTContext.h:1682
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent) const
C++11 deduced auto type.
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
Definition: Type.h:4004
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:6066
RecordDecl * getDecl() const
Definition: Type.h:4366
noexcept(expression), evals to &#39;false&#39;
bool isAlignValT() const
Definition: Type.cpp:2429
LinkageInfo getLinkageAndVisibility() const
Determine the linkage and visibility of this type.
Definition: Type.cpp:3666
unsigned Bool
Whether we can use &#39;bool&#39; rather than &#39;_Bool&#39; (even if the language doesn&#39;t actually have &#39;bool&#39;...
bool isStructureOrClassType() const
Definition: Type.cpp:453
A template template parameter pack that has been substituted for a template template argument pack...
Definition: TemplateName.h:211
CanThrowResult
Possible results from evaluation of a noexcept expression.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
There is no lifetime qualification on this type.
Definition: Type.h:158
bool containsUnexpandedParameterPack() const
Whether this nested-name-specifier contains an unexpanded parameter pack (for C++11 variadic template...
#define false
Definition: stdbool.h:33
The "struct" keyword.
Definition: Type.h:5019
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:169
Kind
QualType getCanonicalType() const
Definition: Type.h:6097
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3738
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:191
bool isSpecialized() const
Determine whether this object type is "specialized", meaning that it has type arguments.
Definition: Type.cpp:638
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3890
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:295
const ExtParameterInfo * ExtParameterInfos
Definition: Type.h:3769
Encodes a location in the source.
Sugar for parentheses used when specifying types.
Definition: Type.h:2513
QualType getAdjustedType() const
Definition: Type.h:2608
QualType getReturnType() const
Definition: Type.h:3617
bool isLinkageValid() const
True if the computed linkage is valid.
Definition: Type.cpp:3647
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4382
bool mayBeNotDynamicClass() const
Returns true if it is not a class or if the class might not be dynamic.
Definition: Type.cpp:96
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6174
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5724
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2101
const ComplexType * getAsComplexIntegerType() const
Definition: Type.cpp:490
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2279
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3060
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3247
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
QualType getElementType() const
Definition: Type.h:3209
void FixedPointValueToString(SmallVectorImpl< char > &Str, llvm::APSInt Val, unsigned Scale)
Definition: Type.cpp:3992
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1751
QualType getLocallyUnqualifiedSingleStepDesugaredType() const
Pull a single level of sugar off of this locally-unqualified type.
Definition: Type.cpp:294
void initialize(ArrayRef< ObjCProtocolDecl * > protocols)
Definition: Type.h:5411
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2272
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:360
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1852
QualType getEquivalentType() const
Definition: Type.h:4437
void Profile(llvm::FoldingSetNodeID &ID)
Definition: TemplateName.h:305
QualType getInnerType() const
Definition: Type.h:2526
bool isObjCObjectPointerType() const
Definition: Type.h:6379
AutoTypeKeyword getKeyword() const
Definition: Type.h:4750
TypeClass getTypeClass() const
Definition: Type.h:1817
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1815
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Definition: Type.cpp:2257
QualType getSuperClassType() const
Retrieve the type of the superclass of this object type.
Definition: Type.h:5652
EnumDecl * getDecl() const
Definition: Type.h:4389
bool isVectorType() const
Definition: Type.h:6367
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
bool hasConstFields() const
Recursively check all fields in the record for const-ness.
Definition: Type.cpp:3159
Assigning into this object requires a lifetime extension.
Definition: Type.h:175
TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits
Definition: Type.h:1725
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
Definition: Type.cpp:2544
void setVariablyModified(bool VM=true)
Definition: Type.h:1804
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
TypeOfExprType(Expr *E, QualType can=QualType())
Definition: Type.cpp:3070
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:2091
Linkage getLinkageInternal() const
Determine what kind of linkage this entity has.
Definition: Decl.cpp:1062
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2628
Represents a pack expansion of types.
Definition: Type.h:5341
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:354
Defines various enumerations that describe declaration and type specifiers.
bool isRealType() const
Definition: Type.cpp:1935
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array&#39;s size can require, which limits the maximu...
Definition: Type.cpp:146
Linkage minLinkage(Linkage L1, Linkage L2)
Compute the minimum linkage given two linkages.
Definition: Linkage.h:115
CXXRecordDecl * getMostRecentCXXRecordDecl() const
Definition: Type.cpp:3988
Represents a template argument.
Definition: TemplateBase.h:51
bool isDeduced() const
Definition: Type.h:4724
bool isScopedEnumeralType() const
Determine whether this type is a scoped enumeration type.
Definition: Type.cpp:484
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2591
TagTypeKind
The kind of a tag type.
Definition: Type.h:5017
Optional< types::ID > Type
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
CanQualType ObjCBuiltinIdTy
Definition: ASTContext.h:1047
GC getObjCGCAttr() const
Definition: Type.h:309
Dataflow Directional Tag Classes.
bool isObjCQualifiedInterfaceType() const
Definition: Type.cpp:1550
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.cpp:1715
ExtInfo getExtInfo() const
Definition: Type.h:3628
not evaluated yet, for special member function
A qualifier set is used to build a set of qualifiers.
Definition: Type.h:6025
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1261
void setContainsUnexpandedParameterPack(bool PP=true)
Definition: Type.h:1806
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
bool hasUnnamedOrLocalType() const
Whether this type is or contains a local or unnamed type.
Definition: Type.cpp:3569
static CachedProperties get(QualType T)
Definition: Type.cpp:3425
bool hasDependentExceptionSpec() const
Return whether this function has a dependent exception spec.
Definition: Type.cpp:2946
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:2101
QualType getUnderlyingType() const
Definition: Decl.h:2967
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
QualType stripObjCKindOfType(const ASTContext &ctx) const
Strip Objective-C "__kindof" types from the given type.
Definition: Type.cpp:1329
QualType getUnderlyingType() const
Definition: Type.h:4243
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:261
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.cpp:3374
VectorKind getVectorKind() const
Definition: Type.h:3219
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:551
The "union" keyword introduces the elaborated-type-specifier.
Definition: Type.h:5044
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition: Type.h:6032
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like &#39;int()&#39;.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3160
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.cpp:3389
bool isObjCIndirectLifetimeType() const
Definition: Type.cpp:3902
The "class" keyword introduces the elaborated-type-specifier.
Definition: Type.h:5047
bool isKindOfType() const
Whether this ia a "__kindof" type (semantically).
Definition: Type.cpp:674
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:378
Represents an enum.
Definition: Decl.h:3322
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2762
bool hasObjCLifetime() const
Definition: Type.h:329
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type. ...
Definition: Type.cpp:1999
bool isQualifier() const
Does this attribute behave like a type qualifier?
Definition: Type.cpp:3172
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:580
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Definition: Type.cpp:3344
UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind, QualType CanonicalTy)
Definition: Type.cpp:3120
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:340
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4604
void addConsistentQualifiers(Qualifiers qs)
Add the qualifiers from the given set to this set, given that they don&#39;t conflict.
Definition: Type.h:456
QualType getModifiedType() const
Definition: Type.h:4436
Represents a pointer to an Objective C object.
Definition: Type.h:5780
Pointer to a block type.
Definition: Type.h:2645
bool isSugared() const
Returns whether this type directly provides sugar.
Definition: Type.cpp:3077
FunctionTypeBitfields FunctionTypeBits
Definition: Type.h:1718
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4356
Complex values, per C99 6.2.5p11.
Definition: Type.h:2483
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
unsigned getIndexTypeCVRQualifiers() const
Definition: Type.h:2863
bool empty() const
Definition: Type.h:418
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:2013
QualType getCanonicalTypeInternal() const
Definition: Type.h:2361
QualType getAtomicUnqualifiedType() const
Remove all qualifiers including _Atomic.
Definition: Type.cpp:1353
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6564
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
Definition: Type.cpp:2967
const llvm::APInt & getSize() const
Definition: Type.h:2896
Kind getAttrKind() const
Definition: Type.h:4432
VectorTypeBitfields VectorTypeBits
Definition: Type.h:1723
ExtVectorType - Extended vector type.
Definition: Type.h:3293
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2679
SourceRange getBracketsRange() const
Definition: Type.h:3003
The template argument is a type.
Definition: TemplateBase.h:60
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:1359
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3671
The "class" keyword.
Definition: Type.h:5028
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2798
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
Definition: Type.cpp:3155
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2069
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3741
void merge(LinkageInfo other)
Merge both linkage and visibility.
Definition: Visibility.h:133
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:2023
bool hasObjCGCAttr() const
Definition: Type.h:308
The type-property cache.
Definition: Type.cpp:3423
bool isClassType() const
Definition: Type.cpp:429
TypedefNameDecl * getDecl() const
Definition: Type.h:4153
TypeBitfields TypeBits
Definition: Type.h:1713
Reading or writing from this object requires a barrier call.
Definition: Type.h:172
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Definition: Type.h:3744
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4411
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
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:1866
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
bool isVoidType() const
Definition: Type.h:6530
Represents a C array with an unspecified size.
Definition: Type.h:2932
QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const
Strip off the Objective-C "kindof" type and (with it) any protocol qualifiers.
Definition: Type.cpp:691
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:1725
The parameter type of a method or function.
QualType getNamedType() const
Retrieve the type named by the qualified-id.
Definition: Type.h:5155
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4610
The "enum" keyword.
Definition: Type.h:5031
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:214
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4196
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
Definition: Type.cpp:3852
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:629
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2397
Defines the clang::TargetInfo interface.
bool isComplexIntegerType() const
Definition: Type.cpp:479
ASTContext & getParentASTContext() const
Definition: DeclBase.h:1780
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
bool hasVolatile() const
Definition: Type.h:265
__DEVICE__ int max(int __a, int __b)
NameKind getKind() const
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:954
unsigned getNumElements() const
Definition: Type.h:3210
QualType getSuperClassType() const
Retrieve the type of the superclass of this object pointer type.
Definition: Type.cpp:1531
void initialize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2085
bool mayBeDynamicClass() const
Returns true if it is a class and it might be dynamic.
Definition: Type.cpp:91
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4827
bool isPointerType() const
Definition: Type.h:6282
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
static StringRef getNameForCallConv(CallingConv CC)
Definition: Type.cpp:2814
#define true
Definition: stdbool.h:32
bool isFloatingType() const
Definition: Type.cpp:1913
A trivial tuple used to represent a source range.
VectorType(QualType vecType, unsigned nElements, QualType canonType, VectorKind vecKind)
Definition: Type.cpp:243
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2970
void computeSuperClassTypeSlow() const
Definition: Type.cpp:1452
This represents a decl that may have a name.
Definition: Decl.h:248
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
A simple holder for a QualType representing a type in an exception specification. ...
Definition: Type.h:3589
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2977
No keyword precedes the qualified type name.
Definition: Type.h:5057
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 isConstant(const ASTContext &Ctx) const
Definition: Type.h:777
bool isInterfaceType() const
Definition: Type.cpp:447
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition: Type.h:5303
QualType desugar() const
Definition: Type.cpp:3066
const LangOptions & getLangOpts() const
Definition: ASTContext.h:706
unsigned size() const
Determine the number of type parameters in this list.
Definition: DeclObjC.h:669
llvm::Optional< NullabilityKind > getImmediateNullability() const
Definition: Type.cpp:3798
The "__interface" keyword introduces the elaborated-type-specifier.
Definition: Type.h:5041
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2878
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3768
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
bool isObjCNSObjectType() const
Definition: Type.cpp:3877
bool hasSizedVLAType() const
Whether this type involves a variable-length array type with a definite size.
Definition: Type.cpp:3939
QualType getPointeeType() const
Definition: Type.h:2782
A single template declaration.
Definition: TemplateName.h:191
bool isBeingDefined() const
Return true if this decl is currently being defined.
Definition: Decl.h:3185
static QualType getParamType(Sema &SemaRef, ArrayRef< ResultCandidate > Candidates, unsigned N)
Get the type of the Nth parameter from a given set of overload candidates.
noexcept(expression), evals to &#39;true&#39;
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type...
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...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1066
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5796