17 #ifndef LLVM_CLANG_AST_TYPE_H
18 #define LLVM_CLANG_AST_TYPE_H
35 #include "llvm/ADT/APInt.h"
36 #include "llvm/ADT/APSInt.h"
37 #include "llvm/ADT/ArrayRef.h"
38 #include "llvm/ADT/FoldingSet.h"
39 #include "llvm/ADT/PointerIntPair.h"
40 #include "llvm/ADT/PointerUnion.h"
41 #include "llvm/ADT/STLForwardCompat.h"
42 #include "llvm/ADT/StringRef.h"
43 #include "llvm/ADT/Twine.h"
44 #include "llvm/ADT/iterator_range.h"
45 #include "llvm/Support/Casting.h"
46 #include "llvm/Support/Compiler.h"
47 #include "llvm/Support/ErrorHandling.h"
48 #include "llvm/Support/PointerLikeTypeTraits.h"
49 #include "llvm/Support/TrailingObjects.h"
50 #include "llvm/Support/type_traits.h"
57 #include <type_traits>
68 class TemplateParameterList;
76 namespace serialization {
77 template <
class T>
class AbstractTypeReader;
114 template <
typename>
class CanQual;
119 class ExtQualsTypeCommonBase;
121 class IdentifierInfo;
123 class ObjCInterfaceDecl;
124 class ObjCProtocolDecl;
125 class ObjCTypeParamDecl;
126 struct PrintingPolicy;
130 class TemplateArgument;
131 class TemplateArgumentListInfo;
132 class TemplateArgumentLoc;
133 class TemplateTypeParmDecl;
134 class TypedefNameDecl;
135 class UnresolvedUsingTypenameDecl;
136 class UsingShadowDecl;
141 #define TYPE(Class, Base) class Class##Type;
142 #include "clang/AST/TypeNodes.inc"
149 EnabledMask = 1 << EnabledShift,
150 AddressDiscriminatedShift = EnabledShift + EnabledBits,
151 AddressDiscriminatedBits = 1,
152 AddressDiscriminatedMask = 1 << AddressDiscriminatedShift,
153 AuthenticationModeShift =
154 AddressDiscriminatedShift + AddressDiscriminatedBits,
155 AuthenticationModeBits = 2,
156 AuthenticationModeMask = ((1 << AuthenticationModeBits) - 1)
157 << AuthenticationModeShift,
158 IsaPointerShift = AuthenticationModeShift + AuthenticationModeBits,
160 IsaPointerMask = ((1 << IsaPointerBits) - 1) << IsaPointerShift,
161 AuthenticatesNullValuesShift = IsaPointerShift + IsaPointerBits,
162 AuthenticatesNullValuesBits = 1,
163 AuthenticatesNullValuesMask = ((1 << AuthenticatesNullValuesBits) - 1)
164 << AuthenticatesNullValuesShift,
165 KeyShift = AuthenticatesNullValuesShift + AuthenticatesNullValuesBits,
167 KeyMask = ((1 << KeyBits) - 1) << KeyShift,
168 DiscriminatorShift = KeyShift + KeyBits,
169 DiscriminatorBits = 16,
170 DiscriminatorMask = ((1u << DiscriminatorBits) - 1) << DiscriminatorShift,
181 static_assert((EnabledBits + AddressDiscriminatedBits +
182 AuthenticationModeBits + IsaPointerBits +
183 AuthenticatesNullValuesBits + KeyBits + DiscriminatorBits) ==
185 "PointerAuthQualifier should be exactly 32 bits");
186 static_assert((EnabledMask + AddressDiscriminatedMask +
187 AuthenticationModeMask + IsaPointerMask +
188 AuthenticatesNullValuesMask + KeyMask + DiscriminatorMask) ==
190 "All masks should cover the entire bits");
191 static_assert((EnabledMask ^ AddressDiscriminatedMask ^
192 AuthenticationModeMask ^ IsaPointerMask ^
193 AuthenticatesNullValuesMask ^ KeyMask ^ DiscriminatorMask) ==
195 "All masks should cover the entire bits");
198 unsigned ExtraDiscriminator,
200 bool IsIsaPointer,
bool AuthenticatesNullValues)
202 (IsAddressDiscriminated
203 ? llvm::to_underlying(AddressDiscriminatedMask)
206 (llvm::to_underlying(AuthenticationMode)
207 << AuthenticationModeShift) |
208 (ExtraDiscriminator << DiscriminatorShift) |
209 (IsIsaPointer << IsaPointerShift) |
210 (AuthenticatesNullValues << AuthenticatesNullValuesShift)) {
213 assert((
Data == 0) ==
232 Create(
unsigned Key,
bool IsAddressDiscriminated,
unsigned ExtraDiscriminator,
234 bool AuthenticatesNullValues) {
239 AuthenticationMode, IsIsaPointer,
240 AuthenticatesNullValues);
244 assert((
Data == 0) ==
253 return (
Data & KeyMask) >> KeyShift;
260 return (
Data & AddressDiscriminatedMask) >> AddressDiscriminatedShift;
265 return (
Data >> DiscriminatorShift);
270 AuthenticationModeShift);
275 return (
Data & IsaPointerMask) >> IsaPointerShift;
280 return (
Data & AuthenticatesNullValuesMask) >> AuthenticatesNullValuesShift;
288 return Lhs.Data == Rhs.Data;
291 return Lhs.Data != Rhs.Data;
303 Result.Data = Opaque;
304 assert((Result.Data == 0) ==
384 Q.Mask = L.Mask & R.Mask;
478 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
479 Mask = (Mask & ~
CVRMask) | mask;
482 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
483 Mask &= ~static_cast<uint64_t>(mask);
489 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
493 assert(!(mask & ~
CVRMask & ~UMask) &&
"bitmask contains non-CVRU bits");
499 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
507 Mask = (Mask & ~GCAttrMask) | (
type << GCAttrShift);
532 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
535 Mask = (Mask & ~LifetimeMask) | (
type << LifetimeShift);
541 Mask |= (
type << LifetimeShift);
558 return static_cast<LangAS>(Mask >> AddressSpaceShift);
579 Mask = (Mask & ~AddressSpaceMask)
580 | (((uint32_t) space) << AddressSpaceShift);
593 Mask = (Mask & ~PtrAuthMask) |
607 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
611 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
612 Mask &= ~static_cast<uint64_t>(mask);
618 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
633 bool empty()
const {
return !Mask; }
806 bool appendSpaceIfNonEmpty =
false)
const;
808 void Profile(llvm::FoldingSetNodeID &
ID)
const {
ID.AddInteger(Mask); }
815 "PointerAuthQualifier must be 32 bits");
817 static constexpr
uint64_t UMask = 0x8;
818 static constexpr
uint64_t UShift = 3;
819 static constexpr
uint64_t GCAttrMask = 0x30;
820 static constexpr
uint64_t GCAttrShift = 4;
821 static constexpr
uint64_t LifetimeMask = 0x1C0;
822 static constexpr
uint64_t LifetimeShift = 6;
823 static constexpr
uint64_t AddressSpaceMask =
824 ~(
CVRMask | UMask | GCAttrMask | LifetimeMask);
825 static constexpr
uint64_t AddressSpaceShift = 9;
826 static constexpr
uint64_t PtrAuthShift = 32;
827 static constexpr
uint64_t PtrAuthMask =
uint64_t(0xffffffff) << PtrAuthShift;
837 : Quals(Quals), HasAtomic(HasAtomic) {}
886 std::pair<const Type *,Qualifiers>
asPair()
const {
887 return std::pair<const Type *, Qualifiers>(
Ty,
Quals);
891 return a.
Ty ==
b.Ty && a.
Quals ==
b.Quals;
894 return a.
Ty !=
b.Ty || a.
Quals !=
b.Quals;
944 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
947 const ExtQuals *getExtQualsUnsafe()
const {
951 const Type *getTypePtrUnsafe()
const {
952 return Value.getPointer().get<
const Type*>();
955 const ExtQualsTypeCommonBase *getCommonPtr()
const {
956 assert(!
isNull() &&
"Cannot retrieve a NULL type pointer");
957 auto CommonPtrVal =
reinterpret_cast<uintptr_t>(
Value.getOpaqueValue());
959 return reinterpret_cast<ExtQualsTypeCommonBase*
>(CommonPtrVal);
991 T.Value.setFromOpaqueValue(
const_cast<void*
>(Ptr));
1008 return Value.getPointer().isNull();
1035 std::optional<NonConstantStorageReason>
1180 &&
"non-fast qualifier bits set in mask!");
1198 T.addFastQualifiers(TQs);
1211 T.removeLocalFastQualifiers();
1305 return getSingleStepDesugaredTypeImpl(*
this, Context);
1311 if (isa<ParenType>(*
this))
1318 return LHS.Value == RHS.Value;
1321 return LHS.Value != RHS.Value;
1324 return LHS.Value < RHS.Value;
1338 const Twine &PlaceHolder = Twine(),
1339 unsigned Indentation = 0)
const;
1343 unsigned Indentation = 0) {
1349 const Twine &PlaceHolder,
1350 unsigned Indentation = 0);
1367 const Twine &PlaceHolder;
1368 unsigned Indentation;
1372 const Twine &PlaceHolder,
unsigned Indentation)
1373 :
T(
T), Policy(Policy), PlaceHolder(PlaceHolder),
1374 Indentation(Indentation) {}
1378 SQT.T.
print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1384 const Twine &PlaceHolder = Twine(),
1385 unsigned Indentation = 0)
const {
1389 void dump(
const char *
s)
const;
1391 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
1531 return isDestructedTypeImpl(*
this);
1629 raw_ostream &
operator<<(raw_ostream &OS, QualType QT);
1649 return P.getAsOpaquePtr();
1657 static constexpr
int NumLowBitsAvailable = 0;
1677 const Type *
const BaseType;
1683 : BaseType(baseType), CanonicalType(canon) {}
1697 public llvm::FoldingSetNode {
1720 canon.isNull() ?
QualType(this_(), 0) : canon),
1722 assert(Quals.hasNonFastQualifiers()
1723 &&
"ExtQuals created with no fast qualifiers");
1724 assert(!Quals.hasFastQualifiers()
1725 &&
"ExtQuals created with fast qualifiers");
1735 return Quals.getObjCLifetime();
1745 Profile(
ID, getBaseType(), Quals);
1749 const Type *BaseType,
1752 ID.AddPointer(BaseType);
1816 #define TYPE(Class, Base) Class,
1817 #define LAST_TYPE(Class) TypeLast = Class
1818 #define ABSTRACT_TYPE(Class, Base)
1819 #include "clang/AST/TypeNodes.inc"
1824 class TypeBitfields {
1826 template <
class T>
friend class TypePropertyCache;
1829 LLVM_PREFERRED_TYPE(TypeClass)
1834 unsigned Dependence : llvm::BitWidth<TypeDependence>;
1838 LLVM_PREFERRED_TYPE(
bool)
1839 mutable unsigned CacheValid : 1;
1843 mutable unsigned CachedLinkage : 3;
1846 LLVM_PREFERRED_TYPE(
bool)
1847 mutable unsigned CachedLocalOrUnnamed : 1;
1850 LLVM_PREFERRED_TYPE(
bool)
1851 mutable unsigned FromAST : 1;
1853 bool isCacheValid()
const {
1858 assert(isCacheValid() &&
"getting linkage from invalid cache");
1859 return static_cast<Linkage>(CachedLinkage);
1862 bool hasLocalOrUnnamedType()
const {
1863 assert(isCacheValid() &&
"getting linkage from invalid cache");
1864 return CachedLocalOrUnnamed;
1867 enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
1876 LLVM_PREFERRED_TYPE(TypeBitfields)
1882 unsigned IndexTypeQuals : 3;
1887 unsigned SizeModifier : 3;
1889 enum { NumArrayTypeBits = NumTypeBits + 6 };
1898 LLVM_PREFERRED_TYPE(
bool)
1899 unsigned HasExternalSize : 1;
1901 LLVM_PREFERRED_TYPE(
unsigned)
1902 unsigned SizeWidth : 5;
1908 LLVM_PREFERRED_TYPE(TypeBitfields)
1912 static constexpr
unsigned NumOfBuiltinTypeBits = 9;
1913 unsigned Kind : NumOfBuiltinTypeBits;
1923 LLVM_PREFERRED_TYPE(TypeBitfields)
1929 unsigned ExtInfo : 13;
1935 unsigned RefQualifier : 2;
1946 LLVM_PREFERRED_TYPE(
bool)
1947 unsigned HasExtQuals : 1;
1953 unsigned NumParams : 16;
1957 unsigned ExceptionSpecType : 4;
1960 LLVM_PREFERRED_TYPE(
bool)
1961 unsigned HasExtParameterInfos : 1;
1964 LLVM_PREFERRED_TYPE(
bool)
1965 unsigned HasExtraBitfields : 1;
1968 LLVM_PREFERRED_TYPE(
bool)
1969 unsigned Variadic : 1;
1972 LLVM_PREFERRED_TYPE(
bool)
1973 unsigned HasTrailingReturn : 1;
1979 LLVM_PREFERRED_TYPE(TypeBitfields)
1983 unsigned NumTypeArgs : 7;
1986 unsigned NumProtocols : 6;
1989 LLVM_PREFERRED_TYPE(
bool)
1990 unsigned IsKindOf : 1;
1996 LLVM_PREFERRED_TYPE(TypeBitfields)
2010 LLVM_PREFERRED_TYPE(
bool)
2011 unsigned SpelledAsLValue : 1;
2015 LLVM_PREFERRED_TYPE(
bool)
2016 unsigned InnerRef : 1;
2022 LLVM_PREFERRED_TYPE(TypeBitfields)
2027 unsigned Keyword : 8;
2030 enum { NumTypeWithKeywordBits = NumTypeBits + 8 };
2039 LLVM_PREFERRED_TYPE(
bool)
2040 unsigned HasOwnedTagDecl : 1;
2047 LLVM_PREFERRED_TYPE(TypeBitfields)
2053 unsigned VecKind : 4;
2055 uint32_t NumElements;
2061 LLVM_PREFERRED_TYPE(TypeBitfields)
2065 unsigned AttrKind : 32 - NumTypeBits;
2071 LLVM_PREFERRED_TYPE(TypeBitfields)
2077 unsigned Keyword : 2;
2093 LLVM_PREFERRED_TYPE(TypeBitfields)
2095 LLVM_PREFERRED_TYPE(
bool)
2096 unsigned IsUnqual : 1;
2102 LLVM_PREFERRED_TYPE(TypeBitfields)
2106 LLVM_PREFERRED_TYPE(
bool)
2107 unsigned hasTypeDifferentFromDecl : 1;
2113 LLVM_PREFERRED_TYPE(TypeBitfields)
2117 LLVM_PREFERRED_TYPE(
bool)
2118 unsigned hasTypeDifferentFromDecl : 1;
2124 LLVM_PREFERRED_TYPE(TypeBitfields)
2127 LLVM_PREFERRED_TYPE(
bool)
2128 unsigned HasNonCanonicalUnderlyingType : 1;
2131 unsigned Index : 15;
2138 unsigned PackIndex : 16;
2144 LLVM_PREFERRED_TYPE(TypeBitfields)
2148 unsigned Index : 16;
2154 unsigned NumArgs : 16;
2160 LLVM_PREFERRED_TYPE(TypeBitfields)
2164 LLVM_PREFERRED_TYPE(
bool)
2165 unsigned TypeAlias : 1;
2196 LLVM_PREFERRED_TYPE(TypeBitfields)
2210 unsigned NumExpansions;
2216 LLVM_PREFERRED_TYPE(TypeBitfields)
2219 static constexpr
unsigned NumCoupledDeclsBits = 4;
2220 unsigned NumCoupledDecls : NumCoupledDeclsBits;
2221 LLVM_PREFERRED_TYPE(
bool)
2222 unsigned CountInBytes : 1;
2223 LLVM_PREFERRED_TYPE(
bool)
2224 unsigned OrNull : 1;
2257 void setFromAST(
bool V =
true)
const {
2258 TypeBits.FromAST =
V;
2266 canon.isNull() ?
QualType(this_(), 0) : canon) {
2267 static_assert(
sizeof(*
this) <=
2269 "changing bitfields changed sizeof(Type)!");
2270 static_assert(
alignof(decltype(*
this)) %
TypeAlignment == 0,
2271 "Insufficient alignment!");
2273 TypeBits.Dependence =
static_cast<unsigned>(
Dependence);
2274 TypeBits.CacheValid =
false;
2275 TypeBits.CachedLocalOrUnnamed =
false;
2277 TypeBits.FromAST =
false;
2284 TypeBits.Dependence =
static_cast<unsigned>(D);
2321 return getDependence() & TypeDependence::UnexpandedPack;
2327 return CanonicalType ==
QualType(
this, 0);
2333 QualType getLocallyUnqualifiedSingleStepDesugaredType()
const;
2341 bool isSizelessType()
const;
2342 bool isSizelessBuiltinType()
const;
2345 bool isSizelessVectorType()
const;
2348 bool isSVESizelessBuiltinType()
const;
2351 bool isRVVSizelessBuiltinType()
const;
2354 bool isWebAssemblyExternrefType()
const;
2359 bool isWebAssemblyTableType()
const;
2364 bool isSveVLSBuiltinType()
const;
2374 bool isRVVVLSBuiltinType()
const;
2396 bool isIncompleteType(
NamedDecl **Def =
nullptr)
const;
2401 return !isFunctionType();
2409 return !isReferenceType() && !isFunctionType() && !isVoidType();
2414 bool isLiteralType(
const ASTContext &Ctx)
const;
2417 bool isStructuralType()
const;
2421 bool isStandardLayoutType()
const;
2427 bool isBuiltinType()
const;
2430 bool isSpecificBuiltinType(
unsigned K)
const;
2435 bool isPlaceholderType()
const;
2439 bool isSpecificPlaceholderType(
unsigned K)
const;
2443 bool isNonOverloadPlaceholderType()
const;
2447 bool isIntegerType()
const;
2448 bool isEnumeralType()
const;
2451 bool isScopedEnumeralType()
const;
2453 bool isCharType()
const;
2454 bool isWideCharType()
const;
2455 bool isChar8Type()
const;
2456 bool isChar16Type()
const;
2457 bool isChar32Type()
const;
2458 bool isAnyCharacterType()
const;
2462 bool isIntegralOrEnumerationType()
const;
2465 bool isIntegralOrUnscopedEnumerationType()
const;
2466 bool isUnscopedEnumerationType()
const;
2469 bool isRealFloatingType()
const;
2472 bool isComplexType()
const;
2473 bool isAnyComplexType()
const;
2474 bool isFloatingType()
const;
2475 bool isHalfType()
const;
2476 bool isFloat16Type()
const;
2477 bool isFloat32Type()
const;
2478 bool isDoubleType()
const;
2479 bool isBFloat16Type()
const;
2480 bool isFloat128Type()
const;
2481 bool isIbm128Type()
const;
2482 bool isRealType()
const;
2483 bool isArithmeticType()
const;
2484 bool isVoidType()
const;
2485 bool isScalarType()
const;
2486 bool isAggregateType()
const;
2487 bool isFundamentalType()
const;
2488 bool isCompoundType()
const;
2492 bool isFunctionType()
const;
2495 bool isPointerType()
const;
2496 bool isAnyPointerType()
const;
2497 bool isCountAttributedType()
const;
2498 bool isBlockPointerType()
const;
2499 bool isVoidPointerType()
const;
2500 bool isReferenceType()
const;
2501 bool isLValueReferenceType()
const;
2502 bool isRValueReferenceType()
const;
2503 bool isObjectPointerType()
const;
2504 bool isFunctionPointerType()
const;
2505 bool isFunctionReferenceType()
const;
2506 bool isMemberPointerType()
const;
2507 bool isMemberFunctionPointerType()
const;
2508 bool isMemberDataPointerType()
const;
2509 bool isArrayType()
const;
2510 bool isConstantArrayType()
const;
2511 bool isIncompleteArrayType()
const;
2512 bool isVariableArrayType()
const;
2513 bool isArrayParameterType()
const;
2514 bool isDependentSizedArrayType()
const;
2516 bool isClassType()
const;
2517 bool isStructureType()
const;
2518 bool isObjCBoxableRecordType()
const;
2519 bool isInterfaceType()
const;
2520 bool isStructureOrClassType()
const;
2521 bool isUnionType()
const;
2522 bool isComplexIntegerType()
const;
2523 bool isVectorType()
const;
2524 bool isExtVectorType()
const;
2525 bool isExtVectorBoolType()
const;
2526 bool isSubscriptableVectorType()
const;
2527 bool isMatrixType()
const;
2528 bool isConstantMatrixType()
const;
2529 bool isDependentAddressSpaceType()
const;
2530 bool isObjCObjectPointerType()
const;
2531 bool isObjCRetainableType()
const;
2532 bool isObjCLifetimeType()
const;
2533 bool isObjCIndirectLifetimeType()
const;
2534 bool isObjCNSObjectType()
const;
2535 bool isObjCIndependentClassType()
const;
2538 bool isObjCObjectType()
const;
2539 bool isObjCQualifiedInterfaceType()
const;
2540 bool isObjCQualifiedIdType()
const;
2541 bool isObjCQualifiedClassType()
const;
2542 bool isObjCObjectOrInterfaceType()
const;
2543 bool isObjCIdType()
const;
2544 bool isDecltypeType()
const;
2552 return hasAttr(attr::ObjCInertUnsafeUnretained);
2562 bool isObjCIdOrObjectKindOfType(
const ASTContext &ctx,
2565 bool isObjCClassType()
const;
2573 bool isObjCClassOrClassKindOfType()
const;
2575 bool isBlockCompatibleObjCPointerType(
ASTContext &ctx)
const;
2576 bool isObjCSelType()
const;
2577 bool isObjCBuiltinType()
const;
2578 bool isObjCARCBridgableType()
const;
2579 bool isCARCBridgableType()
const;
2580 bool isTemplateTypeParmType()
const;
2581 bool isNullPtrType()
const;
2583 bool isNothrowT()
const;
2584 bool isAlignValT()
const;
2585 bool isStdByteType()
const;
2586 bool isAtomicType()
const;
2587 bool isUndeducedAutoType()
const;
2589 bool isTypedefNameType()
const;
2591 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2592 bool is##Id##Type() const;
2593 #include "clang/Basic/OpenCLImageTypes.def"
2594 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2595 bool isSampled##Id##Type() const;
2596 #define IMAGE_WRITE_TYPE(Type, Id, Ext)
2597 #define IMAGE_READ_WRITE_TYPE(Type, Id, Ext)
2598 #include "clang/Basic/OpenCLImageTypes.def"
2600 bool isImageType()
const;
2601 bool isSampledImageType()
const;
2603 bool isSamplerT()
const;
2604 bool isEventT()
const;
2605 bool isClkEventT()
const;
2606 bool isQueueT()
const;
2607 bool isReserveIDT()
const;
2609 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2610 bool is##Id##Type() const;
2611 #include "clang/Basic/OpenCLExtensionTypes.def"
2613 bool isOCLIntelSubgroupAVCType()
const;
2614 bool isOCLExtOpaqueType()
const;
2616 bool isPipeType()
const;
2617 bool isBitIntType()
const;
2618 bool isOpenCLSpecificType()
const;
2623 bool isObjCARCImplicitlyUnretainedType()
const;
2626 bool isCUDADeviceBuiltinSurfaceType()
const;
2628 bool isCUDADeviceBuiltinTextureType()
const;
2661 return getDependence() & TypeDependence::Dependent;
2669 return getDependence() & TypeDependence::Instantiation;
2675 bool isUndeducedType()
const;
2679 return getDependence() & TypeDependence::VariablyModified;
2684 bool hasSizedVLAType()
const;
2687 bool hasUnnamedOrLocalType()
const;
2689 bool isOverloadableType()
const;
2692 bool isElaboratedTypeSpecifier()
const;
2694 bool canDecayToPointerType()
const;
2699 bool hasPointerRepresentation()
const;
2703 bool hasObjCPointerRepresentation()
const;
2707 bool hasIntegerRepresentation()
const;
2711 bool hasSignedIntegerRepresentation()
const;
2715 bool hasUnsignedIntegerRepresentation()
const;
2719 bool hasFloatingRepresentation()
const;
2724 const RecordType *getAsStructureType()
const;
2727 const ComplexType *getAsComplexIntegerType()
const;
2748 TagDecl *getAsTagDecl()
const;
2766 return dyn_cast_or_null<AutoType>(getContainedDeducedType());
2772 bool hasAutoForTrailingReturnType()
const;
2780 template <
typename T>
const T *getAs()
const;
2787 template <
typename T>
const T *getAsAdjusted()
const;
2791 const ArrayType *getAsArrayTypeUnsafe()
const;
2799 template <
typename T>
const T *castAs()
const;
2803 const ArrayType *castAsArrayTypeUnsafe()
const;
2812 const Type *getBaseElementTypeUnsafe()
const;
2817 const Type *getArrayElementTypeNoTypeQual()
const;
2822 const Type *getPointeeOrArrayElementType()
const;
2830 const Type *getUnqualifiedDesugaredType()
const;
2835 bool isSignedIntegerType()
const;
2840 bool isUnsignedIntegerType()
const;
2844 bool isSignedIntegerOrEnumerationType()
const;
2848 bool isUnsignedIntegerOrEnumerationType()
const;
2852 bool isFixedPointType()
const;
2855 bool isFixedPointOrIntegerType()
const;
2858 bool isConvertibleToFixedPointType()
const;
2862 bool isSaturatedFixedPointType()
const;
2866 bool isUnsaturatedFixedPointType()
const;
2870 bool isSignedFixedPointType()
const;
2874 bool isUnsignedFixedPointType()
const;
2879 bool isConstantSizeType()
const;
2883 bool isSpecifierType()
const;
2890 return getLinkageAndVisibility().getVisibility();
2895 return getLinkageAndVisibility().isVisibilityExplicit();
2903 bool isLinkageValid()
const;
2910 std::optional<NullabilityKind> getNullability()
const;
2917 bool canHaveNullability(
bool ResultIfUnknown =
true)
const;
2934 std::optional<ArrayRef<QualType>>
2935 getObjCSubstitutions(
const DeclContext *dc)
const;
2939 bool acceptsObjCTypeParams()
const;
2941 const char *getTypeClassName()
const;
2944 return CanonicalType;
2954 template <>
const TypedefType *
Type::getAs()
const;
2960 template <>
const TemplateSpecializationType *
Type::getAs()
const;
2964 template <>
const AttributedType *
Type::getAs()
const;
2968 template <>
const BoundsAttributedType *
Type::getAs()
const;
2972 template <>
const CountAttributedType *
Type::getAs()
const;
2976 #define TYPE(Class, Base)
2977 #define LEAF_TYPE(Class) \
2978 template <> inline const Class##Type *Type::getAs() const { \
2979 return dyn_cast<Class##Type>(CanonicalType); \
2981 template <> inline const Class##Type *Type::castAs() const { \
2982 return cast<Class##Type>(CanonicalType); \
2984 #include "clang/AST/TypeNodes.inc"
2992 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2993 #include "clang/Basic/OpenCLImageTypes.def"
2994 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Sampled##Id,
2995 #define IMAGE_WRITE_TYPE(Type, Id, Ext)
2996 #define IMAGE_READ_WRITE_TYPE(Type, Id, Ext)
2997 #include "clang/Basic/OpenCLImageTypes.def"
2999 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
3000 #include "clang/Basic/OpenCLExtensionTypes.def"
3002 #define SVE_TYPE(Name, Id, SingletonId) Id,
3003 #include "clang/Basic/AArch64SVEACLETypes.def"
3005 #define PPC_VECTOR_TYPE(Name, Id, Size) Id,
3006 #include "clang/Basic/PPCTypes.def"
3008 #define RVV_TYPE(Name, Id, SingletonId) Id,
3009 #include "clang/Basic/RISCVVTypes.def"
3011 #define WASM_TYPE(Name, Id, SingletonId) Id,
3012 #include "clang/Basic/WebAssemblyReferenceTypes.def"
3014 #define BUILTIN_TYPE(Id, SingletonId) Id,
3015 #define LAST_BUILTIN_TYPE(Id) LastKind = Id
3016 #include "clang/AST/BuiltinTypes.def"
3026 static_assert(Kind::LastKind <
3027 (1 << BuiltinTypeBitfields::NumOfBuiltinTypeBits) &&
3028 "Defined builtin type exceeds the allocated space for serial "
3030 BuiltinTypeBits.Kind = K;
3039 StringRef str =
getName(Policy);
3040 assert(!str.empty() && str.data()[str.size()] ==
'\0');
3069 return K >= Overload;
3076 return isPlaceholderTypeKind(
getKind());
3103 :
Type(
Complex, CanonicalPtr, Element->getDependence()),
3104 ElementType(Element) {}
3113 Profile(
ID, getElementType());
3117 ID.AddPointer(Element.getAsOpaquePtr());
3130 :
Type(
Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}
3139 Profile(
ID, getInnerType());
3156 :
Type(
Pointer, CanonicalPtr, Pointee->getDependence()),
3157 PointeeType(Pointee) {}
3166 Profile(
ID, getPointeeType());
3180 using BaseTy = llvm::PointerIntPair<ValueDecl *, 1, unsigned>;
3195 bool isDeref()
const;
3197 unsigned getInt()
const;
3198 void *getOpaqueValue()
const;
3200 void setFromOpaqueValue(
void *
V);
3231 return decl_range(dependent_decl_begin(), dependent_decl_end());
3235 return {dependent_decl_begin(), dependent_decl_end()};
3238 bool referencesFieldDecls()
const;
3245 case CountAttributed:
3257 public llvm::TrailingObjects<CountAttributedType,
3258 TypeCoupledDeclRefInfo> {
3269 bool CountInBytes,
bool OrNull,
3272 unsigned numTrailingObjects(OverloadToken<TypeCoupledDeclRefInfo>)
const {
3273 return CountAttributedTypeBits.NumCoupledDecls;
3286 bool isOrNull()
const {
return CountAttributedTypeBits.OrNull; }
3290 return isCountInBytes() ? SizedByOrNull : CountedByOrNull;
3291 return isCountInBytes() ? SizedBy : CountedBy;
3295 Profile(
ID, desugar(), CountExpr, isCountInBytes(), isOrNull());
3298 static void Profile(llvm::FoldingSetNodeID &
ID,
QualType WrappedTy,
3299 Expr *CountExpr,
bool CountInBytes,
bool Nullable);
3318 :
Type(TC, CanonicalPtr, OriginalTy->getDependence()),
3319 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
3329 Profile(
ID, OriginalTy, AdjustedTy);
3352 inline QualType getPointeeType()
const;
3367 :
Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
3368 PointeeType(Pointee) {}
3378 Profile(
ID, getPointeeType());
3396 bool SpelledAsLValue)
3397 :
Type(tc, CanonicalRef, Referencee->getDependence()),
3398 PointeeType(Referencee) {
3399 ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
3412 while (
T->isInnerRef())
3414 return T->PointeeType;
3418 Profile(
ID, PointeeType, isSpelledAsLValue());
3423 bool SpelledAsLValue) {
3425 ID.AddBoolean(SpelledAsLValue);
3439 bool SpelledAsLValue)
3481 :
Type(MemberPointer, CanonicalPtr,
3483 Pointee->getDependence()),
3484 PointeeType(Pointee),
Class(Cls) {}
3508 Profile(
ID, getPointeeType(), getClass());
3512 const Type *Class) {
3538 unsigned tq,
const Expr *sz =
nullptr);
3552 return ArrayTypeBits.IndexTypeQuals;
3570 struct ExternalSize {
3572 : Size(Sz), SizeExpr(SE) {}
3574 const Expr *SizeExpr;
3584 :
ArrayType(ConstantArray, Et, Can,
SM, TQ, nullptr), Size(Sz) {
3585 ConstantArrayTypeBits.HasExternalSize =
false;
3586 ConstantArrayTypeBits.SizeWidth = Width / 8;
3589 assert(Width < 0xFF &&
"Type width in bits must be less than 8 bits");
3592 ConstantArrayType(QualType Et, QualType Can, ExternalSize *SzPtr,
3594 : ArrayType(ConstantArray, Et, Can,
SM, TQ, SzPtr->SizeExpr),
3596 ConstantArrayTypeBits.HasExternalSize =
true;
3597 ConstantArrayTypeBits.SizeWidth = 0;
3599 assert((SzPtr->SizeExpr ==
nullptr || !Can.isNull()) &&
3600 "canonical constant array should not have size expression");
3603 static ConstantArrayType *
Create(
const ASTContext &Ctx, QualType ET,
3610 :
ArrayType(Tc, ATy->getElementType(), Can, ATy->getSizeModifier(),
3611 ATy->getIndexTypeQualifiers().getAsOpaqueValue(), nullptr) {
3612 ConstantArrayTypeBits.HasExternalSize =
3614 if (!ConstantArrayTypeBits.HasExternalSize) {
3624 return ConstantArrayTypeBits.HasExternalSize
3626 :
llvm::APInt(ConstantArrayTypeBits.SizeWidth * 8, Size);
3631 return ConstantArrayTypeBits.HasExternalSize
3632 ? SizePtr->Size.getBitWidth()
3633 :
static_cast<unsigned>(ConstantArrayTypeBits.SizeWidth * 8);
3638 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.isZero()
3644 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.getZExtValue()
3650 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.getSExtValue()
3657 return ConstantArrayTypeBits.HasExternalSize
3658 ? SizePtr->Size.getLimitedValue()
3664 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->SizeExpr :
nullptr;
3672 static unsigned getNumAddressingBits(
const ASTContext &Context,
3676 unsigned getNumAddressingBits(
const ASTContext &Context)
const;
3680 static unsigned getMaxSizeBits(
const ASTContext &Context);
3683 Profile(
ID, Ctx, getElementType(), getZExtSize(), getSizeExpr(),
3684 getSizeModifier(), getIndexTypeCVRQualifiers());
3687 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx,
3719 :
ArrayType(IncompleteArray, et, can, sm, tq) {}
3732 Profile(
ID, getElementType(), getSizeModifier(),
3733 getIndexTypeCVRQualifiers());
3739 ID.AddInteger(llvm::to_underlying(SizeMod));
3740 ID.AddInteger(TypeQuals);
3771 :
ArrayType(VariableArray, et, can, sm, tq, e),
3772 SizeExpr((
Stmt*) e), Brackets(brackets) {}
3780 return (
Expr*) SizeExpr;
3795 llvm_unreachable(
"Cannot unique VariableArrayTypes.");
3835 return (
Expr*) SizeExpr;
3850 Profile(
ID, Context, getElementType(),
3851 getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
3854 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
3856 unsigned TypeQuals,
Expr *E);
3873 Expr *AddrSpaceExpr;
3893 Profile(
ID, Context, getPointeeType(), getAddrSpaceExpr());
3896 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
3936 Profile(
ID, Context, getElementType(), getSizeExpr());
3939 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
4005 Profile(
ID, getElementType(), getNumElements(),
4006 getTypeClass(), getVectorKind());
4013 ID.AddInteger(NumElements);
4015 ID.AddInteger(llvm::to_underlying(VecKind));
4058 Profile(
ID, Context, getElementType(), getSizeExpr(), getVectorKind());
4061 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
4076 :
VectorType(ExtVector, vecType, nElements, canonType,
4083 case 'x':
case 'r':
return 0;
4084 case 'y':
case 'g':
return 1;
4085 case 'z':
case 'b':
return 2;
4086 case 'w':
case 'a':
return 3;
4104 case 'a':
return 10;
4106 case 'b':
return 11;
4108 case 'c':
return 12;
4110 case 'd':
return 13;
4112 case 'e':
return 14;
4114 case 'f':
return 15;
4119 if (isNumericAccessor)
4120 return getNumericAccessorIdx(
c);
4122 return getPointAccessorIdx(
c);
4126 if (
int idx = getAccessorIdx(
c, isNumericAccessor)+1)
4127 return unsigned(idx-1) < getNumElements();
4152 const Expr *RowExpr =
nullptr,
const Expr *ColumnExpr =
nullptr);
4186 static constexpr
unsigned MaxElementsPerDimension = (1 << 20) - 1;
4189 unsigned NColumns,
QualType CanonElementType);
4192 unsigned NColumns,
QualType CanonElementType);
4203 return getNumRows() * getNumColumns();
4208 return NumElements > 0 && NumElements <= MaxElementsPerDimension;
4213 return MaxElementsPerDimension;
4217 Profile(
ID, getElementType(), getNumRows(), getNumColumns(),
4222 unsigned NumRows,
unsigned NumColumns,
4225 ID.AddInteger(NumRows);
4226 ID.AddInteger(NumColumns);
4258 Profile(
ID, Context, getElementType(), getRowExpr(), getColumnExpr());
4261 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
4297 HasPassObjSize = 0x20,
4300 unsigned char Data = 0;
4309 copy.Data = (copy.Data & ~ABIMask) |
unsigned(
kind);
4319 copy.Data |= IsConsumed;
4321 copy.Data &= ~IsConsumed;
4328 Copy.Data |= HasPassObjSize;
4336 Copy.Data |= IsNoEscape;
4338 Copy.Data &= ~IsNoEscape;
4350 return lhs.Data == rhs.Data;
4354 return lhs.Data != rhs.Data;
4389 enum { CallConvMask = 0x1F };
4390 enum { NoReturnMask = 0x20 };
4391 enum { ProducesResultMask = 0x40 };
4392 enum { NoCallerSavedRegsMask = 0x80 };
4394 RegParmMask = 0x700,
4397 enum { NoCfCheckMask = 0x800 };
4398 enum { CmseNSCallMask = 0x1000 };
4399 uint16_t Bits =
CC_C;
4401 ExtInfo(
unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
4407 bool producesResult,
bool noCallerSavedRegs,
bool NoCfCheck,
4409 assert((!hasRegParm || regParm < 7) &&
"Invalid regparm value");
4410 Bits = ((
unsigned)cc) | (noReturn ? NoReturnMask : 0) |
4411 (producesResult ? ProducesResultMask : 0) |
4412 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
4413 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
4414 (NoCfCheck ? NoCfCheckMask : 0) |
4415 (cmseNSCall ? CmseNSCallMask : 0);
4431 bool getHasRegParm()
const {
return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
4434 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
4443 return Bits ==
Other.Bits;
4446 return Bits !=
Other.Bits;
4454 return ExtInfo(Bits | NoReturnMask);
4456 return ExtInfo(Bits & ~NoReturnMask);
4461 return ExtInfo(Bits | ProducesResultMask);
4463 return ExtInfo(Bits & ~ProducesResultMask);
4468 return ExtInfo(Bits | CmseNSCallMask);
4470 return ExtInfo(Bits & ~CmseNSCallMask);
4474 if (noCallerSavedRegs)
4475 return ExtInfo(Bits | NoCallerSavedRegsMask);
4477 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
4482 return ExtInfo(Bits | NoCfCheckMask);
4484 return ExtInfo(Bits & ~NoCfCheckMask);
4488 assert(RegParm < 7 &&
"Invalid regparm value");
4489 return ExtInfo((Bits & ~RegParmMask) |
4490 ((RegParm + 1) << RegParmOffset));
4494 return ExtInfo((Bits & ~CallConvMask) | (
unsigned) cc);
4498 ID.AddInteger(Bits);
4516 LLVM_PREFERRED_TYPE(
bool)
4520 : NumExceptionType(0), HasArmTypeAttributes(
false) {}
4527 SME_NormalFunction = 0,
4528 SME_PStateSMEnabledMask = 1 << 0,
4529 SME_PStateSMCompatibleMask = 1 << 1,
4533 SME_ZAMask = 0b111 << SME_ZAShift,
4535 SME_ZT0Mask = 0b111 << SME_ZT0Shift,
4551 return (
ArmStateValue)((AttrBits & SME_ZAMask) >> SME_ZAShift);
4555 return (
ArmStateValue)((AttrBits & SME_ZT0Mask) >> SME_ZT0Shift);
4573 FunctionTypeBits.ExtInfo = Info.Bits;
4577 if (isFunctionProtoType())
4599 "Const, volatile and restrict are assumed to be a subset of "
4600 "the fast qualifiers.");
4602 bool isConst()
const {
return getFastTypeQuals().hasConst(); }
4603 bool isVolatile()
const {
return getFastTypeQuals().hasVolatile(); }
4604 bool isRestrict()
const {
return getFastTypeQuals().hasRestrict(); }
4612 static StringRef getNameForCallConv(
CallingConv CC);
4627 Result->getDependence() &
4639 Profile(
ID, getReturnType(), getExtInfo());
4662 public llvm::FoldingSetNode,
4663 private llvm::TrailingObjects<
4664 FunctionProtoType, QualType, SourceLocation,
4665 FunctionType::FunctionTypeExtraBitfields,
4666 FunctionType::FunctionTypeArmAttributes, FunctionType::ExceptionType,
4667 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
4669 friend TrailingObjects;
4759 AArch64SMEAttributes(SME_NormalFunction) {}
4763 AArch64SMEAttributes(SME_NormalFunction) {}
4767 Result.ExceptionSpec = ESI;
4773 requiresFunctionProtoTypeArmAttributes();
4777 return AArch64SMEAttributes != SME_NormalFunction;
4782 AArch64SMEAttributes |=
Kind;
4784 AArch64SMEAttributes &= ~
Kind;
4789 unsigned numTrailingObjects(OverloadToken<QualType>)
const {
4790 return getNumParams();
4793 unsigned numTrailingObjects(OverloadToken<SourceLocation>)
const {
4794 return isVariadic();
4797 unsigned numTrailingObjects(OverloadToken<FunctionTypeArmAttributes>)
const {
4798 return hasArmTypeAttributes();
4801 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>)
const {
4802 return hasExtraBitfields();
4805 unsigned numTrailingObjects(OverloadToken<ExceptionType>)
const {
4806 return getExceptionSpecSize().NumExceptionType;
4809 unsigned numTrailingObjects(OverloadToken<Expr *>)
const {
4810 return getExceptionSpecSize().NumExprPtr;
4813 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>)
const {
4814 return getExceptionSpecSize().NumFunctionDeclPtr;
4817 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>)
const {
4818 return hasExtParameterInfos() ? getNumParams() : 0;
4823 static bool containsAnyUnexpandedParameterPack(
const QualType *ArgArray,
4825 for (
unsigned Idx = 0; Idx < numArgs; ++Idx)
4826 if (ArgArray[Idx]->containsUnexpandedParameterPack())
4832 FunctionProtoType(QualType result, ArrayRef<QualType> params,
4833 QualType canonical,
const ExtProtoInfo &epi);
4838 struct ExceptionSpecSizeHolder {
4839 unsigned NumExceptionType;
4840 unsigned NumExprPtr;
4841 unsigned NumFunctionDeclPtr;
4846 static ExceptionSpecSizeHolder
4858 return {NumExceptions, 0, 0};
4871 llvm_unreachable(
"bad exception specification kind");
4876 ExceptionSpecSizeHolder getExceptionSpecSize()
const {
4877 return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
4881 bool hasExtraBitfields()
const {
4883 FunctionTypeBits.HasExtraBitfields) &&
4884 "ExtraBitfields are required for given ExceptionSpecType");
4885 return FunctionTypeBits.HasExtraBitfields;
4889 bool hasArmTypeAttributes()
const {
4890 return FunctionTypeBits.HasExtraBitfields &&
4891 getTrailingObjects<FunctionTypeExtraBitfields>()
4892 ->HasArmTypeAttributes;
4895 bool hasExtQualifiers()
const {
4896 return FunctionTypeBits.HasExtQuals;
4903 assert(i < getNumParams() &&
"invalid parameter index");
4904 return param_type_begin()[i];
4928 FunctionTypeBits.ExceptionSpecType);
4945 bool hasDependentExceptionSpec()
const;
4949 bool hasInstantiationDependentExceptionSpec()
const;
4954 Result.Type = getExceptionSpecType();
4956 Result.Exceptions = exceptions();
4958 Result.NoexceptExpr = getNoexceptExpr();
4960 Result.SourceDecl = getExceptionSpecDecl();
4961 Result.SourceTemplate = getExceptionSpecTemplate();
4963 Result.SourceDecl = getExceptionSpecDecl();
4971 ? getTrailingObjects<FunctionTypeExtraBitfields>()
4978 assert(i < getNumExceptions() &&
"Invalid exception number!");
4979 return exception_begin()[i];
4987 return *getTrailingObjects<Expr *>();
4998 return getTrailingObjects<FunctionDecl *>()[0];
5008 return getTrailingObjects<FunctionDecl *>()[1];
5019 return ResultIfDependent ? canThrow() !=
CT_Can : canThrow() ==
CT_Cannot;
5026 return isVariadic() ? *getTrailingObjects<SourceLocation>()
5036 bool isTemplateVariadic()
const;
5042 if (hasExtQualifiers())
5043 return *getTrailingObjects<Qualifiers>();
5045 return getFastTypeQuals();
5060 return getTrailingObjects<QualType>();
5064 return param_type_begin() + getNumParams();
5075 getTrailingObjects<ExceptionType>());
5079 return exception_begin() + getNumExceptions();
5085 return FunctionTypeBits.HasExtParameterInfos;
5089 assert(hasExtParameterInfos());
5098 if (!hasExtParameterInfos())
5100 return getTrailingObjects<ExtParameterInfo>();
5106 if (!hasArmTypeAttributes())
5107 return SME_NormalFunction;
5108 return getTrailingObjects<FunctionTypeArmAttributes>()
5109 ->AArch64SMEAttributes;
5113 assert(I < getNumParams() &&
"parameter index out of range");
5114 if (hasExtParameterInfos())
5115 return getTrailingObjects<ExtParameterInfo>()[I];
5120 assert(I < getNumParams() &&
"parameter index out of range");
5121 if (hasExtParameterInfos())
5122 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
5127 assert(I < getNumParams() &&
"parameter index out of range");
5128 if (hasExtParameterInfos())
5129 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
5136 void printExceptionSpecification(raw_ostream &OS,
5143 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx);
5176 return Profile(
ID,
Decl);
5186 public llvm::FoldingSetNode,
5187 private llvm::TrailingObjects<UsingType, QualType> {
5190 friend TrailingObjects;
5211 ID.AddPointer(Found);
5218 public llvm::FoldingSetNode,
5219 private llvm::TrailingObjects<TypedefType, QualType> {
5222 friend TrailingObjects;
5244 if (!Underlying.
isNull())
5261 :
Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
5262 UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
5263 assert(isa<AttributedType>(UnderlyingTy) &&
5264 "Expected a macro qualified type to only wrap attributed types.");
5306 bool isSugared()
const;
5318 public llvm::FoldingSetNode {
5323 Profile(
ID, Context, getUnderlyingExpr(),
5327 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5328 Expr *E,
bool IsUnqual);
5342 T->getDependence()),
5386 bool isSugared()
const;
5402 Profile(
ID, Context, getUnderlyingExpr());
5405 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5411 public llvm::FoldingSetNode,
5412 private llvm::TrailingObjects<PackIndexingType, QualType> {
5413 friend TrailingObjects;
5434 if (hasSelectedType())
5435 return getSelectedType();
5440 assert(hasSelectedType() &&
"Type is dependant");
5441 return *(getExpansionsPtr() + *getSelectedIndex());
5444 std::optional<unsigned> getSelectedIndex()
const;
5449 return {getExpansionsPtr(), Size};
5457 if (hasSelectedType())
5458 getSelectedType().Profile(
ID);
5460 Profile(
ID, Context, getPattern(), getIndexExpr());
5462 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5466 const QualType *getExpansionsPtr()
const {
5467 return getTrailingObjects<QualType>();
5471 ArrayRef<QualType> Expansions = {});
5473 unsigned numTrailingObjects(OverloadToken<QualType>)
const {
return Size; }
5480 #define TRANSFORM_TYPE_TRAIT_DEF(Enum, _) Enum,
5481 #include "clang/Basic/TransformTypeTraits.def"
5489 QualType UnderlyingType;
5520 public llvm::FoldingSetNode {
5526 Profile(
ID, getBaseType(), getUTTKind());
5532 ID.AddInteger((
unsigned)UKind);
5551 bool isBeingDefined()
const;
5576 bool hasConstFields()
const;
5627 :
Type(Attributed, canon, equivalent->getDependence()),
5628 ModifiedType(modified), EquivalentType(equivalent) {
5629 AttributedTypeBits.AttrKind = attrKind;
5634 return static_cast<Kind>(AttributedTypeBits.AttrKind);
5660 bool isMSTypeSpec()
const;
5662 bool isWebAssemblyFuncrefSpec()
const;
5664 bool isCallingConv()
const;
5666 std::optional<NullabilityKind> getImmediateNullability()
const;
5673 return attr::TypeNonNull;
5676 return attr::TypeNullable;
5679 return attr::TypeNullableResult;
5682 return attr::TypeNullUnspecified;
5684 llvm_unreachable(
"Unknown nullability kind.");
5696 static std::optional<NullabilityKind> stripOuterNullability(
QualType &
T);
5699 Profile(
ID, getAttrKind(), ModifiedType, EquivalentType);
5704 ID.AddInteger(attrKind);
5719 const BTFTypeTagAttr *BTFAttr;
5722 const BTFTypeTagAttr *BTFAttr)
5723 :
Type(BTFTagAttributed, Canon, Wrapped->getDependence()),
5724 WrappedType(Wrapped), BTFAttr(BTFAttr) {}
5728 const BTFTypeTagAttr *
getAttr()
const {
return BTFAttr; }
5734 Profile(
ID, WrappedType, BTFAttr);
5738 const BTFTypeTagAttr *BTFAttr) {
5740 ID.AddPointer(BTFAttr);
5752 struct CanonicalTTPTInfo {
5753 unsigned Depth : 15;
5754 unsigned ParameterPack : 1;
5755 unsigned Index : 16;
5768 :
Type(TemplateTypeParm, Canon,
5774 TemplateTypeParmType(
unsigned D,
unsigned I,
bool PP)
5775 :
Type(TemplateTypeParm, QualType(this, 0),
5778 CanTTPTInfo.Depth = D;
5779 CanTTPTInfo.Index = I;
5780 CanTTPTInfo.ParameterPack = PP;
5783 const CanonicalTTPTInfo& getCanTTPTInfo()
const {
5784 QualType Can = getCanonicalTypeInternal();
5785 return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
5789 unsigned getDepth()
const {
return getCanTTPTInfo().Depth; }
5790 unsigned getIndex()
const {
return getCanTTPTInfo().Index; }
5794 return isCanonicalUnqualified() ? nullptr : TTPDecl;
5807 unsigned Index,
bool ParameterPack,
5810 ID.AddInteger(Index);
5811 ID.AddBoolean(ParameterPack);
5812 ID.AddPointer(TTPDecl);
5829 public llvm::FoldingSetNode,
5830 private llvm::TrailingObjects<SubstTemplateTypeParmType, QualType> {
5834 Decl *AssociatedDecl;
5837 unsigned Index, std::optional<unsigned> PackIndex);
5843 return SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType
5844 ? *getTrailingObjects<QualType>()
5845 : getCanonicalTypeInternal();
5858 unsigned getIndex()
const {
return SubstTemplateTypeParmTypeBits.Index; }
5861 if (SubstTemplateTypeParmTypeBits.PackIndex == 0)
5862 return std::nullopt;
5863 return SubstTemplateTypeParmTypeBits.PackIndex - 1;
5870 Profile(
ID, getReplacementType(), getAssociatedDecl(), getIndex(),
5875 const Decl *AssociatedDecl,
unsigned Index,
5876 std::optional<unsigned> PackIndex) {
5877 Replacement.Profile(
ID);
5878 ID.AddPointer(AssociatedDecl);
5879 ID.AddInteger(Index);
5880 ID.AddInteger(PackIndex ? *PackIndex - 1 : 0);
5907 llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
5910 unsigned Index,
bool Final,
5919 Decl *getAssociatedDecl()
const;
5926 unsigned getIndex()
const {
return SubstTemplateTypeParmPackTypeBits.Index; }
5929 bool getFinal()
const;
5932 return SubstTemplateTypeParmPackTypeBits.NumArgs;
5940 void Profile(llvm::FoldingSetNodeID &
ID);
5941 static void Profile(llvm::FoldingSetNodeID &
ID,
const Decl *AssociatedDecl,
5942 unsigned Index,
bool Final,
5965 ExtraDependence | (DeducedAsType.isNull()
5967 : DeducedAsType->getDependence() &
5969 DeducedAsType(DeducedAsType) {}
5974 return isSugared() ? DeducedAsType :
QualType(
this, 0);
5981 return !DeducedAsType.
isNull() || isDependentType();
6004 AutoTypeBits.NumArgs};
6008 return TypeConstraintConcept;
6012 return TypeConstraintConcept !=
nullptr;
6027 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context);
6028 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
6040 public llvm::FoldingSetNode {
6048 bool IsDeducedAsDependent)
6049 :
DeducedType(DeducedTemplateSpecialization, DeducedAsType,
6051 (IsDeducedAsDependent
6054 DeducedAsType.isNull() ?
QualType(this, 0)
6055 : DeducedAsType.getCanonicalType()),
6056 Template(Template) {}
6063 Profile(
ID, getTemplateName(), getDeducedType(), isDependentType());
6067 QualType Deduced,
bool IsDependent) {
6135 static bool anyInstantiationDependentTemplateArguments(
6141 return isa<InjectedClassNameType>(getCanonicalTypeInternal());
6159 bool isTypeAlias()
const {
return TemplateSpecializationTypeBits.TypeAlias; }
6170 TemplateSpecializationTypeBits.NumArgs};
6174 return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
6178 return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
6181 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx);
6194 ArrayRef<TemplateArgument> Args,
6195 const PrintingPolicy &Policy,
6196 const TemplateParameterList *TPL =
nullptr);
6199 ArrayRef<TemplateArgumentLoc> Args,
6200 const PrintingPolicy &Policy,
6201 const TemplateParameterList *TPL =
nullptr);
6204 const TemplateArgumentListInfo &Args,
6205 const PrintingPolicy &Policy,
6206 const TemplateParameterList *TPL =
nullptr);
6211 const NamedDecl *Param,
6212 ArrayRef<TemplateArgument> Args,
6256 Decl(D), InjectedType(TST) {
6257 assert(isa<TemplateSpecializationType>(TST));
6266 return cast<TemplateSpecializationType>(InjectedType.
getTypePtr());
6270 return getInjectedTST()->getTemplateName();
6336 TypeWithKeywordBits.Keyword = llvm::to_underlying(Keyword);
6349 static TagTypeKind getTagTypeKindForTypeSpec(
unsigned TypeSpec);
6364 return getKeywordName(getKeywordForTagTypeKind(
Kind));
6381 public llvm::FoldingSetNode,
6382 private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
6384 friend TrailingObjects;
6403 NamedType->getDependence() |
6407 NNS(NNS), NamedType(NamedType) {
6408 ElaboratedTypeBits.HasOwnedTagDecl =
false;
6410 ElaboratedTypeBits.HasOwnedTagDecl =
true;
6411 *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
6431 return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
6436 Profile(
ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
6442 ID.AddInteger(llvm::to_underlying(Keyword));
6445 ID.AddPointer(OwnedTagDecl);
6477 NNS(NNS), Name(Name) {}
6496 Profile(
ID, getKeyword(), NNS, Name);
6501 ID.AddInteger(llvm::to_underlying(Keyword));
6503 ID.AddPointer(Name);
6515 public llvm::FoldingSetNode {
6536 DependentTemplateSpecializationTypeBits.NumArgs};
6543 Profile(
ID, Context, getKeyword(), NNS, Name, template_arguments());
6546 static void Profile(llvm::FoldingSetNodeID &
ID,
6554 return T->
getTypeClass() == DependentTemplateSpecialization;
6587 std::optional<unsigned> NumExpansions)
6588 :
Type(PackExpansion, Canon,
6593 PackExpansionTypeBits.NumExpansions =
6594 NumExpansions ? *NumExpansions + 1 : 0;
6606 if (PackExpansionTypeBits.NumExpansions)
6607 return PackExpansionTypeBits.NumExpansions - 1;
6608 return std::nullopt;
6615 Profile(
ID, getPattern(), getNumExpansions());
6619 std::optional<unsigned> NumExpansions) {
6621 ID.AddBoolean(NumExpansions.has_value());
6623 ID.AddInteger(*NumExpansions);
6643 return static_cast<T*
>(
this)->getProtocolStorageImpl();
6647 static_cast<T*
>(
this)->setNumProtocolsImpl(N);
6651 setNumProtocols(protocols.size());
6652 assert(getNumProtocols() == protocols.size() &&
6653 "bitfield overflow in protocol count");
6654 if (!protocols.empty())
6655 memcpy(getProtocolStorage(), protocols.data(),
6672 return static_cast<const T*
>(
this)->getNumProtocolsImpl();
6677 assert(I < getNumProtocols() &&
"Out-of-range protocol access");
6678 return qual_begin()[I];
6691 public llvm::FoldingSetNode {
6696 unsigned NumProtocols : 6;
6707 unsigned getNumProtocolsImpl()
const {
6708 return NumProtocols;
6711 void setNumProtocolsImpl(
unsigned N) {
6715 ObjCTypeParamType(
const ObjCTypeParamDecl *D,
6717 ArrayRef<ObjCProtocolDecl *> protocols);
6727 void Profile(llvm::FoldingSetNodeID &
ID);
6728 static void Profile(llvm::FoldingSetNodeID &
ID,
6784 mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
6785 CachedSuperClassType;
6788 const QualType *getTypeArgStorage()
const {
6795 unsigned getNumProtocolsImpl()
const {
6796 return ObjCObjectTypeBits.NumProtocols;
6798 void setNumProtocolsImpl(
unsigned N) {
6799 ObjCObjectTypeBits.NumProtocols = N;
6813 ObjCObjectTypeBits.NumProtocols = 0;
6814 ObjCObjectTypeBits.NumTypeArgs = 0;
6815 ObjCObjectTypeBits.IsKindOf = 0;
6818 void computeSuperClassTypeSlow()
const;
6830 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
6834 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
6840 if (!qual_empty())
return false;
6841 if (
const BuiltinType *
T = getBaseType()->getAs<BuiltinType>())
6842 return T->getKind() == BuiltinType::ObjCId ||
6843 T->getKind() == BuiltinType::ObjCClass;
6855 bool isSpecialized()
const;
6859 return ObjCObjectTypeBits.NumTypeArgs > 0;
6876 return llvm::ArrayRef(getTypeArgStorage(), ObjCObjectTypeBits.NumTypeArgs);
6883 bool isKindOfType()
const;
6892 if (!CachedSuperClassType.getInt())
6893 computeSuperClassTypeSlow();
6895 assert(CachedSuperClassType.getInt() &&
"Superclass not set?");
6896 return QualType(CachedSuperClassType.getPointer(), 0);
6929 void Profile(llvm::FoldingSetNodeID &
ID);
6930 static void Profile(llvm::FoldingSetNodeID &
ID,
6937 inline QualType *ObjCObjectType::getTypeArgStorage() {
6938 return reinterpret_cast<QualType *
>(
static_cast<ObjCObjectTypeImpl*
>(
this)+1);
6941 inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
6942 return reinterpret_cast<ObjCProtocolDecl**
>(
6943 getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
6946 inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
6947 return reinterpret_cast<ObjCProtocolDecl**
>(
6948 static_cast<ObjCTypeParamType*
>(
this)+1);
7001 if (
const auto *
T = dyn_cast<ObjCInterfaceType>(ObjT))
7002 return T->getDecl();
7004 baseType = ObjT->getBaseType();
7025 :
Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
7026 PointeeType(Pointee) {}
7169 QualType getSuperClassType()
const;
7177 Profile(
ID, getPointeeType());
7181 ID.AddPointer(
T.getAsOpaquePtr());
7195 :
Type(
Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}
7206 Profile(
ID, getValueType());
7210 ID.AddPointer(
T.getAsOpaquePtr());
7226 :
Type(
Pipe, CanonicalPtr, elemType->getDependence()),
7237 Profile(
ID, getElementType(), isReadOnly());
7241 ID.AddPointer(
T.getAsOpaquePtr());
7255 LLVM_PREFERRED_TYPE(
bool)
7256 unsigned IsUnsigned : 1;
7257 unsigned NumBits : 24;
7274 static void Profile(llvm::FoldingSetNodeID &
ID,
bool IsUnsigned,
7276 ID.AddBoolean(IsUnsigned);
7277 ID.AddInteger(NumBits);
7285 llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;
7293 Expr *getNumBitsExpr()
const;
7301 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
7302 bool IsUnsigned,
Expr *NumBitsExpr);
7318 addFastQualifiers(
type.getLocalFastQualifiers());
7319 if (!
type.hasLocalNonFastQualifiers())
7320 return type.getTypePtrUnsafe();
7365 Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
7371 return getCommonPtr()->BaseType;
7375 return (isNull() ?
nullptr : getCommonPtr()->BaseType);
7382 const Type &Self = **
this;
7383 if (Self.isObjectType() || Self.isReferenceType())
7386 return F->getMethodQuals().empty() && F->getRefQualifier() ==
RQ_None;
7392 if (!hasLocalNonFastQualifiers())
7396 const ExtQuals *eq = getExtQualsUnsafe();
7404 if (hasLocalNonFastQualifiers())
7405 Quals = getExtQualsUnsafe()->getQualifiers();
7411 Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
7417 unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
7418 cvr |= getLocalCVRQualifiers();
7423 QualType canon = getCommonPtr()->CanonicalType;
7428 return getTypePtr()->isCanonicalUnqualified();
7432 if (!isCanonical())
return false;
7433 if (hasLocalQualifiers())
return false;
7435 const Type *
T = getTypePtr();
7439 return !isa<FunctionType>(
T) &&
7440 (!isa<ArrayType>(
T) || isa<ArrayParameterType>(
T));
7444 return isLocalConstQualified() ||
7445 getCommonPtr()->CanonicalType.isLocalConstQualified();
7449 return isLocalRestrictQualified() ||
7450 getCommonPtr()->CanonicalType.isLocalRestrictQualified();
7455 return isLocalVolatileQualified() ||
7456 getCommonPtr()->CanonicalType.isLocalVolatileQualified();
7460 return hasLocalQualifiers() ||
7461 getCommonPtr()->CanonicalType.hasLocalQualifiers();
7465 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
7468 return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
7472 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
7475 return getSplitUnqualifiedTypeImpl(*
this);
7492 return getQualifiers().hasAddressSpace();
7497 return getQualifiers().getAddressSpace();
7502 return getQualifiers().getObjCGCAttr();
7506 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
7507 return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
7512 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
7513 return hasNonTrivialToPrimitiveDestructCUnion(RD);
7518 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
7519 return hasNonTrivialToPrimitiveCopyCUnion(RD);
7525 if (
const auto *FT = PT->getPointeeType()->getAs<
FunctionType>())
7526 return FT->getExtInfo();
7528 return FT->getExtInfo();
7556 if (getUnqualifiedType()->isVoidType())
7559 return getQualifiers().compatiblyIncludes(OtherQuals);
7579 return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
7580 getTypePtr()->isFunctionType());
7587 return isVoidType() ||
7591 (isArithmeticType() && !isEnumeralType());
7601 return isArrayType() ||
7607 isReferenceType() ||
7616 isMemberPointerType();
7620 return isa<FunctionType>(CanonicalType);
7624 return isa<PointerType>(CanonicalType);
7628 return isPointerType() || isObjCObjectPointerType();
7632 return isa<BlockPointerType>(CanonicalType);
7636 return isa<ReferenceType>(CanonicalType);
7640 return isa<LValueReferenceType>(CanonicalType);
7644 return isa<RValueReferenceType>(CanonicalType);
7651 if (
const auto *
T = getAs<PointerType>())
7658 if (
const auto *
T = getAs<PointerType>())
7665 if (
const auto *
T = getAs<ReferenceType>())
7672 return isa<MemberPointerType>(CanonicalType);
7676 if (
const auto *
T = getAs<MemberPointerType>())
7677 return T->isMemberFunctionPointer();
7683 if (
const auto *
T = getAs<MemberPointerType>())
7684 return T->isMemberDataPointer();
7690 return isa<ArrayType>(CanonicalType);
7694 return isa<ConstantArrayType>(CanonicalType);
7698 return isa<IncompleteArrayType>(CanonicalType);
7702 return isa<VariableArrayType>(CanonicalType);
7706 return isa<ArrayParameterType>(CanonicalType);
7710 return isa<DependentSizedArrayType>(CanonicalType);
7714 return isa<BuiltinType>(CanonicalType);
7718 return isa<RecordType>(CanonicalType);
7722 return isa<EnumType>(CanonicalType);
7726 return isa<ComplexType>(CanonicalType);
7730 return isa<VectorType>(CanonicalType);
7734 return isa<ExtVectorType>(CanonicalType);
7738 if (!isExtVectorType())
7740 return cast<ExtVectorType>(CanonicalType)->getElementType()->isBooleanType();
7744 return isVectorType() || isSveVLSBuiltinType();
7748 return isa<MatrixType>(CanonicalType);
7752 return isa<ConstantMatrixType>(CanonicalType);
7756 return isa<DependentAddressSpaceType>(CanonicalType);
7760 return isa<ObjCObjectPointerType>(CanonicalType);
7764 return isa<ObjCObjectType>(CanonicalType);
7768 return isa<ObjCInterfaceType>(CanonicalType) ||
7769 isa<ObjCObjectType>(CanonicalType);
7773 return isa<AtomicType>(CanonicalType);
7777 return isa<AutoType>(CanonicalType);
7781 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
7782 return OPT->isObjCQualifiedIdType();
7787 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
7788 return OPT->isObjCQualifiedClassType();
7793 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
7794 return OPT->isObjCIdType();
7799 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
7800 return OPT->isObjCClassType();
7805 if (
const auto *OPT = getAs<PointerType>())
7806 return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
7811 return isObjCIdType() || isObjCClassType() || isObjCSelType();
7815 return isa<DecltypeType>(
this);
7818 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7819 inline bool Type::is##Id##Type() const { \
7820 return isSpecificBuiltinType(BuiltinType::Id); \
7822 #include "clang/Basic/OpenCLImageTypes.def"
7824 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7825 inline bool Type::isSampled##Id##Type() const { \
7826 return isSpecificBuiltinType(BuiltinType::Sampled##Id); \
7828 #define IMAGE_WRITE_TYPE(Type, Id, Ext)
7829 #define IMAGE_READ_WRITE_TYPE(Type, Id, Ext)
7830 #include "clang/Basic/OpenCLImageTypes.def"
7833 return isSpecificBuiltinType(BuiltinType::OCLSampler);
7837 return isSpecificBuiltinType(BuiltinType::OCLEvent);
7841 return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
7845 return isSpecificBuiltinType(BuiltinType::OCLQueue);
7849 return isSpecificBuiltinType(BuiltinType::OCLReserveID);
7853 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
7854 return isSampledImageType() ||
7855 #include "clang/Basic/OpenCLImageTypes.def"
7860 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7861 isSampled##Id##Type() ||
7863 #define IMAGE_WRITE_TYPE(Type, Id, Ext)
7864 #define IMAGE_READ_WRITE_TYPE(Type, Id, Ext)
7865 #include "clang/Basic/OpenCLImageTypes.def"
7870 return isa<PipeType>(CanonicalType);
7874 return isa<BitIntType>(CanonicalType);
7877 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7878 inline bool Type::is##Id##Type() const { \
7879 return isSpecificBuiltinType(BuiltinType::Id); \
7881 #include "clang/Basic/OpenCLExtensionTypes.def"
7884 #define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
7885 isOCLIntelSubgroupAVC##Id##Type() ||
7887 #include "clang/Basic/OpenCLExtensionTypes.def"
7892 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
7894 #include "clang/Basic/OpenCLExtensionTypes.def"
7899 return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
7900 isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
7904 return isa<TemplateTypeParmType>(CanonicalType);
7908 if (
const BuiltinType *BT = getAs<BuiltinType>()) {
7915 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
7916 return BT->isPlaceholderType();
7921 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
7922 if (BT->isPlaceholderType())
7929 return isSpecificBuiltinType(K);
7933 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
7934 return BT->isNonOverloadPlaceholderType();
7939 return isSpecificBuiltinType(BuiltinType::Void);
7944 return isSpecificBuiltinType(BuiltinType::Half);
7948 return isSpecificBuiltinType(BuiltinType::Float16);
7956 return isSpecificBuiltinType(BuiltinType::Double);
7960 return isSpecificBuiltinType(BuiltinType::BFloat16);
7964 return isSpecificBuiltinType(BuiltinType::Float128);
7968 return isSpecificBuiltinType(BuiltinType::Ibm128);
7972 return isSpecificBuiltinType(BuiltinType::NullPtr);
7979 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
7980 return BT->getKind() >= BuiltinType::Bool &&
7981 BT->getKind() <= BuiltinType::Int128;
7982 if (
const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
7988 return isBitIntType();
7992 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7993 return BT->getKind() >= BuiltinType::ShortAccum &&
7994 BT->getKind() <= BuiltinType::SatULongFract;
8000 return isFixedPointType() || isIntegerType();
8004 return isRealFloatingType() || isFixedPointOrIntegerType();
8008 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8009 return BT->getKind() >= BuiltinType::SatShortAccum &&
8010 BT->getKind() <= BuiltinType::SatULongFract;
8016 return isFixedPointType() && !isSaturatedFixedPointType();
8020 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8021 return ((BT->getKind() >= BuiltinType::ShortAccum &&
8022 BT->getKind() <= BuiltinType::LongAccum) ||
8023 (BT->getKind() >= BuiltinType::ShortFract &&
8024 BT->getKind() <= BuiltinType::LongFract) ||
8025 (BT->getKind() >= BuiltinType::SatShortAccum &&
8026 BT->getKind() <= BuiltinType::SatLongAccum) ||
8027 (BT->getKind() >= BuiltinType::SatShortFract &&
8028 BT->getKind() <= BuiltinType::SatLongFract));
8034 return isFixedPointType() && !isSignedFixedPointType();
8038 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8039 return BT->getKind() > BuiltinType::Void &&
8040 BT->getKind() <= BuiltinType::NullPtr;
8041 if (
const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
8045 return isa<PointerType>(CanonicalType) ||
8046 isa<BlockPointerType>(CanonicalType) ||
8047 isa<MemberPointerType>(CanonicalType) ||
8048 isa<ComplexType>(CanonicalType) ||
8049 isa<ObjCObjectPointerType>(CanonicalType) ||
8054 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8055 return BT->getKind() >= BuiltinType::Bool &&
8056 BT->getKind() <= BuiltinType::Int128;
8060 if (
const auto *ET = dyn_cast<EnumType>(CanonicalType))
8063 return isBitIntType();
8067 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8068 return BT->getKind() == BuiltinType::Bool;
8073 auto *DT = getContainedDeducedType();
8074 return DT && !DT->isDeduced();
8080 if (!CanonicalType->isDependentType())
8082 return !isArrayType() && !isFunctionType() && !isAnyPointerType() &&
8083 !isMemberPointerType();
8088 if (getAs<TypedefType>())
8090 if (
auto *TST = getAs<TemplateSpecializationType>())
8091 return TST->isTypeAlias();
8097 return isFunctionType() || (isArrayType() && !isArrayParameterType());
8101 return (isPointerType() || isReferenceType() || isBlockPointerType() ||
8102 isObjCObjectPointerType() || isNullPtrType());
8106 return isObjCObjectPointerType();
8118 if (
type->isAnyPointerType())
8119 return type->getPointeeType().getTypePtr();
8120 else if (
type->isArrayType())
8121 return type->getBaseElementTypeUnsafe();
8129 DiagnosticsEngine::ArgumentKind::ak_addrspace);
8138 DiagnosticsEngine::ArgumentKind::ak_qual);
8153 template <
typename T>
8155 std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
8156 std::is_base_of<ArrayType, T>::value>;
8161 "ArrayType cannot be used with getAs!");
8164 if (
const auto *Ty = dyn_cast<T>(
this))
8168 if (!isa<T>(CanonicalType))
8173 return cast<T>(getUnqualifiedDesugaredType());
8180 if (
const auto *Ty = dyn_cast<T>(
this))
8184 if (!isa<T>(CanonicalType))
8189 const Type *Ty =
this;
8191 if (
const auto *A = dyn_cast<AttributedType>(Ty))
8192 Ty = A->getModifiedType().getTypePtr();
8193 else if (
const auto *A = dyn_cast<BTFTagAttributedType>(Ty))
8194 Ty = A->getWrappedType().getTypePtr();
8195 else if (
const auto *E = dyn_cast<ElaboratedType>(Ty))
8196 Ty = E->desugar().getTypePtr();
8197 else if (
const auto *
P = dyn_cast<ParenType>(Ty))
8198 Ty =
P->desugar().getTypePtr();
8199 else if (
const auto *A = dyn_cast<AdjustedType>(Ty))
8200 Ty = A->desugar().getTypePtr();
8201 else if (
const auto *M = dyn_cast<MacroQualifiedType>(Ty))
8202 Ty = M->desugar().getTypePtr();
8209 return dyn_cast<T>(Ty);
8214 if (
const auto *arr = dyn_cast<ArrayType>(
this))
8218 if (!isa<ArrayType>(CanonicalType))
8223 return cast<ArrayType>(getUnqualifiedDesugaredType());
8228 "ArrayType cannot be used with castAs!");
8230 if (
const auto *ty = dyn_cast<T>(
this))
return ty;
8231 assert(isa<T>(CanonicalType));
8232 return cast<T>(getUnqualifiedDesugaredType());
8236 assert(isa<ArrayType>(CanonicalType));
8237 if (
const auto *arr = dyn_cast<ArrayType>(
this))
return arr;
8238 return cast<ArrayType>(getUnqualifiedDesugaredType());
8243 :
AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
8245 QualType Adjusted = getAdjustedType();
8247 assert(isa<PointerType>(Adjusted));
8254 return cast<PointerType>(Decayed)->getPointeeType();
Provides definitions for the various language-specific address spaces.
static bool isUnsigned(SValBuilder &SVB, NonLoc Value)
Defines the clang::attr::Kind enum.
Defines the Diagnostic-related interfaces.
static bool isBooleanType(QualType Ty)
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
static Decl::Kind getKind(const Decl *D)
Defines the ExceptionSpecificationType enumeration and various utility functions.
static bool isRead(AccessKinds AK)
static QualType getObjectType(APValue::LValueBase B)
Retrieves the "underlying object type" of the given expression, as used by __builtin_object_size.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
static StringRef getIdentifier(const Token &Tok)
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
static QualType getUnderlyingType(const SubRegion *R)
static std::string getName(const CallEvent &Call)
static bool hasAttr(const Decl *D, bool IgnoreImplicitAttr)
static RecordDecl * getAsRecordDecl(QualType BaseType)
static bool isRecordType(QualType T)
static bool isParameterPack(Expr *PackExpression)
Defines the clang::SourceLocation class and associated facilities.
Defines various enumerations that describe declaration and type specifiers.
static const TemplateTypeParmDecl * getReplacedParameter(Decl *D, unsigned Index)
Defines the clang::Visibility enumeration and various utility functions.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
__device__ __2f16 float __ockl_bool s
__device__ __2f16 float c
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Reads an AST files chain containing the contents of a translation unit.
Writes an AST file containing the contents of a translation unit.
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
static bool classof(const Type *T)
static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New)
AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy, QualType CanonicalPtr)
QualType getAdjustedType() const
void Profile(llvm::FoldingSetNodeID &ID)
QualType getOriginalType() const
Represents a constant array type that does not decay to a pointer when used as a function parameter.
static bool classof(const Type *T)
Represents an array type, per C99 6.7.5.2 - Array Declarators.
ArraySizeModifier getSizeModifier() const
Qualifiers getIndexTypeQualifiers() const
static bool classof(const Type *T)
QualType getElementType() const
unsigned getIndexTypeCVRQualifiers() const
static void Profile(llvm::FoldingSetNodeID &ID, QualType T)
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
void Profile(llvm::FoldingSetNodeID &ID)
static bool classof(const Type *T)
An attributed type is a type to which a type attribute has been applied.
QualType getModifiedType() const
static bool classof(const Type *T)
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
static std::optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind, QualType modified, QualType equivalent)
QualType getEquivalentType() const
void Profile(llvm::FoldingSetNodeID &ID)
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
static bool classof(const Type *T)
bool isDecltypeAuto() const
ArrayRef< TemplateArgument > getTypeConstraintArguments() const
AutoTypeKeyword getKeyword() const
bool isGNUAutoType() const
ConceptDecl * getTypeConstraintConcept() const
bool isConstrained() const
static bool classof(const Type *T)
QualType getWrappedType() const
void Profile(llvm::FoldingSetNodeID &ID)
const BTFTypeTagAttr * getAttr() const
static void Profile(llvm::FoldingSetNodeID &ID, QualType Wrapped, const BTFTypeTagAttr *BTFAttr)
A fixed int type of a specified bitwidth.
static bool classof(const Type *T)
static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned, unsigned NumBits)
void Profile(llvm::FoldingSetNodeID &ID) const
unsigned getNumBits() const
void Profile(llvm::FoldingSetNodeID &ID)
QualType getPointeeType() const
static bool classof(const Type *T)
static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee)
[BoundsSafety] Represents a parent type class for CountAttributedType and similar sugar types that wi...
decl_iterator dependent_decl_begin() const
decl_iterator dependent_decl_end() const
unsigned getNumCoupledDecls() const
decl_range dependent_decls() const
ArrayRef< TypeCoupledDeclRefInfo > getCoupledDecls() const
llvm::iterator_range< decl_iterator > decl_range
static bool classof(const Type *T)
ArrayRef< TypeCoupledDeclRefInfo > Decls
This class is used for builtin types like 'int'.
bool isPlaceholderType() const
Determines whether this type is a placeholder type, i.e.
bool isNonOverloadPlaceholderType() const
Determines whether this type is a placeholder type other than Overload.
const char * getNameAsCString(const PrintingPolicy &Policy) const
bool isFloatingPoint() const
static bool classof(const Type *T)
bool isSignedInteger() const
bool isUnsignedInteger() const
static bool isPlaceholderTypeKind(Kind K)
Determines whether the given kind corresponds to a placeholder type.
Represents a C++ struct/union/class.
Complex values, per C99 6.2.5p11.
QualType getElementType() const
static void Profile(llvm::FoldingSetNodeID &ID, QualType Element)
static bool classof(const Type *T)
void Profile(llvm::FoldingSetNodeID &ID)
Declaration of a C++20 concept.
Represents the canonical version of C arrays with a specified constant size.
unsigned getSizeBitWidth() const
Return the bit width of the size type.
ConstantArrayType(TypeClass Tc, const ConstantArrayType *ATy, QualType Can)
uint64_t getLimitedSize() const
Return the size zero-extended to uint64_t or UINT64_MAX if the value is larger than UINT64_MAX.
bool isZeroSize() const
Return true if the size is zero.
int64_t getSExtSize() const
Return the size sign-extended as a uint64_t.
const Expr * getSizeExpr() const
Return a pointer to the size expression.
static bool classof(const Type *T)
llvm::APInt getSize() const
Return the constant array size as an APInt.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
Represents a concrete matrix type with constant number of rows and columns.
unsigned getNumColumns() const
Returns the number of columns in the matrix.
static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType, unsigned NumRows, unsigned NumColumns, TypeClass TypeClass)
void Profile(llvm::FoldingSetNodeID &ID)
static constexpr unsigned getMaxElementsPerDimension()
Returns the maximum number of elements per dimension.
unsigned getNumRows() const
Returns the number of rows in the matrix.
unsigned getNumElementsFlattened() const
Returns the number of elements required to embed the matrix into a vector.
static constexpr bool isDimensionValid(size_t NumElements)
Returns true if NumElements is a valid matrix dimension.
unsigned NumRows
Number of rows and columns.
static bool classof(const Type *T)
Represents a sugar type with __counted_by or __sized_by annotations, including their _or_null variant...
void Profile(llvm::FoldingSetNodeID &ID)
static bool classof(const Type *T)
Expr * getCountExpr() const
bool isCountInBytes() const
DynamicCountPointerKind getKind() const
Represents a pointer type decayed from an array or function type.
QualType getPointeeType() const
static bool classof(const Type *T)
QualType getDecayedType() const
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Decl - This represents one declaration (or definition), e.g.
Represents the type decltype(expr) (C++11).
Expr * getUnderlyingExpr() const
static bool classof(const Type *T)
QualType getUnderlyingType() const
Represents a C++17 deduced template specialization type.
TemplateName getTemplateName() const
Retrieve the name of the template that we are deducing.
static bool classof(const Type *T)
void Profile(llvm::FoldingSetNodeID &ID)
static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template, QualType Deduced, bool IsDependent)
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
static bool classof(const Type *T)
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it has not been deduced.
DeducedType(TypeClass TC, QualType DeducedAsType, TypeDependence ExtraDependence, QualType Canon)
Represents an extended address space qualifier where the input address space value is dependent.
Expr * getAddrSpaceExpr() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
QualType getPointeeType() const
static bool classof(const Type *T)
SourceLocation getAttributeLoc() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
static bool classof(const Type *T)
Internal representation of canonical, dependent decltype(expr) types.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Represents a qualified type name for which the type name is dependent.
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
static bool classof(const Type *T)
void Profile(llvm::FoldingSetNodeID &ID)
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name)
Represents an array type in C++ whose size is a value-dependent expression.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
static bool classof(const Type *T)
SourceRange getBracketsRange() const
SourceLocation getLBracketLoc() const
Expr * getSizeExpr() const
SourceLocation getRBracketLoc() const
Represents an extended vector type where either the type or size is dependent.
Expr * getSizeExpr() const
static bool classof(const Type *T)
SourceLocation getAttributeLoc() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
QualType getElementType() const
Represents a matrix type where the type and the number of rows and columns is dependent on a template...
Expr * getRowExpr() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Expr * getColumnExpr() const
SourceLocation getAttributeLoc() const
static bool classof(const Type *T)
Represents a template specialization type whose template cannot be resolved, e.g.
NestedNameSpecifier * getQualifier() const
const IdentifierInfo * getIdentifier() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
ArrayRef< TemplateArgument > template_arguments() const
static bool classof(const Type *T)
Internal representation of canonical, dependent typeof(expr) types.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
DependentTypeOfExprType(Expr *E, TypeOfKind Kind)
Represents a vector type where either the type or size is dependent.
Expr * getSizeExpr() const
VectorKind getVectorKind() const
SourceLocation getAttributeLoc() const
QualType getElementType() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
static bool classof(const Type *T)
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
static bool classof(const Type *T)
QualType desugar() const
Remove a single level of sugar.
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl)
bool isSugared() const
Returns whether this type directly provides sugar.
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
void Profile(llvm::FoldingSetNodeID &ID)
TagDecl * getOwnedTagDecl() const
Return the (re)declaration of this type owned by this occurrence of this type, or nullptr if there is...
QualType getNamedType() const
Retrieve the type named by the qualified-id.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
static bool classof(const Type *T)
EnumDecl * getDecl() const
This represents one expression.
Base class that is common to both the ExtQuals and Type classes, which allows QualType to access the ...
We can encode up to four bits in the low bits of a type pointer, but there are many more type qualifi...
Qualifiers::ObjCLifetime getObjCLifetime() const
const Type * getBaseType() const
static void Profile(llvm::FoldingSetNodeID &ID, const Type *BaseType, Qualifiers Quals)
void Profile(llvm::FoldingSetNodeID &ID) const
ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
bool hasObjCGCAttr() const
Qualifiers::GC getObjCGCAttr() const
bool hasAddressSpace() const
Qualifiers getQualifiers() const
LangAS getAddressSpace() const
bool hasObjCLifetime() const
ExtVectorType - Extended vector type.
bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const
static int getNumericAccessorIdx(char c)
static bool classof(const Type *T)
static int getPointAccessorIdx(char c)
static int getAccessorIdx(char c, bool isNumericAccessor)
Represents a function declaration or definition.
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType, ExtInfo Info)
static bool classof(const Type *T)
void Profile(llvm::FoldingSetNodeID &ID)
Represents a prototype with parameter type info, e.g.
param_type_iterator param_type_begin() const
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
const ExtParameterInfo * getExtParameterInfosOrNull() const
Return a pointer to the beginning of the array of extra parameter information, if present,...
ArrayRef< QualType > getParamTypes() const
ExtParameterInfo getExtParameterInfo(unsigned I) const
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
FunctionDecl * getExceptionSpecTemplate() const
If this function type has an uninstantiated exception specification, this is the function whose excep...
bool isParamConsumed(unsigned I) const
exception_iterator exception_end() const
ArrayRef< QualType > param_types() const
unsigned getNumParams() const
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
ExceptionSpecInfo getExceptionSpecInfo() const
Return all the available information about this type's exception spec.
Qualifiers getMethodQuals() const
ArrayRef< QualType > exceptions() const
static bool classof(const Type *T)
QualType getParamType(unsigned i) const
unsigned getAArch64SMEAttributes() const
Return a bitmask describing the SME attributes on the function type, see AArch64SMETypeAttributes for...
QualType getExceptionType(unsigned i) const
Return the ith exception type, where 0 <= i < getNumExceptions().
static void Profile(llvm::FoldingSetNodeID &ID, QualType Result, param_type_iterator ArgTys, unsigned NumArgs, const ExtProtoInfo &EPI, const ASTContext &Context, bool Canonical)
SourceLocation getEllipsisLoc() const
unsigned getNumExceptions() const
Return the number of types in the exception specification.
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
FunctionDecl * getExceptionSpecDecl() const
If this function type has an exception specification which hasn't been determined yet (either because...
bool hasDynamicExceptionSpec() const
Return whether this function has a dynamic (throw) exception spec.
bool hasNoexceptExceptionSpec() const
Return whether this function has a noexcept exception spec.
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
param_type_iterator param_type_end() const
ArrayRef< ExtParameterInfo > getExtParameterInfos() const
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
ParameterABI getParameterABI(unsigned I) const
exception_iterator exception_begin() const
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type?
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
A class which abstracts out some details necessary for making a call.
ExtInfo withNoCfCheck(bool noCfCheck) const
ExtInfo withCallingConv(CallingConv cc) const
CallingConv getCC() const
ExtInfo withProducesResult(bool producesResult) const
ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc, bool producesResult, bool noCallerSavedRegs, bool NoCfCheck, bool cmseNSCall)
bool getCmseNSCall() const
bool getNoCfCheck() const
unsigned getRegParm() const
void Profile(llvm::FoldingSetNodeID &ID) const
bool getNoCallerSavedRegs() const
ExtInfo withNoReturn(bool noReturn) const
bool getHasRegParm() const
bool operator==(ExtInfo Other) const
bool getProducesResult() const
ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const
ExtInfo withCmseNSCall(bool cmseNSCall) const
ExtInfo withRegParm(unsigned RegParm) const
bool operator!=(ExtInfo Other) const
Interesting information about a specific parameter that can't simply be reflected in parameter's type...
friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs)
friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs)
ExtParameterInfo()=default
bool hasPassObjectSize() const
ExtParameterInfo withHasPassObjectSize() const
unsigned char getOpaqueValue() const
bool isConsumed() const
Is this parameter considered "consumed" by Objective-C ARC? Consumed parameters must have retainable ...
ParameterABI getABI() const
Return the ABI treatment of this parameter.
ExtParameterInfo withIsConsumed(bool consumed) const
ExtParameterInfo withIsNoEscape(bool NoEscape) const
ExtParameterInfo withABI(ParameterABI kind) const
static ExtParameterInfo getFromOpaqueValue(unsigned char data)
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
static ArmStateValue getArmZT0State(unsigned AttrBits)
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
static ArmStateValue getArmZAState(unsigned AttrBits)
unsigned getRegParmType() const
CallingConv getCallConv() const
QualType getReturnType() const
FunctionType(TypeClass tc, QualType res, QualType Canonical, TypeDependence Dependence, ExtInfo Info)
static bool classof(const Type *T)
bool getCmseNSCallAttr() const
bool getHasRegParm() const
Qualifiers getFastTypeQuals() const
QualType getCallResultType(const ASTContext &Context) const
Determine the type of an expression that calls a function of this type.
AArch64SMETypeAttributes
The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number of function type attributes that...
One of these records is kept for each identifier that is lexed.
Represents a C array with an unspecified size.
void Profile(llvm::FoldingSetNodeID &ID)
static void Profile(llvm::FoldingSetNodeID &ID, QualType ET, ArraySizeModifier SizeMod, unsigned TypeQuals)
static bool classof(const Type *T)
The injected class name of a C++ class template or class template partial specialization.
static bool classof(const Type *T)
TemplateName getTemplateName() const
QualType getInjectedSpecializationType() const
const TemplateSpecializationType * getInjectedTST() const
An lvalue reference type, per C++11 [dcl.ref].
static bool classof(const Type *T)
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.
static bool classof(const Type *T)
QualType getUnderlyingType() const
const IdentifierInfo * getMacroIdentifier() const
Represents a matrix type, as defined in the Matrix Types clang extensions.
QualType getElementType() const
Returns type of the elements being stored in the matrix.
MatrixType(QualType ElementTy, QualType CanonElementTy)
static bool isValidElementType(QualType T)
Valid elements types are the following:
QualType ElementType
The element type of the matrix.
static bool classof(const Type *T)
A pointer to member type per C++ 8.3.3 - Pointers to members.
const Type * getClass() const
void Profile(llvm::FoldingSetNodeID &ID)
QualType getPointeeType() const
bool isMemberFunctionPointer() const
Returns true if the member type (i.e.
bool isMemberDataPointer() const
Returns true if the member type (i.e.
static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee, const Type *Class)
static bool classof(const Type *T)
This represents a decl that may have a name.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Represents an ObjC class declaration.
Interfaces are the core concept in Objective-C for object oriented design.
static bool classof(const Type *T)
Represents a pointer to an Objective C object.
unsigned getNumProtocols() const
Return the number of qualifying protocols on the object type.
bool isSpecialized() const
Whether this type is specialized, meaning that it has type arguments.
qual_iterator qual_end() const
bool isObjCQualifiedClassType() const
True if this is equivalent to 'Class.
static void Profile(llvm::FoldingSetNodeID &ID, QualType T)
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments for this type.
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
bool isSpecializedAsWritten() const
Whether this type is specialized, meaning that it has type arguments.
bool isUnspecializedAsWritten() const
Determine whether this object type is "unspecialized" as written, meaning that it has no type argumen...
void Profile(llvm::FoldingSetNodeID &ID)
ObjCProtocolDecl * getProtocol(unsigned I) const
Retrieve a qualifying protocol by index on the object type.
ObjCObjectType::qual_iterator qual_iterator
An iterator over the qualifiers on the object type.
llvm::iterator_range< qual_iterator > qual_range
static bool classof(const Type *T)
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments for this type.
bool isUnspecialized() const
Whether this type is unspecialized, meaning that is has no type arguments.
bool isObjCIdType() const
True if this is equivalent to the 'id' type, i.e.
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
bool isObjCClassType() const
True if this is equivalent to the 'Class' type, i.e.
bool isObjCIdOrClassType() const
True if this is equivalent to the 'id' or 'Class' type,.
qual_iterator qual_begin() const
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
bool isKindOfType() const
Whether this is a "__kindof" type.
A class providing a concrete implementation of ObjCObjectType, so as to not increase the footprint of...
Represents a class type in Objective C.
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were written.
bool isKindOfTypeAsWritten() const
Whether this is a "__kindof" type as written.
bool isUnspecializedAsWritten() const
Determine whether this object type is "unspecialized" as written, meaning that it has no type argumen...
bool isObjCQualifiedClass() const
ObjCObjectType(enum Nonce_ObjCInterface)
bool isObjCUnqualifiedIdOrClass() const
QualType getBaseType() const
Gets the base type of this object type.
bool isObjCQualifiedId() const
bool isSpecializedAsWritten() const
Determine whether this object type was written with type arguments.
bool isObjCUnqualifiedId() const
bool isUnspecialized() const
Determine whether this object type is "unspecialized", meaning that it has no type arguments.
bool isObjCUnqualifiedClass() const
static bool classof(const Type *T)
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface.
QualType getSuperClassType() const
Retrieve the type of the superclass of this object type.
Represents an Objective-C protocol declaration.
This class wraps the list of protocol qualifiers.
llvm::iterator_range< qual_iterator > qual_range
ArrayRef< ObjCProtocolDecl * > getProtocols() const
Retrieve all of the protocol qualifiers.
ObjCProtocolDecl *const * getProtocolStorage() const
void initialize(ArrayRef< ObjCProtocolDecl * > protocols)
unsigned getNumProtocols() const
Return the number of qualifying protocols in this type, or 0 if there are none.
ObjCProtocolDecl * getProtocol(unsigned I) const
Fetch a protocol by index.
ObjCProtocolDecl ** getProtocolStorage()
void setNumProtocols(unsigned N)
qual_iterator qual_end() const
qual_iterator qual_begin() const
ObjCProtocolQualifiers()=default
ObjCProtocolDecl *const * qual_iterator
Represents the declaration of an Objective-C type parameter.
Represents a type parameter type in Objective C.
static bool classof(const Type *T)
ObjCTypeParamDecl * getDecl() const
Represents a pack expansion of types.
std::optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
void Profile(llvm::FoldingSetNodeID &ID)
static bool classof(const Type *T)
static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern, std::optional< unsigned > NumExpansions)
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
bool hasSelectedType() const
QualType getPattern() const
void Profile(llvm::FoldingSetNodeID &ID)
Expr * getIndexExpr() const
QualType getSelectedType() const
ArrayRef< QualType > getExpansions() const
static bool classof(const Type *T)
Sugar for parentheses used when specifying types.
void Profile(llvm::FoldingSetNodeID &ID)
static bool classof(const Type *T)
static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner)
QualType getInnerType() const
static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead)
QualType getElementType() const
void Profile(llvm::FoldingSetNodeID &ID)
static bool classof(const Type *T)
Pointer-authentication qualifiers.
static PointerAuthQualifier fromOpaqueValue(uint32_t Opaque)
friend bool operator==(PointerAuthQualifier Lhs, PointerAuthQualifier Rhs)
bool isIsaPointer() const
static PointerAuthQualifier Create(unsigned Key, bool IsAddressDiscriminated, unsigned ExtraDiscriminator, PointerAuthenticationMode AuthenticationMode, bool IsIsaPointer, bool AuthenticatesNullValues)
friend bool operator!=(PointerAuthQualifier Lhs, PointerAuthQualifier Rhs)
bool authenticatesNullValues() const
bool isEquivalent(PointerAuthQualifier Other) const
void Profile(llvm::FoldingSetNodeID &ID) const
@ MaxDiscriminator
The maximum supported pointer-authentication discriminator.
@ MaxKey
The maximum supported pointer-authentication key.
bool isAddressDiscriminated() const
PointerAuthQualifier withoutKeyNone() const
unsigned getExtraDiscriminator() const
PointerAuthenticationMode getAuthenticationMode() const
uint32_t getAsOpaqueValue() const
PointerAuthQualifier()=default
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
static bool classof(const Type *T)
void Profile(llvm::FoldingSetNodeID &ID)
static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee)
StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy, const Twine &PlaceHolder, unsigned Indentation)
friend raw_ostream & operator<<(raw_ostream &OS, const StreamedQualTypeHelper &SQT)
A (possibly-)qualified type.
void addRestrict()
Add the restrict qualifier to this QualType.
QualType(const ExtQuals *Ptr, unsigned Quals)
bool isLocalConstQualified() const
Determine whether this particular QualType instance has the "const" qualifier set,...
bool isLocalRestrictQualified() const
Determine whether this particular QualType instance has the "restrict" qualifier set,...
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
const Type * operator->() const
QualType IgnoreParens() const
Returns the specified type after dropping any outer-level parentheses.
Qualifiers::GC getObjCGCAttr() const
Returns gc attribute of this type.
friend bool operator==(const QualType &LHS, const QualType &RHS)
Indicate whether the specified types and qualifiers are identical.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
QualType withFastQualifiers(unsigned TQs) const
QualType withRestrict() const
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
PointerAuthQualifier getPointerAuth() const
void addFastQualifiers(unsigned TQs)
bool isWebAssemblyFuncrefType() const
Returns true if it is a WebAssembly Funcref Type.
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
@ DK_objc_strong_lifetime
PrimitiveDefaultInitializeKind
@ PDIK_ARCWeak
The type is an Objective-C retainable pointer type that is qualified with the ARC __weak qualifier.
@ PDIK_Trivial
The type does not fall into any of the following categories.
@ PDIK_ARCStrong
The type is an Objective-C retainable pointer type that is qualified with the ARC __strong qualifier.
@ PDIK_Struct
The type is a struct containing a field whose type is not PCK_Trivial.
bool mayBeDynamicClass() const
Returns true if it is a class and it might be dynamic.
bool hasLocalNonFastQualifiers() const
Determine whether this particular QualType instance has any "non-fast" qualifiers,...
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
const IdentifierInfo * getBaseTypeIdentifier() const
Retrieves a pointer to the name of the base type.
QualType withoutLocalFastQualifiers() const
void Profile(llvm::FoldingSetNodeID &ID) const
void * getAsOpaquePtr() const
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
void removeLocalFastQualifiers(unsigned Mask)
QualType withConst() const
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
void addConst()
Add the const type qualifier to this QualType.
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
bool isTriviallyCopyConstructibleType(const ASTContext &Context) const
Return true if this is a trivially copyable type.
bool isTrivialType(const ASTContext &Context) const
Return true if this is a trivial type per (C++0x [basic.types]p9)
const Type & operator*() const
bool isNull() const
Return true if this QualType doesn't point to a type yet.
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
bool isTriviallyRelocatableType(const ASTContext &Context) const
Return true if this is a trivially relocatable type.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
bool isConstant(const ASTContext &Ctx) const
static QualType getFromOpaquePtr(const void *Ptr)
QualType withVolatile() const
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
void setLocalFastQualifiers(unsigned Quals)
bool isAddressSpaceOverlapping(QualType T) const
Returns true if address space qualifiers overlap with T address space qualifiers.
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...
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType stripObjCKindOfType(const ASTContext &ctx) const
Strip Objective-C "__kindof" types from the given type.
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
bool isReferenceable() const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool isTriviallyEqualityComparableType(const ASTContext &Context) const
Return true if this is a trivially equality comparable type.
void removeLocalVolatile()
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...
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
SplitQualType getSplitDesugaredType() const
std::optional< NonConstantStorageReason > isNonConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
Determine whether instances of this type can be placed in immutable storage.
QualType withCVRQualifiers(unsigned CVR) const
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
bool UseExcessPrecision(const ASTContext &Ctx)
void addVolatile()
Add the volatile type qualifier to this QualType.
bool isCForbiddenLValueType() const
Determine whether expressions of the given type are forbidden from being lvalues in C.
PrimitiveDefaultInitializeKind isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C struct types.
bool isObjCGCStrong() const
true when Type is objc's strong.
std::string getAsString() const
static void print(SplitQualType split, raw_ostream &OS, const PrintingPolicy &policy, const Twine &PlaceHolder, unsigned Indentation=0)
bool isCanonicalAsParam() const
void removeLocalRestrict()
bool isWebAssemblyExternrefType() const
Returns true if it is a WebAssembly Externref Type.
QualType(const Type *Ptr, unsigned Quals)
QualType getNonPackExpansionType() const
Remove an outer pack expansion type (if any) from this type.
bool isMoreQualifiedThan(QualType Other) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
SplitQualType getSplitUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
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,...
bool mayBeNotDynamicClass() const
Returns true if it is not a class or if the class might not be dynamic.
bool isConstQualified() const
Determine whether this type is const-qualified.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
bool isObjCGCWeak() const
true when Type is objc's weak.
QualType substObjCTypeArgs(ASTContext &ctx, ArrayRef< QualType > typeArgs, ObjCSubstitutionContext context) const
Substitute type arguments for the Objective-C type parameters used in the subject type.
unsigned getLocalFastQualifiers() const
void removeLocalFastQualifiers()
QualType getAtomicUnqualifiedType() const
Remove all qualifiers including _Atomic.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
friend bool operator<(const QualType &LHS, const QualType &RHS)
friend bool operator!=(const QualType &LHS, const QualType &RHS)
StreamedQualTypeHelper stream(const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
bool isLocalVolatileQualified() const
Determine whether this particular QualType instance has the "volatile" qualifier set,...
bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static void getAsStringInternal(SplitQualType split, std::string &out, const PrintingPolicy &policy)
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
const Type * getTypePtrOrNull() const
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasNonTrivialObjCLifetime() const
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
bool hasStrongOrWeakObjCLifetime() const
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
QualType withExactLocalFastQualifiers(unsigned TQs) const
@ NonConstNonReferenceType
@ PCK_Struct
The type is a struct containing a field whose type is neither PCK_Trivial nor PCK_VolatileTrivial.
@ PCK_Trivial
The type does not fall into any of the following categories.
@ PCK_ARCStrong
The type is an Objective-C retainable pointer type that is qualified with the ARC __strong qualifier.
@ PCK_VolatileTrivial
The type would be trivial except that it is volatile-qualified.
@ PCK_ARCWeak
The type is an Objective-C retainable pointer type that is qualified with the ARC __weak qualifier.
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
A qualifier set is used to build a set of qualifiers.
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
QualifierCollector(Qualifiers Qs=Qualifiers())
QualifiersAndAtomic & operator+=(Qualifiers RHS)
QualifiersAndAtomic withVolatile()
QualifiersAndAtomic withAtomic()
QualifiersAndAtomic withConst()
QualifiersAndAtomic(Qualifiers Quals, bool HasAtomic)
QualifiersAndAtomic withRestrict()
The collection of all-type qualifiers we support.
unsigned getCVRQualifiers() const
void removeCVRQualifiers(unsigned mask)
friend Qualifiers operator-(Qualifiers L, Qualifiers R)
Compute the difference between two qualifier sets.
static Qualifiers fromFastMask(unsigned Mask)
void setFastQualifiers(unsigned mask)
Qualifiers & operator+=(Qualifiers R)
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R)
Returns the common set of qualifiers while removing them from the given sets.
bool hasOnlyConst() const
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
void removeObjCLifetime()
bool hasTargetSpecificAddressSpace() const
bool isStrictSupersetOf(Qualifiers Other) const
Determine whether this set of qualifiers is a strict superset of another set of qualifiers,...
bool hasNonFastQualifiers() const
Return true if the set contains any qualifiers which require an ExtQuals node to be allocated.
void Profile(llvm::FoldingSetNodeID &ID) const
bool isAddressSpaceSupersetOf(Qualifiers other) const
Returns true if the address space in these qualifiers is equal to or a superset of the address space ...
bool operator!=(Qualifiers Other) const
bool hasNonTrivialObjCLifetime() const
True if the lifetime is neither None or ExplicitNone.
void addCVRQualifiers(unsigned mask)
bool hasCVRQualifiers() const
void addConsistentQualifiers(Qualifiers qs)
Add the qualifiers from the given set to this set, given that they don't conflict.
void removeFastQualifiers(unsigned mask)
void removeFastQualifiers()
bool hasQualifiers() const
Return true if the set contains any qualifiers.
void removeCVRQualifiers()
Qualifiers withVolatile() const
void addCVRUQualifiers(unsigned mask)
bool hasUnaligned() const
unsigned getAddressSpaceAttributePrintValue() const
Get the address space attribute value to be printed by diagnostics.
bool hasAddressSpace() const
Qualifiers withoutAddressSpace() const
unsigned getFastQualifiers() const
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool appendSpaceIfNonEmpty=false) const
Qualifiers & operator-=(Qualifiers R)
void removeAddressSpace()
@ FastWidth
The width of the "fast" qualifier mask.
@ MaxAddressSpace
The maximum supported address space number.
@ FastMask
The fast qualifier mask.
void addQualifiers(Qualifiers Q)
Add the qualifiers from the given set to this set.
static Qualifiers fromCVRMask(unsigned CVR)
void setAddressSpace(LangAS space)
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B)
Returns true if address space A is equal to or a superset of B.
unsigned getCVRUQualifiers() const
bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const
PointerAuthQualifier getPointerAuth() const
void setObjCGCAttr(GC type)
Qualifiers withConst() const
bool hasObjCGCAttr() const
uint64_t getAsOpaqueValue() const
void setCVRQualifiers(unsigned mask)
bool hasObjCLifetime() const
ObjCLifetime getObjCLifetime() const
Qualifiers withoutObjCLifetime() const
Qualifiers withoutObjCGCAttr() const
static Qualifiers fromCVRUMask(unsigned CVRU)
friend Qualifiers operator+(Qualifiers L, Qualifiers R)
void addAddressSpace(LangAS space, bool AllowDefaultAddrSpace=false)
void setUnaligned(bool flag)
void addFastQualifiers(unsigned mask)
std::string getAsString() const
Qualifiers withRestrict() const
void addPointerAuth(PointerAuthQualifier Q)
void addObjCGCAttr(GC type)
bool hasPointerAuth() const
bool operator==(Qualifiers Other) const
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
void removeQualifiers(Qualifiers Q)
Remove the qualifiers from the given set from this set.
LangAS getAddressSpace() const
bool hasOnlyVolatile() const
void setPointerAuth(PointerAuthQualifier Q)
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Qualifiers getNonFastQualifiers() const
static Qualifiers fromOpaqueValue(uint64_t opaque)
bool hasStrongOrWeakObjCLifetime() const
True if the lifetime is either strong or weak.
static std::string getAddrSpaceAsString(LangAS AS)
bool hasFastQualifiers() const
bool hasOnlyRestrict() const
void addObjCLifetime(ObjCLifetime type)
void setObjCLifetime(ObjCLifetime type)
An rvalue reference type, per C++11 [dcl.ref].
static bool classof(const Type *T)
Represents a struct/union/class.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
RecordType(const RecordDecl *D)
RecordType(TypeClass TC, RecordDecl *D)
static bool classof(const Type *T)
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef, bool SpelledAsLValue)
static bool classof(const Type *T)
QualType getPointeeTypeAsWritten() const
bool isSpelledAsLValue() const
void Profile(llvm::FoldingSetNodeID &ID)
static void Profile(llvm::FoldingSetNodeID &ID, QualType Referencee, bool SpelledAsLValue)
Encodes a location in the source.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
The streaming interface shared between DiagnosticBuilder and PartialDiagnostic.
void AddTaggedVal(uint64_t V, DiagnosticsEngine::ArgumentKind Kind) const
Represents the result of substituting a set of types for a template type parameter pack.
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
static bool classof(const Type *T)
unsigned getNumArgs() const
Represents the result of substituting a type for a template type parameter.
std::optional< unsigned > getPackIndex() const
void Profile(llvm::FoldingSetNodeID &ID)
static bool classof(const Type *T)
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
static void Profile(llvm::FoldingSetNodeID &ID, QualType Replacement, const Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex)
Represents the declaration of a struct/union/class/enum.
TagDecl * getDecl() const
static bool classof(const Type *T)
A convenient class for passing around template argument information.
Represents a template argument.
Represents a C++ template name within the type system.
void Profile(llvm::FoldingSetNodeID &ID)
bool isDependent() const
Determines whether this is a dependent template name.
Represents a type template specialization; the template must be a class template, a type alias templa...
ArrayRef< TemplateArgument > template_arguments() const
static bool classof(const Type *T)
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
bool isTypeAlias() const
Determine if this template specialization type is for a type alias template that has been substituted...
bool isCurrentInstantiation() const
True if this template specialization type matches a current instantiation in the context in which it ...
Declaration of a template type parameter.
TemplateTypeParmDecl * getDecl() const
bool isParameterPack() const
void Profile(llvm::FoldingSetNodeID &ID)
unsigned getIndex() const
static bool classof(const Type *T)
static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth, unsigned Index, bool ParameterPack, TemplateTypeParmDecl *TTPDecl)
CanonicalTTPTInfo CanTTPTInfo
TemplateTypeParmDecl * TTPDecl
unsigned getDepth() const
[BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by a...
llvm::PointerIntPair< ValueDecl *, 1, unsigned > BaseTy
Base wrapper for a particular "section" of type source info.
Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...
static bool classof(const Type *T)
Expr * getUnderlyingExpr() const
TypeOfKind getKind() const
Returns the kind of 'typeof' type this is.
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
static bool classof(const Type *T)
TypeOfKind getKind() const
Returns the kind of 'typeof' type this is.
bool isSugared() const
Returns whether this type directly provides sugar.
QualType desugar() const
Remove a single level of sugar.
QualType getUnmodifiedType() const
A container of type source information.
QualType getType() const
Return the type wrapped by this type source info.
void overrideType(QualType T)
Override the type stored in this TypeSourceInfo. Use with caution!
A helper class for Type nodes having an ElaboratedTypeKeyword.
TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc, QualType Canonical, TypeDependence Dependence)
static CannotCastToThisType classof(const Type *)
static StringRef getTagTypeKindName(TagTypeKind Kind)
ElaboratedTypeKeyword getKeyword() const
FunctionTypeBitfields store various bits belonging to FunctionProtoType.
The base class of the type hierarchy.
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
bool isDecltypeType() const
bool isDependentSizedArrayType() const
bool isFixedPointOrIntegerType() const
Return true if this is a fixed point or integer type.
bool isBlockPointerType() const
TypedefBitfields TypedefBits
bool isBooleanType() const
bool isFunctionReferenceType() const
Type(const Type &)=delete
bool isObjCBuiltinType() const
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
bool isIncompleteArrayType() const
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
bool isFloat16Type() const
ReferenceTypeBitfields ReferenceTypeBits
ElaboratedTypeBitfields ElaboratedTypeBits
ArrayTypeBitfields ArrayTypeBits
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
bool isDependentAddressSpaceType() const
bool isUndeducedAutoType() const
bool isRValueReferenceType() const
bool isFundamentalType() const
Tests whether the type is categorized as a fundamental type.
VectorTypeBitfields VectorTypeBits
bool isConstantArrayType() const
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
Type & operator=(const Type &)=delete
bool isFunctionPointerType() const
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isConvertibleToFixedPointType() const
Return true if this can be converted to (or from) a fixed point type.
bool isConstantMatrixType() const
bool isPointerType() const
TypeWithKeywordBitfields TypeWithKeywordBits
bool isArrayParameterType() const
TypeOfBitfields TypeOfBits
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
bool isObjCSelType() const
const T * castAs() const
Member-template castAs<specific type>.
BuiltinTypeBitfields BuiltinTypeBits
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
bool isReferenceType() const
bool isSignedFixedPointType() const
Return true if this is a fixed point type that is signed according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isObjectPointerType() const
bool isEnumeralType() const
bool isVisibilityExplicit() const
Return true if the visibility was explicitly set is the code.
void addDependence(TypeDependence D)
ConstantArrayTypeBitfields ConstantArrayTypeBits
Type(TypeClass tc, QualType canon, TypeDependence Dependence)
bool isScalarType() const
bool isVariableArrayType() const
bool isFloat128Type() const
CountAttributedTypeBitfields CountAttributedTypeBits
bool isObjCQualifiedIdType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool isExtVectorType() const
bool isExtVectorBoolType() const
bool isObjCObjectOrInterfaceType() const
bool isSampledImageType() const
bool isNonOverloadPlaceholderType() const
Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.
bool isOCLIntelSubgroupAVCType() const
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isMemberDataPointerType() const
bool isLValueReferenceType() const
bool isBitIntType() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isOpenCLSpecificType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isFloat32Type() const
bool isAnyComplexType() const
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
DependentTemplateSpecializationTypeBitfields DependentTemplateSpecializationTypeBits
bool isSaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Type & operator=(Type &&)=delete
const BuiltinType * getAsPlaceholderType() const
QualType getCanonicalTypeInternal() const
bool isTemplateTypeParmType() const
bool isCompoundType() const
Tests whether the type is categorized as a compound type.
bool containsErrors() const
Whether this type is an error type.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isMemberPointerType() const
bool isAtomicType() const
AttributedTypeBitfields AttributedTypeBits
bool isFunctionProtoType() const
bool isIbm128Type() const
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
bool isObjCIdType() const
bool isMatrixType() const
PackExpansionTypeBitfields PackExpansionTypeBits
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isUnsaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isObjCObjectType() const
bool isFromAST() const
Whether this type comes from an AST file.
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isObjectType() const
Determine whether this type is an object type.
bool isDoubleType() const
FunctionTypeBitfields FunctionTypeBits
bool isBFloat16Type() const
void setDependence(TypeDependence D)
const T * getAsAdjusted() const
Member-template getAsAdjusted<specific type>.
bool isFunctionType() const
bool isObjCObjectPointerType() const
SubstTemplateTypeParmTypeBitfields SubstTemplateTypeParmTypeBits
TypeDependence getDependence() const
Visibility getVisibility() const
Determine the visibility of this type.
bool isMemberFunctionPointerType() const
bool isUnsignedFixedPointType() const
Return true if this is a fixed point type that is unsigned according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isVectorType() const
bool isObjCQualifiedClassType() const
bool isObjCClassType() const
bool isObjCInertUnsafeUnretainedType() const
Was this type written with the special inert-in-ARC __unsafe_unretained qualifier?
ObjCObjectTypeBitfields ObjCObjectTypeBits
bool isOCLExtOpaqueType() const
bool isAnyPointerType() const
bool hasSizedVLAType() const
Whether this type involves a variable-length array type with a definite size.
TypeClass getTypeClass() const
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
bool isSubscriptableVectorType() const
const T * getAs() const
Member-template getAs<specific type>'.
SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits
bool isNullPtrType() const
bool isRecordType() const
TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits
bool isTypedefNameType() const
Determines whether this type is written as a typedef-name.
bool isFunctionNoProtoType() const
bool isReserveIDT() const
bool hasObjCPointerRepresentation() const
Whether this type can represent an objective pointer type for the purpose of GC'ability.
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
AutoTypeBitfields AutoTypeBits
Base class for declarations which introduce a typedef-name.
TypedefNameDecl * getDecl() const
void Profile(llvm::FoldingSetNodeID &ID)
static bool classof(const Type *T)
bool typeMatchesDecl() const
static void Profile(llvm::FoldingSetNodeID &ID, const TypedefNameDecl *Decl, QualType Underlying)
Represents the dependent type named by a dependently-scoped typename using declaration,...
void Profile(llvm::FoldingSetNodeID &ID)
static void Profile(llvm::FoldingSetNodeID &ID, UnresolvedUsingTypenameDecl *D)
static bool classof(const Type *T)
UnresolvedUsingTypenameDecl * getDecl() const
Represents a dependent using declaration which was marked with typename.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
void Profile(llvm::FoldingSetNodeID &ID)
UsingShadowDecl * getFoundDecl() const
static void Profile(llvm::FoldingSetNodeID &ID, const UsingShadowDecl *Found, QualType Underlying)
static bool classof(const Type *T)
bool typeMatchesDecl() const
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a C array with a specified size that is not an integer-constant-expression.
SourceRange getBracketsRange() const
SourceLocation getLBracketLoc() const
static bool classof(const Type *T)
void Profile(llvm::FoldingSetNodeID &ID)
SourceLocation getRBracketLoc() const
Expr * getSizeExpr() const
Represents a GCC generic vector type.
unsigned getNumElements() const
void Profile(llvm::FoldingSetNodeID &ID)
static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType, unsigned NumElements, TypeClass TypeClass, VectorKind VecKind)
VectorKind getVectorKind() const
QualType ElementType
The element type of the vector.
QualType getElementType() const
static bool classof(const Type *T)
Defines the Linkage enumeration and various utility functions.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
constexpr bool isIntegralType(PrimType T)
The JSON file list parser is used to communicate input to InstallAPI.
@ Create
'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
TypeDependenceScope::TypeDependence TypeDependence
AutoTypeKeyword
Which keyword(s) were used to create an AutoType.
@ GNUAutoType
__auto_type (GNU extension)
@ DecltypeAuto
decltype(auto)
bool isTargetAddressSpace(LangAS AS)
CanThrowResult
Possible results from evaluation of a noexcept expression.
FunctionType::ExtInfo getFunctionExtInfo(const Type &t)
bool isDynamicExceptionSpec(ExceptionSpecificationType ESpecType)
NullabilityKind
Describes the nullability of a particular type.
@ Nullable
Values of this type can be null.
@ Unspecified
Whether values of this type can be null is (explicitly) unspecified.
@ NonNull
Values of this type can never be null.
RefQualifierKind
The kind of C++11 ref-qualifier associated with a function type.
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
bool IsEnumDeclComplete(EnumDecl *ED)
Check if the given decl is complete.
ExprDependence computeDependence(FullExpr *E)
TypeOfKind
The kind of 'typeof' expression we're after.
bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
TypeDependence toTypeDependence(ExprDependence D)
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
unsigned toTargetAddressSpace(LangAS AS)
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
ObjCSubstitutionContext
The kind of type we are substituting Objective-C type arguments into.
@ Superclass
The superclass of a type.
@ Ordinary
An ordinary type.
@ Property
The type of a property.
@ Parameter
The parameter type of a method or function.
@ Result
The result type of a method or function.
ArraySizeModifier
Capture whether this is a normal array (e.g.
ParameterABI
Kinds of parameter ABI.
@ Ordinary
This parameter uses ordinary ABI rules for its type.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
bool isNoexceptExceptionSpec(ExceptionSpecificationType ESpecType)
TagTypeKind
The kind of a tag type.
constexpr unsigned PointerAuthKeyNone
bool IsEnumDeclScoped(EnumDecl *ED)
Check if the given decl is scoped.
LangAS
Defines the address space values used by the address space qualifier of QualType.
void FixedPointValueToString(SmallVectorImpl< char > &Str, llvm::APSInt Val, unsigned Scale)
bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg, const NamedDecl *Param, ArrayRef< TemplateArgument > Args, unsigned Depth)
Make a best-effort determination of whether the type T can be produced by substituting Args into the ...
std::integral_constant< bool, std::is_same< T, ArrayType >::value||std::is_base_of< ArrayType, T >::value > TypeIsArrayType
bool isPtrSizeAddressSpace(LangAS AS)
const FunctionProtoType * T
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
PointerAuthenticationMode
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ AltiVecBool
is AltiVec 'vector bool ...'
@ SveFixedLengthData
is AArch64 SVE fixed-length data vector
@ AltiVecVector
is AltiVec vector
@ AltiVecPixel
is AltiVec 'vector Pixel'
@ Generic
not a target-specific vector type
@ RVVFixedLengthData
is RISC-V RVV fixed-length data vector
@ RVVFixedLengthMask
is RISC-V RVV fixed-length mask vector
@ NeonPoly
is ARM Neon polynomial vector
@ SveFixedLengthPredicate
is AArch64 SVE fixed-length predicate vector
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Union
The "union" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
TypeDependence toSyntacticDependence(TypeDependence D)
@ Other
Other implicit parameter.
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
@ EST_DependentNoexcept
noexcept(expression), value-dependent
@ EST_Uninstantiated
not instantiated yet
@ EST_Unparsed
not parsed yet
@ EST_NoThrow
Microsoft __declspec(nothrow) extension.
@ EST_None
no exception specification
@ EST_MSAny
Microsoft throw(...) extension.
@ EST_BasicNoexcept
noexcept
@ EST_NoexceptFalse
noexcept(expression), evals to 'false'
@ EST_Unevaluated
not evaluated yet, for special member function
@ EST_NoexceptTrue
noexcept(expression), evals to 'true'
@ EST_Dynamic
throw(T1, T2)
Visibility
Describes the different kinds of visibility that a declaration may have.
Diagnostic wrappers for TextAPI types for error reporting.
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Holds information about the various types of exception specification.
ExceptionSpecInfo(ExceptionSpecificationType EST)
ExceptionSpecificationType Type
The kind of exception specification this is.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
ExceptionSpecInfo()=default
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
bool requiresFunctionProtoTypeArmAttributes() const
unsigned AArch64SMEAttributes
SourceLocation EllipsisLoc
const ExtParameterInfo * ExtParameterInfos
RefQualifierKind RefQualifier
ExtProtoInfo(CallingConv CC)
unsigned HasTrailingReturn
bool requiresFunctionProtoTypeExtraBitfields() const
void setArmSMEAttribute(AArch64SMETypeAttributes Kind, bool Enable=true)
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI)
FunctionType::ExtInfo ExtInfo
A simple holder for a QualType representing a type in an exception specification.
A holder for Arm type attributes as described in the Arm C/C++ Language extensions which are not part...
FunctionTypeArmAttributes()
unsigned AArch64SMEAttributes
Any AArch64 SME ACLE type attributes that need to be propagated on declarations and function pointers...
Describes how types, statements, expressions, and declarations should be printed.
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
std::pair< const Type *, Qualifiers > asPair() const
SplitQualType(const Type *ty, Qualifiers qs)
SplitQualType getSingleStepDesugaredType() const
friend bool operator==(SplitQualType a, SplitQualType b)
const Type * Ty
The locally-unqualified type.
friend bool operator!=(SplitQualType a, SplitQualType b)
Qualifiers Quals
The local qualifiers.
static void * getAsVoidPointer(::clang::ExtQuals *P)
static inline ::clang::ExtQuals * getFromVoidPointer(void *P)
static void * getAsVoidPointer(::clang::Type *P)
static inline ::clang::Type * getFromVoidPointer(void *P)
static clang::QualType getFromVoidPointer(void *P)
static void * getAsVoidPointer(clang::QualType P)
static SimpleType getSimplifiedValue(::clang::QualType Val)