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