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  }
2790 
2791  llvm_unreachable("Invalid builtin type.");
2792 }
2793 
2795  if (const auto *RefType = getTypePtr()->getAs<ReferenceType>())
2796  return RefType->getPointeeType();
2797 
2798  // C++0x [basic.lval]:
2799  // Class prvalues can have cv-qualified types; non-class prvalues always
2800  // have cv-unqualified types.
2801  //
2802  // See also C99 6.3.2.1p2.
2803  if (!Context.getLangOpts().CPlusPlus ||
2804  (!getTypePtr()->isDependentType() && !getTypePtr()->isRecordType()))
2805  return getUnqualifiedType();
2806 
2807  return *this;
2808 }
2809 
2811  switch (CC) {
2812  case CC_C: return "cdecl";
2813  case CC_X86StdCall: return "stdcall";
2814  case CC_X86FastCall: return "fastcall";
2815  case CC_X86ThisCall: return "thiscall";
2816  case CC_X86Pascal: return "pascal";
2817  case CC_X86VectorCall: return "vectorcall";
2818  case CC_Win64: return "ms_abi";
2819  case CC_X86_64SysV: return "sysv_abi";
2820  case CC_X86RegCall : return "regcall";
2821  case CC_AAPCS: return "aapcs";
2822  case CC_AAPCS_VFP: return "aapcs-vfp";
2823  case CC_IntelOclBicc: return "intel_ocl_bicc";
2824  case CC_SpirFunction: return "spir_function";
2825  case CC_OpenCLKernel: return "opencl_kernel";
2826  case CC_Swift: return "swiftcall";
2827  case CC_PreserveMost: return "preserve_most";
2828  case CC_PreserveAll: return "preserve_all";
2829  }
2830 
2831  llvm_unreachable("Invalid calling convention.");
2832 }
2833 
2834 FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
2835  QualType canonical,
2836  const ExtProtoInfo &epi)
2837  : FunctionType(FunctionProto, result, canonical, result->isDependentType(),
2838  result->isInstantiationDependentType(),
2839  result->isVariablyModifiedType(),
2840  result->containsUnexpandedParameterPack(), epi.ExtInfo) {
2841  FunctionTypeBits.TypeQuals = epi.TypeQuals;
2842  FunctionTypeBits.RefQualifier = epi.RefQualifier;
2843  FunctionTypeBits.NumParams = params.size();
2844  assert(getNumParams() == params.size() && "NumParams overflow!");
2845  FunctionTypeBits.ExceptionSpecType = epi.ExceptionSpec.Type;
2846  FunctionTypeBits.HasExtParameterInfos = !!epi.ExtParameterInfos;
2847  FunctionTypeBits.Variadic = epi.Variadic;
2848  FunctionTypeBits.HasTrailingReturn = epi.HasTrailingReturn;
2849 
2850  // Fill in the extra trailing bitfields if present.
2851  if (hasExtraBitfields(epi.ExceptionSpec.Type)) {
2852  auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
2853  ExtraBits.NumExceptionType = epi.ExceptionSpec.Exceptions.size();
2854  }
2855 
2856  // Fill in the trailing argument array.
2857  auto *argSlot = getTrailingObjects<QualType>();
2858  for (unsigned i = 0; i != getNumParams(); ++i) {
2859  if (params[i]->isDependentType())
2860  setDependent();
2861  else if (params[i]->isInstantiationDependentType())
2863 
2864  if (params[i]->containsUnexpandedParameterPack())
2866 
2867  argSlot[i] = params[i];
2868  }
2869 
2870  // Fill in the exception type array if present.
2871  if (getExceptionSpecType() == EST_Dynamic) {
2872  assert(hasExtraBitfields() && "missing trailing extra bitfields!");
2873  auto *exnSlot =
2874  reinterpret_cast<QualType *>(getTrailingObjects<ExceptionType>());
2875  unsigned I = 0;
2876  for (QualType ExceptionType : epi.ExceptionSpec.Exceptions) {
2877  // Note that, before C++17, a dependent exception specification does
2878  // *not* make a type dependent; it's not even part of the C++ type
2879  // system.
2880  if (ExceptionType->isInstantiationDependentType())
2882 
2883  if (ExceptionType->containsUnexpandedParameterPack())
2885 
2886  exnSlot[I++] = ExceptionType;
2887  }
2888  }
2889  // Fill in the Expr * in the exception specification if present.
2890  else if (isComputedNoexcept(getExceptionSpecType())) {
2891  assert(epi.ExceptionSpec.NoexceptExpr && "computed noexcept with no expr");
2892  assert((getExceptionSpecType() == EST_DependentNoexcept) ==
2893  epi.ExceptionSpec.NoexceptExpr->isValueDependent());
2894 
2895  // Store the noexcept expression and context.
2896  *getTrailingObjects<Expr *>() = epi.ExceptionSpec.NoexceptExpr;
2897 
2898  if (epi.ExceptionSpec.NoexceptExpr->isValueDependent() ||
2899  epi.ExceptionSpec.NoexceptExpr->isInstantiationDependent())
2901 
2902  if (epi.ExceptionSpec.NoexceptExpr->containsUnexpandedParameterPack())
2904  }
2905  // Fill in the FunctionDecl * in the exception specification if present.
2906  else if (getExceptionSpecType() == EST_Uninstantiated) {
2907  // Store the function decl from which we will resolve our
2908  // exception specification.
2909  auto **slot = getTrailingObjects<FunctionDecl *>();
2910  slot[0] = epi.ExceptionSpec.SourceDecl;
2911  slot[1] = epi.ExceptionSpec.SourceTemplate;
2912  // This exception specification doesn't make the type dependent, because
2913  // it's not instantiated as part of instantiating the type.
2914  } else if (getExceptionSpecType() == EST_Unevaluated) {
2915  // Store the function decl from which we will resolve our
2916  // exception specification.
2917  auto **slot = getTrailingObjects<FunctionDecl *>();
2918  slot[0] = epi.ExceptionSpec.SourceDecl;
2919  }
2920 
2921  // If this is a canonical type, and its exception specification is dependent,
2922  // then it's a dependent type. This only happens in C++17 onwards.
2923  if (isCanonicalUnqualified()) {
2924  if (getExceptionSpecType() == EST_Dynamic ||
2925  getExceptionSpecType() == EST_DependentNoexcept) {
2926  assert(hasDependentExceptionSpec() && "type should not be canonical");
2927  setDependent();
2928  }
2929  } else if (getCanonicalTypeInternal()->isDependentType()) {
2930  // Ask our canonical type whether our exception specification was dependent.
2931  setDependent();
2932  }
2933 
2934  // Fill in the extra parameter info if present.
2935  if (epi.ExtParameterInfos) {
2936  auto *extParamInfos = getTrailingObjects<ExtParameterInfo>();
2937  for (unsigned i = 0; i != getNumParams(); ++i)
2938  extParamInfos[i] = epi.ExtParameterInfos[i];
2939  }
2940 }
2941 
2943  if (Expr *NE = getNoexceptExpr())
2944  return NE->isValueDependent();
2945  for (QualType ET : exceptions())
2946  // A pack expansion with a non-dependent pattern is still dependent,
2947  // because we don't know whether the pattern is in the exception spec
2948  // or not (that depends on whether the pack has 0 expansions).
2949  if (ET->isDependentType() || ET->getAs<PackExpansionType>())
2950  return true;
2951  return false;
2952 }
2953 
2955  if (Expr *NE = getNoexceptExpr())
2956  return NE->isInstantiationDependent();
2957  for (QualType ET : exceptions())
2958  if (ET->isInstantiationDependentType())
2959  return true;
2960  return false;
2961 }
2962 
2964  switch (getExceptionSpecType()) {
2965  case EST_Unparsed:
2966  case EST_Unevaluated:
2967  case EST_Uninstantiated:
2968  llvm_unreachable("should not call this with unresolved exception specs");
2969 
2970  case EST_DynamicNone:
2971  case EST_BasicNoexcept:
2972  case EST_NoexceptTrue:
2973  return CT_Cannot;
2974 
2975  case EST_None:
2976  case EST_MSAny:
2977  case EST_NoexceptFalse:
2978  return CT_Can;
2979 
2980  case EST_Dynamic:
2981  // A dynamic exception specification is throwing unless every exception
2982  // type is an (unexpanded) pack expansion type.
2983  for (unsigned I = 0; I != getNumExceptions(); ++I)
2984  if (!getExceptionType(I)->getAs<PackExpansionType>())
2985  return CT_Can;
2986  return CT_Dependent;
2987 
2988  case EST_DependentNoexcept:
2989  return CT_Dependent;
2990  }
2991 
2992  llvm_unreachable("unexpected exception specification kind");
2993 }
2994 
2996  for (unsigned ArgIdx = getNumParams(); ArgIdx; --ArgIdx)
2997  if (isa<PackExpansionType>(getParamType(ArgIdx - 1)))
2998  return true;
2999 
3000  return false;
3001 }
3002 
3003 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
3004  const QualType *ArgTys, unsigned NumParams,
3005  const ExtProtoInfo &epi,
3006  const ASTContext &Context, bool Canonical) {
3007  // We have to be careful not to get ambiguous profile encodings.
3008  // Note that valid type pointers are never ambiguous with anything else.
3009  //
3010  // The encoding grammar begins:
3011  // type type* bool int bool
3012  // If that final bool is true, then there is a section for the EH spec:
3013  // bool type*
3014  // This is followed by an optional "consumed argument" section of the
3015  // same length as the first type sequence:
3016  // bool*
3017  // Finally, we have the ext info and trailing return type flag:
3018  // int bool
3019  //
3020  // There is no ambiguity between the consumed arguments and an empty EH
3021  // spec because of the leading 'bool' which unambiguously indicates
3022  // whether the following bool is the EH spec or part of the arguments.
3023 
3024  ID.AddPointer(Result.getAsOpaquePtr());
3025  for (unsigned i = 0; i != NumParams; ++i)
3026  ID.AddPointer(ArgTys[i].getAsOpaquePtr());
3027  // This method is relatively performance sensitive, so as a performance
3028  // shortcut, use one AddInteger call instead of four for the next four
3029  // fields.
3030  assert(!(unsigned(epi.Variadic) & ~1) &&
3031  !(unsigned(epi.TypeQuals) & ~255) &&
3032  !(unsigned(epi.RefQualifier) & ~3) &&
3033  !(unsigned(epi.ExceptionSpec.Type) & ~15) &&
3034  "Values larger than expected.");
3035  ID.AddInteger(unsigned(epi.Variadic) +
3036  (epi.TypeQuals << 1) +
3037  (epi.RefQualifier << 9) +
3038  (epi.ExceptionSpec.Type << 11));
3039  if (epi.ExceptionSpec.Type == EST_Dynamic) {
3040  for (QualType Ex : epi.ExceptionSpec.Exceptions)
3041  ID.AddPointer(Ex.getAsOpaquePtr());
3042  } else if (isComputedNoexcept(epi.ExceptionSpec.Type)) {
3043  epi.ExceptionSpec.NoexceptExpr->Profile(ID, Context, Canonical);
3044  } else if (epi.ExceptionSpec.Type == EST_Uninstantiated ||
3046  ID.AddPointer(epi.ExceptionSpec.SourceDecl->getCanonicalDecl());
3047  }
3048  if (epi.ExtParameterInfos) {
3049  for (unsigned i = 0; i != NumParams; ++i)
3050  ID.AddInteger(epi.ExtParameterInfos[i].getOpaqueValue());
3051  }
3052  epi.ExtInfo.Profile(ID);
3053  ID.AddBoolean(epi.HasTrailingReturn);
3054 }
3055 
3056 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID,
3057  const ASTContext &Ctx) {
3058  Profile(ID, getReturnType(), param_type_begin(), getNumParams(),
3059  getExtProtoInfo(), Ctx, isCanonicalUnqualified());
3060 }
3061 
3063  return getDecl()->getUnderlyingType();
3064 }
3065 
3067  : Type(TypeOfExpr, can, E->isTypeDependent(),
3068  E->isInstantiationDependent(),
3069  E->getType()->isVariablyModifiedType(),
3071  TOExpr(E) {}
3072 
3074  return !TOExpr->isTypeDependent();
3075 }
3076 
3078  if (isSugared())
3079  return getUnderlyingExpr()->getType();
3080 
3081  return QualType(this, 0);
3082 }
3083 
3084 void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID,
3085  const ASTContext &Context, Expr *E) {
3086  E->Profile(ID, Context, true);
3087 }
3088 
3090  // C++11 [temp.type]p2: "If an expression e involves a template parameter,
3091  // decltype(e) denotes a unique dependent type." Hence a decltype type is
3092  // type-dependent even if its expression is only instantiation-dependent.
3093  : Type(Decltype, can, E->isInstantiationDependent(),
3094  E->isInstantiationDependent(),
3095  E->getType()->isVariablyModifiedType(),
3097  E(E), UnderlyingType(underlyingType) {}
3098 
3100 
3102  if (isSugared())
3103  return getUnderlyingType();
3104 
3105  return QualType(this, 0);
3106 }
3107 
3109  : DecltypeType(E, Context.DependentTy), Context(Context) {}
3110 
3111 void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID,
3112  const ASTContext &Context, Expr *E) {
3113  E->Profile(ID, Context, true);
3114 }
3115 
3117  QualType UnderlyingType,
3118  UTTKind UKind,
3119  QualType CanonicalType)
3120  : Type(UnaryTransform, CanonicalType, BaseType->isDependentType(),
3121  BaseType->isInstantiationDependentType(),
3122  BaseType->isVariablyModifiedType(),
3123  BaseType->containsUnexpandedParameterPack()),
3124  BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind) {}
3125 
3127  QualType BaseType,
3128  UTTKind UKind)
3129  : UnaryTransformType(BaseType, C.DependentTy, UKind, QualType()) {}
3130 
3132  : Type(TC, can, D->isDependentType(),
3133  /*InstantiationDependent=*/D->isDependentType(),
3134  /*VariablyModified=*/false,
3135  /*ContainsUnexpandedParameterPack=*/false),
3136  decl(const_cast<TagDecl*>(D)) {}
3137 
3139  for (auto I : decl->redecls()) {
3140  if (I->isCompleteDefinition() || I->isBeingDefined())
3141  return I;
3142  }
3143  // If there's no definition (not even in progress), return what we have.
3144  return decl;
3145 }
3146 
3148  return getInterestingTagDecl(decl);
3149 }
3150 
3152  return getDecl()->isBeingDefined();
3153 }
3154 
3156  for (FieldDecl *FD : getDecl()->fields()) {
3157  QualType FieldTy = FD->getType();
3158  if (FieldTy.isConstQualified())
3159  return true;
3160  FieldTy = FieldTy.getCanonicalType();
3161  if (const auto *FieldRecTy = FieldTy->getAs<RecordType>())
3162  if (FieldRecTy->hasConstFields())
3163  return true;
3164  }
3165  return false;
3166 }
3167 
3169  // FIXME: Generate this with TableGen.
3170  switch (getAttrKind()) {
3171  // These are type qualifiers in the traditional C sense: they annotate
3172  // something about a specific value/variable of a type. (They aren't
3173  // always part of the canonical type, though.)
3174  case attr::ObjCGC:
3175  case attr::ObjCOwnership:
3176  case attr::ObjCInertUnsafeUnretained:
3177  case attr::TypeNonNull:
3178  case attr::TypeNullable:
3179  case attr::TypeNullUnspecified:
3180  case attr::LifetimeBound:
3181  return true;
3182 
3183  // All other type attributes aren't qualifiers; they rewrite the modified
3184  // type to be a semantically different type.
3185  default:
3186  return false;
3187  }
3188 }
3189 
3191  // FIXME: Generate this with TableGen?
3192  switch (getAttrKind()) {
3193  default: return false;
3194  case attr::Ptr32:
3195  case attr::Ptr64:
3196  case attr::SPtr:
3197  case attr::UPtr:
3198  return true;
3199  }
3200  llvm_unreachable("invalid attr kind");
3201 }
3202 
3204  // FIXME: Generate this with TableGen.
3205  switch (getAttrKind()) {
3206  default: return false;
3207  case attr::Pcs:
3208  case attr::CDecl:
3209  case attr::FastCall:
3210  case attr::StdCall:
3211  case attr::ThisCall:
3212  case attr::RegCall:
3213  case attr::SwiftCall:
3214  case attr::VectorCall:
3215  case attr::Pascal:
3216  case attr::MSABI:
3217  case attr::SysVABI:
3218  case attr::IntelOclBicc:
3219  case attr::PreserveMost:
3220  case attr::PreserveAll:
3221  return true;
3222  }
3223  llvm_unreachable("invalid attr kind");
3224 }
3225 
3227  return cast<CXXRecordDecl>(getInterestingTagDecl(Decl));
3228 }
3229 
3231  return isCanonicalUnqualified() ? nullptr : getDecl()->getIdentifier();
3232 }
3233 
3234 SubstTemplateTypeParmPackType::
3235 SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
3236  QualType Canon,
3237  const TemplateArgument &ArgPack)
3238  : Type(SubstTemplateTypeParmPack, Canon, true, true, false, true),
3239  Replaced(Param), Arguments(ArgPack.pack_begin()) {
3240  SubstTemplateTypeParmPackTypeBits.NumArgs = ArgPack.pack_size();
3241 }
3242 
3244  return TemplateArgument(llvm::makeArrayRef(Arguments, getNumArgs()));
3245 }
3246 
3247 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
3248  Profile(ID, getReplacedParameter(), getArgumentPack());
3249 }
3250 
3251 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
3252  const TemplateTypeParmType *Replaced,
3253  const TemplateArgument &ArgPack) {
3254  ID.AddPointer(Replaced);
3255  ID.AddInteger(ArgPack.pack_size());
3256  for (const auto &P : ArgPack.pack_elements())
3257  ID.AddPointer(P.getAsType().getAsOpaquePtr());
3258 }
3259 
3262  bool &InstantiationDependent) {
3263  return anyDependentTemplateArguments(Args.arguments(),
3264  InstantiationDependent);
3265 }
3266 
3269  bool &InstantiationDependent) {
3270  for (const TemplateArgumentLoc &ArgLoc : Args) {
3271  if (ArgLoc.getArgument().isDependent()) {
3272  InstantiationDependent = true;
3273  return true;
3274  }
3275 
3276  if (ArgLoc.getArgument().isInstantiationDependent())
3277  InstantiationDependent = true;
3278  }
3279  return false;
3280 }
3281 
3282 TemplateSpecializationType::
3283 TemplateSpecializationType(TemplateName T,
3285  QualType Canon, QualType AliasedType)
3286  : Type(TemplateSpecialization,
3287  Canon.isNull()? QualType(this, 0) : Canon,
3288  Canon.isNull()? true : Canon->isDependentType(),
3289  Canon.isNull()? true : Canon->isInstantiationDependentType(),
3290  false,
3291  T.containsUnexpandedParameterPack()), Template(T) {
3292  TemplateSpecializationTypeBits.NumArgs = Args.size();
3293  TemplateSpecializationTypeBits.TypeAlias = !AliasedType.isNull();
3294 
3295  assert(!T.getAsDependentTemplateName() &&
3296  "Use DependentTemplateSpecializationType for dependent template-name");
3297  assert((T.getKind() == TemplateName::Template ||
3300  "Unexpected template name for TemplateSpecializationType");
3301 
3302  auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1);
3303  for (const TemplateArgument &Arg : Args) {
3304  // Update instantiation-dependent and variably-modified bits.
3305  // If the canonical type exists and is non-dependent, the template
3306  // specialization type can be non-dependent even if one of the type
3307  // arguments is. Given:
3308  // template<typename T> using U = int;
3309  // U<T> is always non-dependent, irrespective of the type T.
3310  // However, U<Ts> contains an unexpanded parameter pack, even though
3311  // its expansion (and thus its desugared type) doesn't.
3312  if (Arg.isInstantiationDependent())
3314  if (Arg.getKind() == TemplateArgument::Type &&
3315  Arg.getAsType()->isVariablyModifiedType())
3317  if (Arg.containsUnexpandedParameterPack())
3319  new (TemplateArgs++) TemplateArgument(Arg);
3320  }
3321 
3322  // Store the aliased type if this is a type alias template specialization.
3323  if (isTypeAlias()) {
3324  auto *Begin = reinterpret_cast<TemplateArgument *>(this + 1);
3325  *reinterpret_cast<QualType*>(Begin + getNumArgs()) = AliasedType;
3326  }
3327 }
3328 
3329 void
3330 TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
3331  TemplateName T,
3333  const ASTContext &Context) {
3334  T.Profile(ID);
3335  for (const TemplateArgument &Arg : Args)
3336  Arg.Profile(ID, Context);
3337 }
3338 
3339 QualType
3340 QualifierCollector::apply(const ASTContext &Context, QualType QT) const {
3341  if (!hasNonFastQualifiers())
3342  return QT.withFastQualifiers(getFastQualifiers());
3343 
3344  return Context.getQualifiedType(QT, *this);
3345 }
3346 
3347 QualType
3348 QualifierCollector::apply(const ASTContext &Context, const Type *T) const {
3349  if (!hasNonFastQualifiers())
3350  return QualType(T, getFastQualifiers());
3351 
3352  return Context.getQualifiedType(T, *this);
3353 }
3354 
3355 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID,
3356  QualType BaseType,
3357  ArrayRef<QualType> typeArgs,
3358  ArrayRef<ObjCProtocolDecl *> protocols,
3359  bool isKindOf) {
3360  ID.AddPointer(BaseType.getAsOpaquePtr());
3361  ID.AddInteger(typeArgs.size());
3362  for (auto typeArg : typeArgs)
3363  ID.AddPointer(typeArg.getAsOpaquePtr());
3364  ID.AddInteger(protocols.size());
3365  for (auto proto : protocols)
3366  ID.AddPointer(proto);
3367  ID.AddBoolean(isKindOf);
3368 }
3369 
3370 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) {
3371  Profile(ID, getBaseType(), getTypeArgsAsWritten(),
3372  llvm::makeArrayRef(qual_begin(), getNumProtocols()),
3373  isKindOfTypeAsWritten());
3374 }
3375 
3376 void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID,
3377  const ObjCTypeParamDecl *OTPDecl,
3378  ArrayRef<ObjCProtocolDecl *> protocols) {
3379  ID.AddPointer(OTPDecl);
3380  ID.AddInteger(protocols.size());
3381  for (auto proto : protocols)
3382  ID.AddPointer(proto);
3383 }
3384 
3385 void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID) {
3386  Profile(ID, getDecl(),
3387  llvm::makeArrayRef(qual_begin(), getNumProtocols()));
3388 }
3389 
3390 namespace {
3391 
3392 /// The cached properties of a type.
3393 class CachedProperties {
3394  Linkage L;
3395  bool local;
3396 
3397 public:
3398  CachedProperties(Linkage L, bool local) : L(L), local(local) {}
3399 
3400  Linkage getLinkage() const { return L; }
3401  bool hasLocalOrUnnamedType() const { return local; }
3402 
3403  friend CachedProperties merge(CachedProperties L, CachedProperties R) {
3404  Linkage MergedLinkage = minLinkage(L.L, R.L);
3405  return CachedProperties(MergedLinkage,
3406  L.hasLocalOrUnnamedType() | R.hasLocalOrUnnamedType());
3407  }
3408 };
3409 
3410 } // namespace
3411 
3412 static CachedProperties computeCachedProperties(const Type *T);
3413 
3414 namespace clang {
3415 
3416 /// The type-property cache. This is templated so as to be
3417 /// instantiated at an internal type to prevent unnecessary symbol
3418 /// leakage.
3419 template <class Private> class TypePropertyCache {
3420 public:
3421  static CachedProperties get(QualType T) {
3422  return get(T.getTypePtr());
3423  }
3424 
3425  static CachedProperties get(const Type *T) {
3426  ensure(T);
3427  return CachedProperties(T->TypeBits.getLinkage(),
3428  T->TypeBits.hasLocalOrUnnamedType());
3429  }
3430 
3431  static void ensure(const Type *T) {
3432  // If the cache is valid, we're okay.
3433  if (T->TypeBits.isCacheValid()) return;
3434 
3435  // If this type is non-canonical, ask its canonical type for the
3436  // relevant information.
3437  if (!T->isCanonicalUnqualified()) {
3438  const Type *CT = T->getCanonicalTypeInternal().getTypePtr();
3439  ensure(CT);
3440  T->TypeBits.CacheValid = true;
3441  T->TypeBits.CachedLinkage = CT->TypeBits.CachedLinkage;
3442  T->TypeBits.CachedLocalOrUnnamed = CT->TypeBits.CachedLocalOrUnnamed;
3443  return;
3444  }
3445 
3446  // Compute the cached properties and then set the cache.
3447  CachedProperties Result = computeCachedProperties(T);
3448  T->TypeBits.CacheValid = true;
3449  T->TypeBits.CachedLinkage = Result.getLinkage();
3450  T->TypeBits.CachedLocalOrUnnamed = Result.hasLocalOrUnnamedType();
3451  }
3452 };
3453 
3454 } // namespace clang
3455 
3456 // Instantiate the friend template at a private class. In a
3457 // reasonable implementation, these symbols will be internal.
3458 // It is terrible that this is the best way to accomplish this.
3459 namespace {
3460 
3461 class Private {};
3462 
3463 } // namespace
3464 
3466 
3467 static CachedProperties computeCachedProperties(const Type *T) {
3468  switch (T->getTypeClass()) {
3469 #define TYPE(Class,Base)
3470 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
3471 #include "clang/AST/TypeNodes.def"
3472  llvm_unreachable("didn't expect a non-canonical type here");
3473 
3474 #define TYPE(Class,Base)
3475 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
3476 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
3477 #include "clang/AST/TypeNodes.def"
3478  // Treat instantiation-dependent types as external.
3479  assert(T->isInstantiationDependentType());
3480  return CachedProperties(ExternalLinkage, false);
3481 
3482  case Type::Auto:
3483  case Type::DeducedTemplateSpecialization:
3484  // Give non-deduced 'auto' types external linkage. We should only see them
3485  // here in error recovery.
3486  return CachedProperties(ExternalLinkage, false);
3487 
3488  case Type::Builtin:
3489  // C++ [basic.link]p8:
3490  // A type is said to have linkage if and only if:
3491  // - it is a fundamental type (3.9.1); or
3492  return CachedProperties(ExternalLinkage, false);
3493 
3494  case Type::Record:
3495  case Type::Enum: {
3496  const TagDecl *Tag = cast<TagType>(T)->getDecl();
3497 
3498  // C++ [basic.link]p8:
3499  // - it is a class or enumeration type that is named (or has a name
3500  // for linkage purposes (7.1.3)) and the name has linkage; or
3501  // - it is a specialization of a class template (14); or
3502  Linkage L = Tag->getLinkageInternal();
3503  bool IsLocalOrUnnamed =
3504  Tag->getDeclContext()->isFunctionOrMethod() ||
3505  !Tag->hasNameForLinkage();
3506  return CachedProperties(L, IsLocalOrUnnamed);
3507  }
3508 
3509  // C++ [basic.link]p8:
3510  // - it is a compound type (3.9.2) other than a class or enumeration,
3511  // compounded exclusively from types that have linkage; or
3512  case Type::Complex:
3513  return Cache::get(cast<ComplexType>(T)->getElementType());
3514  case Type::Pointer:
3515  return Cache::get(cast<PointerType>(T)->getPointeeType());
3516  case Type::BlockPointer:
3517  return Cache::get(cast<BlockPointerType>(T)->getPointeeType());
3518  case Type::LValueReference:
3519  case Type::RValueReference:
3520  return Cache::get(cast<ReferenceType>(T)->getPointeeType());
3521  case Type::MemberPointer: {
3522  const auto *MPT = cast<MemberPointerType>(T);
3523  return merge(Cache::get(MPT->getClass()),
3524  Cache::get(MPT->getPointeeType()));
3525  }
3526  case Type::ConstantArray:
3527  case Type::IncompleteArray:
3528  case Type::VariableArray:
3529  return Cache::get(cast<ArrayType>(T)->getElementType());
3530  case Type::Vector:
3531  case Type::ExtVector:
3532  return Cache::get(cast<VectorType>(T)->getElementType());
3533  case Type::FunctionNoProto:
3534  return Cache::get(cast<FunctionType>(T)->getReturnType());
3535  case Type::FunctionProto: {
3536  const auto *FPT = cast<FunctionProtoType>(T);
3537  CachedProperties result = Cache::get(FPT->getReturnType());
3538  for (const auto &ai : FPT->param_types())
3539  result = merge(result, Cache::get(ai));
3540  return result;
3541  }
3542  case Type::ObjCInterface: {
3543  Linkage L = cast<ObjCInterfaceType>(T)->getDecl()->getLinkageInternal();
3544  return CachedProperties(L, false);
3545  }
3546  case Type::ObjCObject:
3547  return Cache::get(cast<ObjCObjectType>(T)->getBaseType());
3548  case Type::ObjCObjectPointer:
3549  return Cache::get(cast<ObjCObjectPointerType>(T)->getPointeeType());
3550  case Type::Atomic:
3551  return Cache::get(cast<AtomicType>(T)->getValueType());
3552  case Type::Pipe:
3553  return Cache::get(cast<PipeType>(T)->getElementType());
3554  }
3555 
3556  llvm_unreachable("unhandled type class");
3557 }
3558 
3559 /// Determine the linkage of this type.
3561  Cache::ensure(this);
3562  return TypeBits.getLinkage();
3563 }
3564 
3566  Cache::ensure(this);
3567  return TypeBits.hasLocalOrUnnamedType();
3568 }
3569 
3571  switch (T->getTypeClass()) {
3572 #define TYPE(Class,Base)
3573 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
3574 #include "clang/AST/TypeNodes.def"
3575  llvm_unreachable("didn't expect a non-canonical type here");
3576 
3577 #define TYPE(Class,Base)
3578 #define DEPENDENT_TYPE(Class,Base) case Type::Class:
3579 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
3580 #include "clang/AST/TypeNodes.def"
3581  // Treat instantiation-dependent types as external.
3582  assert(T->isInstantiationDependentType());
3583  return LinkageInfo::external();
3584 
3585  case Type::Builtin:
3586  return LinkageInfo::external();
3587 
3588  case Type::Auto:
3589  case Type::DeducedTemplateSpecialization:
3590  return LinkageInfo::external();
3591 
3592  case Type::Record:
3593  case Type::Enum:
3594  return getDeclLinkageAndVisibility(cast<TagType>(T)->getDecl());
3595 
3596  case Type::Complex:
3597  return computeTypeLinkageInfo(cast<ComplexType>(T)->getElementType());
3598  case Type::Pointer:
3599  return computeTypeLinkageInfo(cast<PointerType>(T)->getPointeeType());
3600  case Type::BlockPointer:
3601  return computeTypeLinkageInfo(cast<BlockPointerType>(T)->getPointeeType());
3602  case Type::LValueReference:
3603  case Type::RValueReference:
3604  return computeTypeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
3605  case Type::MemberPointer: {
3606  const auto *MPT = cast<MemberPointerType>(T);
3607  LinkageInfo LV = computeTypeLinkageInfo(MPT->getClass());
3608  LV.merge(computeTypeLinkageInfo(MPT->getPointeeType()));
3609  return LV;
3610  }
3611  case Type::ConstantArray:
3612  case Type::IncompleteArray:
3613  case Type::VariableArray:
3614  return computeTypeLinkageInfo(cast<ArrayType>(T)->getElementType());
3615  case Type::Vector:
3616  case Type::ExtVector:
3617  return computeTypeLinkageInfo(cast<VectorType>(T)->getElementType());
3618  case Type::FunctionNoProto:
3619  return computeTypeLinkageInfo(cast<FunctionType>(T)->getReturnType());
3620  case Type::FunctionProto: {
3621  const auto *FPT = cast<FunctionProtoType>(T);
3622  LinkageInfo LV = computeTypeLinkageInfo(FPT->getReturnType());
3623  for (const auto &ai : FPT->param_types())
3624  LV.merge(computeTypeLinkageInfo(ai));
3625  return LV;
3626  }
3627  case Type::ObjCInterface:
3628  return getDeclLinkageAndVisibility(cast<ObjCInterfaceType>(T)->getDecl());
3629  case Type::ObjCObject:
3630  return computeTypeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType());
3631  case Type::ObjCObjectPointer:
3632  return computeTypeLinkageInfo(
3633  cast<ObjCObjectPointerType>(T)->getPointeeType());
3634  case Type::Atomic:
3635  return computeTypeLinkageInfo(cast<AtomicType>(T)->getValueType());
3636  case Type::Pipe:
3637  return computeTypeLinkageInfo(cast<PipeType>(T)->getElementType());
3638  }
3639 
3640  llvm_unreachable("unhandled type class");
3641 }
3642 
3643 bool Type::isLinkageValid() const {
3644  if (!TypeBits.isCacheValid())
3645  return true;
3646 
3647  Linkage L = LinkageComputer{}
3649  .getLinkage();
3650  return L == TypeBits.getLinkage();
3651 }
3652 
3654  if (!T->isCanonicalUnqualified())
3655  return computeTypeLinkageInfo(T->getCanonicalTypeInternal());
3656 
3657  LinkageInfo LV = computeTypeLinkageInfo(T);
3658  assert(LV.getLinkage() == T->getLinkage());
3659  return LV;
3660 }
3661 
3664 }
3665 
3667 Type::getNullability(const ASTContext &Context) const {
3668  QualType Type(this, 0);
3669  while (const auto *AT = Type->getAs<AttributedType>()) {
3670  // Check whether this is an attributed type with nullability
3671  // information.
3672  if (auto Nullability = AT->getImmediateNullability())
3673  return Nullability;
3674 
3675  Type = AT->getEquivalentType();
3676  }
3677  return None;
3678 }
3679 
3680 bool Type::canHaveNullability(bool ResultIfUnknown) const {
3682 
3683  switch (type->getTypeClass()) {
3684  // We'll only see canonical types here.
3685 #define NON_CANONICAL_TYPE(Class, Parent) \
3686  case Type::Class: \
3687  llvm_unreachable("non-canonical type");
3688 #define TYPE(Class, Parent)
3689 #include "clang/AST/TypeNodes.def"
3690 
3691  // Pointer types.
3692  case Type::Pointer:
3693  case Type::BlockPointer:
3694  case Type::MemberPointer:
3695  case Type::ObjCObjectPointer:
3696  return true;
3697 
3698  // Dependent types that could instantiate to pointer types.
3699  case Type::UnresolvedUsing:
3700  case Type::TypeOfExpr:
3701  case Type::TypeOf:
3702  case Type::Decltype:
3703  case Type::UnaryTransform:
3704  case Type::TemplateTypeParm:
3705  case Type::SubstTemplateTypeParmPack:
3706  case Type::DependentName:
3707  case Type::DependentTemplateSpecialization:
3708  case Type::Auto:
3709  return ResultIfUnknown;
3710 
3711  // Dependent template specializations can instantiate to pointer
3712  // types unless they're known to be specializations of a class
3713  // template.
3714  case Type::TemplateSpecialization:
3715  if (TemplateDecl *templateDecl
3716  = cast<TemplateSpecializationType>(type.getTypePtr())
3717  ->getTemplateName().getAsTemplateDecl()) {
3718  if (isa<ClassTemplateDecl>(templateDecl))
3719  return false;
3720  }
3721  return ResultIfUnknown;
3722 
3723  case Type::Builtin:
3724  switch (cast<BuiltinType>(type.getTypePtr())->getKind()) {
3725  // Signed, unsigned, and floating-point types cannot have nullability.
3726 #define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
3727 #define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
3728 #define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
3729 #define BUILTIN_TYPE(Id, SingletonId)
3730 #include "clang/AST/BuiltinTypes.def"
3731  return false;
3732 
3733  // Dependent types that could instantiate to a pointer type.
3734  case BuiltinType::Dependent:
3735  case BuiltinType::Overload:
3736  case BuiltinType::BoundMember:
3737  case BuiltinType::PseudoObject:
3738  case BuiltinType::UnknownAny:
3739  case BuiltinType::ARCUnbridgedCast:
3740  return ResultIfUnknown;
3741 
3742  case BuiltinType::Void:
3743  case BuiltinType::ObjCId:
3744  case BuiltinType::ObjCClass:
3745  case BuiltinType::ObjCSel:
3746 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3747  case BuiltinType::Id:
3748 #include "clang/Basic/OpenCLImageTypes.def"
3749  case BuiltinType::OCLSampler:
3750  case BuiltinType::OCLEvent:
3751  case BuiltinType::OCLClkEvent:
3752  case BuiltinType::OCLQueue:
3753  case BuiltinType::OCLReserveID:
3754  case BuiltinType::BuiltinFn:
3755  case BuiltinType::NullPtr:
3756  case BuiltinType::OMPArraySection:
3757  return false;
3758  }
3759  llvm_unreachable("unknown builtin type");
3760 
3761  // Non-pointer types.
3762  case Type::Complex:
3763  case Type::LValueReference:
3764  case Type::RValueReference:
3765  case Type::ConstantArray:
3766  case Type::IncompleteArray:
3767  case Type::VariableArray:
3768  case Type::DependentSizedArray:
3769  case Type::DependentVector:
3770  case Type::DependentSizedExtVector:
3771  case Type::Vector:
3772  case Type::ExtVector:
3773  case Type::DependentAddressSpace:
3774  case Type::FunctionProto:
3775  case Type::FunctionNoProto:
3776  case Type::Record:
3777  case Type::DeducedTemplateSpecialization:
3778  case Type::Enum:
3779  case Type::InjectedClassName:
3780  case Type::PackExpansion:
3781  case Type::ObjCObject:
3782  case Type::ObjCInterface:
3783  case Type::Atomic:
3784  case Type::Pipe:
3785  return false;
3786  }
3787  llvm_unreachable("bad type kind!");
3788 }
3789 
3792  if (getAttrKind() == attr::TypeNonNull)
3793  return NullabilityKind::NonNull;
3794  if (getAttrKind() == attr::TypeNullable)
3796  if (getAttrKind() == attr::TypeNullUnspecified)
3798  return None;
3799 }
3800 
3802  if (auto attributed = dyn_cast<AttributedType>(T.getTypePtr())) {
3803  if (auto nullability = attributed->getImmediateNullability()) {
3804  T = attributed->getModifiedType();
3805  return nullability;
3806  }
3807  }
3808 
3809  return None;
3810 }
3811 
3813  const auto *objcPtr = getAs<ObjCObjectPointerType>();
3814  if (!objcPtr)
3815  return false;
3816 
3817  if (objcPtr->isObjCIdType()) {
3818  // id is always okay.
3819  return true;
3820  }
3821 
3822  // Blocks are NSObjects.
3823  if (ObjCInterfaceDecl *iface = objcPtr->getInterfaceDecl()) {
3824  if (iface->getIdentifier() != ctx.getNSObjectName())
3825  return false;
3826 
3827  // Continue to check qualifiers, below.
3828  } else if (objcPtr->isObjCQualifiedIdType()) {
3829  // Continue to check qualifiers, below.
3830  } else {
3831  return false;
3832  }
3833 
3834  // Check protocol qualifiers.
3835  for (ObjCProtocolDecl *proto : objcPtr->quals()) {
3836  // Blocks conform to NSObject and NSCopying.
3837  if (proto->getIdentifier() != ctx.getNSObjectName() &&
3838  proto->getIdentifier() != ctx.getNSCopyingName())
3839  return false;
3840  }
3841 
3842  return true;
3843 }
3844 
3848  return Qualifiers::OCL_Strong;
3849 }
3850 
3852  assert(isObjCLifetimeType() &&
3853  "cannot query implicit lifetime for non-inferrable type");
3854 
3855  const Type *canon = getCanonicalTypeInternal().getTypePtr();
3856 
3857  // Walk down to the base type. We don't care about qualifiers for this.
3858  while (const auto *array = dyn_cast<ArrayType>(canon))
3859  canon = array->getElementType().getTypePtr();
3860 
3861  if (const auto *opt = dyn_cast<ObjCObjectPointerType>(canon)) {
3862  // Class and Class<Protocol> don't require retention.
3863  if (opt->getObjectType()->isObjCClass())
3864  return true;
3865  }
3866 
3867  return false;
3868 }
3869 
3871  const Type *cur = this;
3872  while (true) {
3873  if (const auto *typedefType = dyn_cast<TypedefType>(cur))
3874  return typedefType->getDecl()->hasAttr<ObjCNSObjectAttr>();
3875 
3876  // Single-step desugar until we run out of sugar.
3878  if (next.getTypePtr() == cur) return false;
3879  cur = next.getTypePtr();
3880  }
3881 }
3882 
3884  if (const auto *typedefType = dyn_cast<TypedefType>(this))
3885  return typedefType->getDecl()->hasAttr<ObjCIndependentClassAttr>();
3886  return false;
3887 }
3888 
3890  return isObjCObjectPointerType() ||
3891  isBlockPointerType() ||
3893 }
3894 
3896  if (isObjCLifetimeType())
3897  return true;
3898  if (const auto *OPT = getAs<PointerType>())
3899  return OPT->getPointeeType()->isObjCIndirectLifetimeType();
3900  if (const auto *Ref = getAs<ReferenceType>())
3901  return Ref->getPointeeType()->isObjCIndirectLifetimeType();
3902  if (const auto *MemPtr = getAs<MemberPointerType>())
3903  return MemPtr->getPointeeType()->isObjCIndirectLifetimeType();
3904  return false;
3905 }
3906 
3907 /// Returns true if objects of this type have lifetime semantics under
3908 /// ARC.
3910  const Type *type = this;
3911  while (const ArrayType *array = type->getAsArrayTypeUnsafe())
3912  type = array->getElementType().getTypePtr();
3913  return type->isObjCRetainableType();
3914 }
3915 
3916 /// Determine whether the given type T is a "bridgable" Objective-C type,
3917 /// which is either an Objective-C object pointer type or an
3920 }
3921 
3922 /// Determine whether the given type T is a "bridgeable" C type.
3924  const auto *Pointer = getAs<PointerType>();
3925  if (!Pointer)
3926  return false;
3927 
3928  QualType Pointee = Pointer->getPointeeType();
3929  return Pointee->isVoidType() || Pointee->isRecordType();
3930 }
3931 
3933  if (!isVariablyModifiedType()) return false;
3934 
3935  if (const auto *ptr = getAs<PointerType>())
3936  return ptr->getPointeeType()->hasSizedVLAType();
3937  if (const auto *ref = getAs<ReferenceType>())
3938  return ref->getPointeeType()->hasSizedVLAType();
3939  if (const ArrayType *arr = getAsArrayTypeUnsafe()) {
3940  if (isa<VariableArrayType>(arr) &&
3941  cast<VariableArrayType>(arr)->getSizeExpr())
3942  return true;
3943 
3944  return arr->getElementType()->hasSizedVLAType();
3945  }
3946 
3947  return false;
3948 }
3949 
3950 QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) {
3951  switch (type.getObjCLifetime()) {
3952  case Qualifiers::OCL_None:
3955  break;
3956 
3958  return DK_objc_strong_lifetime;
3959  case Qualifiers::OCL_Weak:
3960  return DK_objc_weak_lifetime;
3961  }
3962 
3963  if (const auto *RT =
3965  const RecordDecl *RD = RT->getDecl();
3966  if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3967  /// Check if this is a C++ object with a non-trivial destructor.
3968  if (CXXRD->hasDefinition() && !CXXRD->hasTrivialDestructor())
3969  return DK_cxx_destructor;
3970  } else {
3971  /// Check if this is a C struct that is non-trivial to destroy or an array
3972  /// that contains such a struct.
3974  return DK_nontrivial_c_struct;
3975  }
3976  }
3977 
3978  return DK_none;
3979 }
3980 
3982  return getClass()->getAsCXXRecordDecl()->getMostRecentNonInjectedDecl();
3983 }
3984 
3986  llvm::APSInt Val, unsigned Scale) {
3987  if (Val.isSigned() && Val.isNegative() && Val != -Val) {
3988  Val = -Val;
3989  Str.push_back('-');
3990  }
3991 
3992  llvm::APSInt IntPart = Val >> Scale;
3993 
3994  // Add 4 digits to hold the value after multiplying 10 (the radix)
3995  unsigned Width = Val.getBitWidth() + 4;
3996  llvm::APInt FractPart = Val.zextOrTrunc(Scale).zext(Width);
3997  llvm::APInt FractPartMask = llvm::APInt::getAllOnesValue(Scale).zext(Width);
3998  llvm::APInt RadixInt = llvm::APInt(Width, 10);
3999 
4000  IntPart.toString(Str, /*radix=*/10);
4001  Str.push_back('.');
4002  do {
4003  (FractPart * RadixInt)
4004  .lshr(Scale)
4005  .toString(Str, /*radix=*/10, Val.isSigned());
4006  FractPart = (FractPart * RadixInt) & FractPartMask;
4007  } while (FractPart != 0);
4008 }
DecltypeType(Expr *E, QualType underlyingType, QualType can=QualType())
Definition: Type.cpp:3089
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:4711
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:5103
const Type * Ty
The locally-unqualified type.
Definition: Type.h:583
bool isStruct() const
Definition: Decl.h:3241
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:4906
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:5629
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:5038
DependentUnaryTransformType(const ASTContext &C, QualType BaseType, UTTKind UKind)
Definition: Type.cpp:3126
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:2995
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:2533
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were written.
Definition: Type.h:5623
QualType getPointeeType() const
Definition: Type.h:2546
A (possibly-)qualified type.
Definition: Type.h:642
bool isBlockPointerType() const
Definition: Type.h:6278
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:6319
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:3571
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:3351
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:3918
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.cpp:3247
bool isRecordType() const
Definition: Type.h:6343
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1939
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:3147
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:4725
QualType desugar() const
Remove a single level of sugar.
Definition: Type.cpp:3101
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
Definition: Type.cpp:3056
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:2808
bool isObjCBoxableRecordType() const
Definition: Type.cpp:441
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1582
DependentDecltypeType(const ASTContext &Context, Expr *E)
Definition: Type.cpp:3108
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:699
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5957
bool isCARCBridgableType() const
Determine whether the given type T is a "bridgeable" C type.
Definition: Type.cpp:3923
bool isUnspecialized() const
Determine whether this object type is "unspecialized", meaning that it has no type arguments...
Definition: Type.h:5612
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3560
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:2843
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3161
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:3467
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:3242
bool isStructureType() const
Definition: Type.cpp:435
bool isEnumeralType() const
Definition: Type.h:6347
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6683
The "union" keyword.
Definition: Type.h:5013
Extra information about a function prototype.
Definition: Type.h:3752
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type...
Definition: Type.h:6755
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:5010
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:3203
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
LinkageInfo computeTypeLinkageInfo(const Type *T)
Definition: Type.cpp:3570
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4579
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:6331
bool isSugared() const
Returns whether this type directly provides sugar.
Definition: Type.cpp:3099
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:3243
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3061
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:3680
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:3585
QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced, QualType Replacement) const
Retrieve a substitution-result type.
QualType getOriginalType() const
Definition: Type.h:2597
bool isWideCharType() const
Definition: Type.cpp:1788
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3753
bool isComplete() const
Returns true if this can be considered a complete type.
Definition: Decl.h:3526
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:5512
bool isObjCIndependentClassType() const
Definition: Type.cpp:3883
QualType getPointeeType() const
Definition: Type.h:2650
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:3876
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:3909
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
Definition: Type.cpp:3268
bool isCharType() const
Definition: Type.cpp:1779
bool isSpelledAsLValue() const
Definition: Type.h:2685
Represents a member of a struct/union/class.
Definition: Decl.h:2571
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:6282
qual_iterator qual_begin() const
Definition: Type.h:5413
unsigned char getOpaqueValue() const
Definition: Type.h:3426
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:3106
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:2734
bool isMSTypeSpec() const
Definition: Type.cpp:3190
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:6732
The "struct" keyword introduces the elaborated-type-specifier.
Definition: Type.h:5026
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:2786
CXXRecordDecl * getDecl() const
Definition: Type.cpp:3226
Values of this type can never be null.
Expr * getSizeExpr() const
Definition: Type.h:2987
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6046
LinkageInfo getTypeLinkageAndVisibility(const Type *T)
Definition: Type.cpp:3653
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:3138
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type...
Definition: Decl.h:3262
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:3812
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:166
bool isScalarType() const
Definition: Type.h:6582
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:5747
PrimitiveDefaultInitializeKind
Definition: Type.h:1081
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3738
SplitQualType getSplitDesugaredType() const
Definition: Type.h:946
QualType getPointeeTypeAsWritten() const
Definition: Type.h:2688
TagType(TypeClass TC, const TagDecl *D, QualType can)
Definition: Type.cpp:3131
unsigned getNumProtocols() const
Return the number of qualifying protocols in this type, or 0 if there are none.
Definition: Type.h:5420
QualType getElementType() const
Definition: Type.h:3140
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:3124
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:3639
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:5606
bool hasAttr() const
Definition: DeclBase.h:531
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:5575
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Definition: Type.cpp:1609
static void ensure(const Type *T)
Definition: Type.cpp:3431
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:3676
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:1680
ArraySizeModifier
Capture whether this is a normal array (e.g.
Definition: Type.h:2814
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:2486
IdentifierInfo * getIdentifier() const
Definition: Type.cpp:3230
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:105
Defines the clang::LangOptions interface.
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition: Type.h:5042
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
Definition: Type.cpp:3851
QualType desugar() const
Definition: Type.h:3207
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:6746
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:5024
bool isObjCRetainableType() const
Definition: Type.cpp:3889
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:6351
SourceLocation Begin
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4256
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:4222
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:3268
QualType desugar() const
Remove a single level of sugar.
Definition: Type.cpp:3077
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
QualType getType() const
Definition: Expr.h:127
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:3801
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:4265
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:2060
bool hasInstantiationDependentExceptionSpec() const
Return whether this function has an instantiation-dependent exception spec.
Definition: Type.cpp:2954
A helper class for Type nodes having an ElaboratedTypeKeyword.
Definition: Type.h:5052
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:1386
Represents a GCC generic vector type.
Definition: Type.h:3164
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2845
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2716
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition: Type.h:4685
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6641
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:4161
bool isNonTrivialToPrimitiveDestroy() const
Definition: Decl.h:3700
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:6105
IdentifierInfo * getNSCopyingName()
Retrieve the identifier &#39;NSCopying&#39;.
Definition: ASTContext.h:1689
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:3994
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:6054
RecordDecl * getDecl() const
Definition: Type.h:4356
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:3662
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:5007
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:6085
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3728
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:190
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:3880
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:3759
Encodes a location in the source.
Sugar for parentheses used when specifying types.
Definition: Type.h:2503
QualType getAdjustedType() const
Definition: Type.h:2598
QualType getReturnType() const
Definition: Type.h:3607
bool isLinkageValid() const
True if the computed linkage is valid.
Definition: Type.cpp:3643
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4372
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:6162
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5712
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2094
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:3056
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3243
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
QualType getElementType() const
Definition: Type.h:3199
void FixedPointValueToString(SmallVectorImpl< char > &Str, llvm::APSInt Val, unsigned Scale)
Definition: Type.cpp:3985
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:5399
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:4427
void Profile(llvm::FoldingSetNodeID &ID)
Definition: TemplateName.h:305
QualType getInnerType() const
Definition: Type.h:2516
bool isObjCObjectPointerType() const
Definition: Type.h:6367
AutoTypeKeyword getKeyword() const
Definition: Type.h:4740
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:5640
EnumDecl * getDecl() const
Definition: Type.h:4379
bool isVectorType() const
Definition: Type.h:6355
__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:3155
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:3066
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:2084
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:2618
Represents a pack expansion of types.
Definition: Type.h:5329
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:3981
Represents a template argument.
Definition: TemplateBase.h:51
bool isDeduced() const
Definition: Type.h:4714
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:2581
TagTypeKind
The kind of a tag type.
Definition: Type.h:5005
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:1057
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:3618
not evaluated yet, for special member function
A qualifier set is used to build a set of qualifiers.
Definition: Type.h:6013
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:3565
static CachedProperties get(QualType T)
Definition: Type.cpp:3421
bool hasDependentExceptionSpec() const
Return whether this function has a dependent exception spec.
Definition: Type.cpp:2942
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:2963
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:4233
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:3370
VectorKind getVectorKind() const
Definition: Type.h:3209
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:551
The "union" keyword introduces the elaborated-type-specifier.
Definition: Type.h:5032
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition: Type.h:6020
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:3150
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.cpp:3385
bool isObjCIndirectLifetimeType() const
Definition: Type.cpp:3895
The "class" keyword introduces the elaborated-type-specifier.
Definition: Type.h:5035
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:3318
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2752
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:3168
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:3340
UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind, QualType CanonicalTy)
Definition: Type.cpp:3116
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:4594
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:4426
Represents a pointer to an Objective C object.
Definition: Type.h:5768
Pointer to a block type.
Definition: Type.h:2635
bool isSugared() const
Returns whether this type directly provides sugar.
Definition: Type.cpp:3073
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:4346
Complex values, per C99 6.2.5p11.
Definition: Type.h:2473
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
unsigned getIndexTypeCVRQualifiers() const
Definition: Type.h:2853
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:2354
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:6531
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
Definition: Type.cpp:2963
const llvm::APInt & getSize() const
Definition: Type.h:2886
Kind getAttrKind() const
Definition: Type.h:4422
VectorTypeBitfields VectorTypeBits
Definition: Type.h:1723
ExtVectorType - Extended vector type.
Definition: Type.h:3283
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2669
SourceRange getBracketsRange() const
Definition: Type.h:2993
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:3667
The "class" keyword.
Definition: Type.h:5016
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2794
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
Definition: Type.cpp:3151
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2076
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3731
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:3419
bool isClassType() const
Definition: Type.cpp:429
TypedefNameDecl * getDecl() const
Definition: Type.h:4143
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:3734
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4401
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:6497
Represents a C array with an unspecified size.
Definition: Type.h:2922
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:5143
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4600
The "enum" keyword.
Definition: Type.h:5019
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:213
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4186
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
Definition: Type.cpp:3845
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:2390
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:3200
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:2078
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:4817
bool isPointerType() const
Definition: Type.h:6270
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
static StringRef getNameForCallConv(CallingConv CC)
Definition: Type.cpp:2810
#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:2965
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:3579
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2967
No keyword precedes the qualified type name.
Definition: Type.h:5045
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:5291
QualType desugar() const
Definition: Type.cpp:3062
const LangOptions & getLangOpts() const
Definition: ASTContext.h:716
unsigned size() const
Determine the number of type parameters in this list.
Definition: DeclObjC.h:669
llvm::Optional< NullabilityKind > getImmediateNullability() const
Definition: Type.cpp:3791
The "__interface" keyword introduces the elaborated-type-specifier.
Definition: Type.h:5029
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2868
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3758
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:3870
bool hasSizedVLAType() const
Whether this type involves a variable-length array type with a definite size.
Definition: Type.cpp:3932
QualType getPointeeType() const
Definition: Type.h:2772
A single template declaration.
Definition: TemplateName.h:191
bool isBeingDefined() const
Return true if this decl is currently being defined.
Definition: Decl.h:3181
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:5784