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"
68class TemplateParameterList;
76namespace serialization {
77 template <
class T>
class AbstractTypeReader;
114template <
typename>
class CanQual;
119class ExtQualsTypeCommonBase;
123class ObjCInterfaceDecl;
124class ObjCProtocolDecl;
125class ObjCTypeParamDecl;
126struct PrintingPolicy;
130class TemplateArgument;
131class TemplateArgumentListInfo;
132class TemplateArgumentLoc;
133class TemplateTypeParmDecl;
134class TypedefNameDecl;
135class UnresolvedUsingTypenameDecl;
136class 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;
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");
608 Mask = (Mask & ~FastMask) | mask;
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);
1629raw_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);
1783enum class ArraySizeModifier;
1784enum class ElaboratedTypeKeyword;
1785enum class VectorKind;
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;
1944 unsigned FastTypeQuals : Qualifiers::FastWidth;
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;
2276 TypeBits.CachedLinkage = llvm::to_underlying(Linkage::Invalid);
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;
2459 bool isIntegralType(
const ASTContext &Ctx)
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 isMatrixType()
const;
2527 bool isConstantMatrixType()
const;
2528 bool isDependentAddressSpaceType()
const;
2529 bool isObjCObjectPointerType()
const;
2530 bool isObjCRetainableType()
const;
2531 bool isObjCLifetimeType()
const;
2532 bool isObjCIndirectLifetimeType()
const;
2533 bool isObjCNSObjectType()
const;
2534 bool isObjCIndependentClassType()
const;
2537 bool isObjCObjectType()
const;
2538 bool isObjCQualifiedInterfaceType()
const;
2539 bool isObjCQualifiedIdType()
const;
2540 bool isObjCQualifiedClassType()
const;
2541 bool isObjCObjectOrInterfaceType()
const;
2542 bool isObjCIdType()
const;
2543 bool isDecltypeType()
const;
2551 return hasAttr(attr::ObjCInertUnsafeUnretained);
2561 bool isObjCIdOrObjectKindOfType(
const ASTContext &ctx,
2564 bool isObjCClassType()
const;
2572 bool isObjCClassOrClassKindOfType()
const;
2574 bool isBlockCompatibleObjCPointerType(
ASTContext &ctx)
const;
2575 bool isObjCSelType()
const;
2576 bool isObjCBuiltinType()
const;
2577 bool isObjCARCBridgableType()
const;
2578 bool isCARCBridgableType()
const;
2579 bool isTemplateTypeParmType()
const;
2580 bool isNullPtrType()
const;
2582 bool isNothrowT()
const;
2583 bool isAlignValT()
const;
2584 bool isStdByteType()
const;
2585 bool isAtomicType()
const;
2586 bool isUndeducedAutoType()
const;
2588 bool isTypedefNameType()
const;
2590#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2591 bool is##Id##Type() const;
2592#include "clang/Basic/OpenCLImageTypes.def"
2594 bool isImageType()
const;
2596 bool isSamplerT()
const;
2597 bool isEventT()
const;
2598 bool isClkEventT()
const;
2599 bool isQueueT()
const;
2600 bool isReserveIDT()
const;
2602#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2603 bool is##Id##Type() const;
2604#include "clang/Basic/OpenCLExtensionTypes.def"
2606 bool isOCLIntelSubgroupAVCType()
const;
2607 bool isOCLExtOpaqueType()
const;
2609 bool isPipeType()
const;
2610 bool isBitIntType()
const;
2611 bool isOpenCLSpecificType()
const;
2616 bool isObjCARCImplicitlyUnretainedType()
const;
2619 bool isCUDADeviceBuiltinSurfaceType()
const;
2621 bool isCUDADeviceBuiltinTextureType()
const;
2640 ScalarTypeKind getScalarTypeKind()
const;
2648 return getDependence() & TypeDependence::Error;
2654 return getDependence() & TypeDependence::Dependent;
2662 return getDependence() & TypeDependence::Instantiation;
2668 bool isUndeducedType()
const;
2672 return getDependence() & TypeDependence::VariablyModified;
2677 bool hasSizedVLAType()
const;
2680 bool hasUnnamedOrLocalType()
const;
2682 bool isOverloadableType()
const;
2685 bool isElaboratedTypeSpecifier()
const;
2687 bool canDecayToPointerType()
const;
2692 bool hasPointerRepresentation()
const;
2696 bool hasObjCPointerRepresentation()
const;
2700 bool hasIntegerRepresentation()
const;
2704 bool hasSignedIntegerRepresentation()
const;
2708 bool hasUnsignedIntegerRepresentation()
const;
2712 bool hasFloatingRepresentation()
const;
2717 const RecordType *getAsStructureType()
const;
2720 const ComplexType *getAsComplexIntegerType()
const;
2741 TagDecl *getAsTagDecl()
const;
2759 return dyn_cast_or_null<AutoType>(getContainedDeducedType());
2765 bool hasAutoForTrailingReturnType()
const;
2773 template <
typename T>
const T *getAs()
const;
2780 template <
typename T>
const T *getAsAdjusted()
const;
2784 const ArrayType *getAsArrayTypeUnsafe()
const;
2792 template <
typename T>
const T *castAs()
const;
2796 const ArrayType *castAsArrayTypeUnsafe()
const;
2805 const Type *getBaseElementTypeUnsafe()
const;
2810 const Type *getArrayElementTypeNoTypeQual()
const;
2815 const Type *getPointeeOrArrayElementType()
const;
2823 const Type *getUnqualifiedDesugaredType()
const;
2828 bool isSignedIntegerType()
const;
2833 bool isUnsignedIntegerType()
const;
2837 bool isSignedIntegerOrEnumerationType()
const;
2841 bool isUnsignedIntegerOrEnumerationType()
const;
2845 bool isFixedPointType()
const;
2848 bool isFixedPointOrIntegerType()
const;
2851 bool isConvertibleToFixedPointType()
const;
2855 bool isSaturatedFixedPointType()
const;
2859 bool isUnsaturatedFixedPointType()
const;
2863 bool isSignedFixedPointType()
const;
2867 bool isUnsignedFixedPointType()
const;
2872 bool isConstantSizeType()
const;
2876 bool isSpecifierType()
const;
2883 return getLinkageAndVisibility().getVisibility();
2888 return getLinkageAndVisibility().isVisibilityExplicit();
2896 bool isLinkageValid()
const;
2903 std::optional<NullabilityKind> getNullability()
const;
2910 bool canHaveNullability(
bool ResultIfUnknown =
true)
const;
2927 std::optional<ArrayRef<QualType>>
2928 getObjCSubstitutions(
const DeclContext *dc)
const;
2932 bool acceptsObjCTypeParams()
const;
2934 const char *getTypeClassName()
const;
2937 return CanonicalType;
2942 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
2947template <>
const TypedefType *Type::getAs()
const;
2948template <>
const UsingType *Type::getAs()
const;
2953template <>
const TemplateSpecializationType *Type::getAs()
const;
2957template <>
const AttributedType *Type::getAs()
const;
2961template <>
const BoundsAttributedType *Type::getAs()
const;
2965template <>
const CountAttributedType *Type::getAs()
const;
2969#define TYPE(Class, Base)
2970#define LEAF_TYPE(Class) \
2971template <> inline const Class##Type *Type::getAs() const { \
2972 return dyn_cast<Class##Type>(CanonicalType); \
2974template <> inline const Class##Type *Type::castAs() const { \
2975 return cast<Class##Type>(CanonicalType); \
2977#include "clang/AST/TypeNodes.inc"
2985#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2986#include "clang/Basic/OpenCLImageTypes.def"
2988#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2989#include "clang/Basic/OpenCLExtensionTypes.def"
2991#define SVE_TYPE(Name, Id, SingletonId) Id,
2992#include "clang/Basic/AArch64SVEACLETypes.def"
2994#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2995#include "clang/Basic/PPCTypes.def"
2997#define RVV_TYPE(Name, Id, SingletonId) Id,
2998#include "clang/Basic/RISCVVTypes.def"
3000#define WASM_TYPE(Name, Id, SingletonId) Id,
3001#include "clang/Basic/WebAssemblyReferenceTypes.def"
3003#define BUILTIN_TYPE(Id, SingletonId) Id,
3004#define LAST_BUILTIN_TYPE(Id) LastKind = Id
3005#include "clang/AST/BuiltinTypes.def"
3015 static_assert(Kind::LastKind <
3016 (1 << BuiltinTypeBitfields::NumOfBuiltinTypeBits) &&
3017 "Defined builtin type exceeds the allocated space for serial "
3019 BuiltinTypeBits.Kind = K;
3028 StringRef str =
getName(Policy);
3029 assert(!str.empty() && str.data()[str.size()] ==
'\0');
3058 return K >= Overload;
3065 return isPlaceholderTypeKind(
getKind());
3092 :
Type(
Complex, CanonicalPtr, Element->getDependence()),
3093 ElementType(Element) {}
3102 Profile(
ID, getElementType());
3106 ID.AddPointer(Element.getAsOpaquePtr());
3119 :
Type(
Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}
3128 Profile(
ID, getInnerType());
3145 :
Type(
Pointer, CanonicalPtr, Pointee->getDependence()),
3146 PointeeType(Pointee) {}
3155 Profile(
ID, getPointeeType());
3169 using BaseTy = llvm::PointerIntPair<ValueDecl *, 1, unsigned>;
3184 bool isDeref()
const;
3186 unsigned getInt()
const;
3187 void *getOpaqueValue()
const;
3189 void setFromOpaqueValue(
void *
V);
3220 return decl_range(dependent_decl_begin(), dependent_decl_end());
3224 return {dependent_decl_begin(), dependent_decl_end()};
3227 bool referencesFieldDecls()
const;
3234 case CountAttributed:
3246 public llvm::TrailingObjects<CountAttributedType,
3247 TypeCoupledDeclRefInfo> {
3258 bool CountInBytes,
bool OrNull,
3261 unsigned numTrailingObjects(OverloadToken<TypeCoupledDeclRefInfo>)
const {
3262 return CountAttributedTypeBits.NumCoupledDecls;
3275 bool isOrNull()
const {
return CountAttributedTypeBits.OrNull; }
3279 return isCountInBytes() ? SizedByOrNull : CountedByOrNull;
3280 return isCountInBytes() ? SizedBy : CountedBy;
3284 Profile(
ID, desugar(), CountExpr, isCountInBytes(), isOrNull());
3287 static void Profile(llvm::FoldingSetNodeID &
ID,
QualType WrappedTy,
3288 Expr *CountExpr,
bool CountInBytes,
bool Nullable);
3307 :
Type(TC, CanonicalPtr, OriginalTy->getDependence()),
3308 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
3318 Profile(
ID, OriginalTy, AdjustedTy);
3341 inline QualType getPointeeType()
const;
3356 :
Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
3357 PointeeType(Pointee) {}
3367 Profile(
ID, getPointeeType());
3385 bool SpelledAsLValue)
3386 :
Type(tc, CanonicalRef, Referencee->getDependence()),
3387 PointeeType(Referencee) {
3388 ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
3401 while (
T->isInnerRef())
3403 return T->PointeeType;
3407 Profile(
ID, PointeeType, isSpelledAsLValue());
3412 bool SpelledAsLValue) {
3414 ID.AddBoolean(SpelledAsLValue);
3428 bool SpelledAsLValue)
3470 :
Type(MemberPointer, CanonicalPtr,
3472 Pointee->getDependence()),
3473 PointeeType(Pointee),
Class(Cls) {}
3497 Profile(
ID, getPointeeType(), getClass());
3501 const Type *Class) {
3527 unsigned tq,
const Expr *sz =
nullptr);
3537 return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
3541 return ArrayTypeBits.IndexTypeQuals;
3559 struct ExternalSize {
3560 ExternalSize(
const llvm::APInt &Sz,
const Expr *SE)
3561 : Size(Sz), SizeExpr(SE) {}
3563 const Expr *SizeExpr;
3573 :
ArrayType(ConstantArray, Et, Can,
SM, TQ, nullptr), Size(Sz) {
3574 ConstantArrayTypeBits.HasExternalSize =
false;
3575 ConstantArrayTypeBits.SizeWidth = Width / 8;
3578 assert(Width < 0xFF &&
"Type width in bits must be less than 8 bits");
3581 ConstantArrayType(QualType Et, QualType Can, ExternalSize *SzPtr,
3582 ArraySizeModifier
SM,
unsigned TQ)
3583 : ArrayType(ConstantArray, Et, Can,
SM, TQ, SzPtr->SizeExpr),
3585 ConstantArrayTypeBits.HasExternalSize =
true;
3586 ConstantArrayTypeBits.SizeWidth = 0;
3588 assert((SzPtr->SizeExpr ==
nullptr || !Can.isNull()) &&
3589 "canonical constant array should not have size expression");
3592 static ConstantArrayType *
Create(
const ASTContext &Ctx, QualType ET,
3593 QualType Can,
const llvm::APInt &Sz,
3594 const Expr *SzExpr, ArraySizeModifier SzMod,
3599 :
ArrayType(Tc, ATy->getElementType(), Can, ATy->getSizeModifier(),
3600 ATy->getIndexTypeQualifiers().getAsOpaqueValue(), nullptr) {
3601 ConstantArrayTypeBits.HasExternalSize =
3603 if (!ConstantArrayTypeBits.HasExternalSize) {
3613 return ConstantArrayTypeBits.HasExternalSize
3615 : llvm::APInt(ConstantArrayTypeBits.SizeWidth * 8, Size);
3620 return ConstantArrayTypeBits.HasExternalSize
3621 ? SizePtr->Size.getBitWidth()
3622 :
static_cast<unsigned>(ConstantArrayTypeBits.SizeWidth * 8);
3627 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.isZero()
3633 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.getZExtValue()
3639 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.getSExtValue()
3640 :
static_cast<int64_t
>(Size);
3646 return ConstantArrayTypeBits.HasExternalSize
3647 ? SizePtr->Size.getLimitedValue()
3653 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->SizeExpr :
nullptr;
3661 static unsigned getNumAddressingBits(
const ASTContext &Context,
3663 const llvm::APInt &NumElements);
3665 unsigned getNumAddressingBits(
const ASTContext &Context)
const;
3669 static unsigned getMaxSizeBits(
const ASTContext &Context);
3672 Profile(
ID, Ctx, getElementType(), getZExtSize(), getSizeExpr(),
3673 getSizeModifier(), getIndexTypeCVRQualifiers());
3676 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx,
3708 :
ArrayType(IncompleteArray, et, can, sm, tq) {}
3721 Profile(
ID, getElementType(), getSizeModifier(),
3722 getIndexTypeCVRQualifiers());
3728 ID.AddInteger(llvm::to_underlying(SizeMod));
3729 ID.AddInteger(TypeQuals);
3760 :
ArrayType(VariableArray, et, can, sm, tq, e),
3761 SizeExpr((
Stmt*) e), Brackets(brackets) {}
3769 return (
Expr*) SizeExpr;
3784 llvm_unreachable(
"Cannot unique VariableArrayTypes.");
3824 return (
Expr*) SizeExpr;
3839 Profile(
ID, Context, getElementType(),
3840 getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
3843 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
3845 unsigned TypeQuals,
Expr *E);
3862 Expr *AddrSpaceExpr;
3882 Profile(
ID, Context, getPointeeType(), getAddrSpaceExpr());
3885 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
3925 Profile(
ID, Context, getElementType(), getSizeExpr());
3928 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
3994 Profile(
ID, getElementType(), getNumElements(),
3995 getTypeClass(), getVectorKind());
4002 ID.AddInteger(NumElements);
4004 ID.AddInteger(llvm::to_underlying(VecKind));
4047 Profile(
ID, Context, getElementType(), getSizeExpr(), getVectorKind());
4050 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
4065 :
VectorType(ExtVector, vecType, nElements, canonType,
4072 case 'x':
case 'r':
return 0;
4073 case 'y':
case 'g':
return 1;
4074 case 'z':
case 'b':
return 2;
4075 case 'w':
case 'a':
return 3;
4093 case 'a':
return 10;
4095 case 'b':
return 11;
4097 case 'c':
return 12;
4099 case 'd':
return 13;
4101 case 'e':
return 14;
4103 case 'f':
return 15;
4108 if (isNumericAccessor)
4109 return getNumericAccessorIdx(
c);
4111 return getPointAccessorIdx(
c);
4115 if (
int idx = getAccessorIdx(
c, isNumericAccessor)+1)
4116 return unsigned(idx-1) < getNumElements();
4141 const Expr *RowExpr =
nullptr,
const Expr *ColumnExpr =
nullptr);
4175 static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;
4178 unsigned NColumns,
QualType CanonElementType);
4181 unsigned NColumns,
QualType CanonElementType);
4192 return getNumRows() * getNumColumns();
4197 return NumElements > 0 && NumElements <= MaxElementsPerDimension;
4202 return MaxElementsPerDimension;
4206 Profile(
ID, getElementType(), getNumRows(), getNumColumns(),
4211 unsigned NumRows,
unsigned NumColumns,
4214 ID.AddInteger(NumRows);
4215 ID.AddInteger(NumColumns);
4247 Profile(
ID, Context, getElementType(), getRowExpr(), getColumnExpr());
4250 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
4286 HasPassObjSize = 0x20,
4289 unsigned char Data = 0;
4298 copy.Data = (copy.Data & ~ABIMask) |
unsigned(kind);
4308 copy.Data |= IsConsumed;
4310 copy.Data &= ~IsConsumed;
4317 Copy.Data |= HasPassObjSize;
4325 Copy.Data |= IsNoEscape;
4327 Copy.Data &= ~IsNoEscape;
4339 return lhs.Data == rhs.Data;
4343 return lhs.Data != rhs.Data;
4378 enum { CallConvMask = 0x1F };
4379 enum { NoReturnMask = 0x20 };
4380 enum { ProducesResultMask = 0x40 };
4381 enum { NoCallerSavedRegsMask = 0x80 };
4383 RegParmMask = 0x700,
4386 enum { NoCfCheckMask = 0x800 };
4387 enum { CmseNSCallMask = 0x1000 };
4388 uint16_t Bits =
CC_C;
4390 ExtInfo(
unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
4396 bool producesResult,
bool noCallerSavedRegs,
bool NoCfCheck,
4398 assert((!hasRegParm || regParm < 7) &&
"Invalid regparm value");
4399 Bits = ((
unsigned)cc) | (noReturn ? NoReturnMask : 0) |
4400 (producesResult ? ProducesResultMask : 0) |
4401 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
4402 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
4403 (NoCfCheck ? NoCfCheckMask : 0) |
4404 (cmseNSCall ? CmseNSCallMask : 0);
4420 bool getHasRegParm()
const {
return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
4423 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
4432 return Bits ==
Other.Bits;
4435 return Bits !=
Other.Bits;
4443 return ExtInfo(Bits | NoReturnMask);
4445 return ExtInfo(Bits & ~NoReturnMask);
4450 return ExtInfo(Bits | ProducesResultMask);
4452 return ExtInfo(Bits & ~ProducesResultMask);
4457 return ExtInfo(Bits | CmseNSCallMask);
4459 return ExtInfo(Bits & ~CmseNSCallMask);
4463 if (noCallerSavedRegs)
4464 return ExtInfo(Bits | NoCallerSavedRegsMask);
4466 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
4471 return ExtInfo(Bits | NoCfCheckMask);
4473 return ExtInfo(Bits & ~NoCfCheckMask);
4477 assert(RegParm < 7 &&
"Invalid regparm value");
4478 return ExtInfo((Bits & ~RegParmMask) |
4479 ((RegParm + 1) << RegParmOffset));
4483 return ExtInfo((Bits & ~CallConvMask) | (
unsigned) cc);
4487 ID.AddInteger(Bits);
4505 LLVM_PREFERRED_TYPE(
bool)
4509 : NumExceptionType(0), HasArmTypeAttributes(
false) {}
4516 SME_NormalFunction = 0,
4517 SME_PStateSMEnabledMask = 1 << 0,
4518 SME_PStateSMCompatibleMask = 1 << 1,
4522 SME_ZAMask = 0b111 << SME_ZAShift,
4524 SME_ZT0Mask = 0b111 << SME_ZT0Shift,
4540 return (
ArmStateValue)((AttrBits & SME_ZAMask) >> SME_ZAShift);
4544 return (
ArmStateValue)((AttrBits & SME_ZT0Mask) >> SME_ZT0Shift);
4562 FunctionTypeBits.ExtInfo = Info.Bits;
4566 if (isFunctionProtoType())
4567 return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
4587 static_assert((
~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
4588 "Const, volatile and restrict are assumed to be a subset of "
4589 "the fast qualifiers.");
4591 bool isConst()
const {
return getFastTypeQuals().hasConst(); }
4592 bool isVolatile()
const {
return getFastTypeQuals().hasVolatile(); }
4593 bool isRestrict()
const {
return getFastTypeQuals().hasRestrict(); }
4601 static StringRef getNameForCallConv(
CallingConv CC);
4616 Result->getDependence() &
4628 Profile(
ID, getReturnType(), getExtInfo());
4651 public llvm::FoldingSetNode,
4652 private llvm::TrailingObjects<
4653 FunctionProtoType, QualType, SourceLocation,
4654 FunctionType::FunctionTypeExtraBitfields,
4655 FunctionType::FunctionTypeArmAttributes, FunctionType::ExceptionType,
4656 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
4658 friend TrailingObjects;
4748 AArch64SMEAttributes(SME_NormalFunction) {}
4752 AArch64SMEAttributes(SME_NormalFunction) {}
4756 Result.ExceptionSpec = ESI;
4762 requiresFunctionProtoTypeArmAttributes();
4766 return AArch64SMEAttributes != SME_NormalFunction;
4771 AArch64SMEAttributes |= Kind;
4773 AArch64SMEAttributes &= ~Kind;
4778 unsigned numTrailingObjects(OverloadToken<QualType>)
const {
4779 return getNumParams();
4782 unsigned numTrailingObjects(OverloadToken<SourceLocation>)
const {
4783 return isVariadic();
4786 unsigned numTrailingObjects(OverloadToken<FunctionTypeArmAttributes>)
const {
4787 return hasArmTypeAttributes();
4790 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>)
const {
4791 return hasExtraBitfields();
4794 unsigned numTrailingObjects(OverloadToken<ExceptionType>)
const {
4795 return getExceptionSpecSize().NumExceptionType;
4798 unsigned numTrailingObjects(OverloadToken<Expr *>)
const {
4799 return getExceptionSpecSize().NumExprPtr;
4802 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>)
const {
4803 return getExceptionSpecSize().NumFunctionDeclPtr;
4806 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>)
const {
4807 return hasExtParameterInfos() ? getNumParams() : 0;
4812 static bool containsAnyUnexpandedParameterPack(
const QualType *ArgArray,
4814 for (
unsigned Idx = 0; Idx < numArgs; ++Idx)
4815 if (ArgArray[Idx]->containsUnexpandedParameterPack())
4821 FunctionProtoType(QualType result, ArrayRef<QualType> params,
4822 QualType canonical,
const ExtProtoInfo &epi);
4827 struct ExceptionSpecSizeHolder {
4828 unsigned NumExceptionType;
4829 unsigned NumExprPtr;
4830 unsigned NumFunctionDeclPtr;
4835 static ExceptionSpecSizeHolder
4836 getExceptionSpecSize(ExceptionSpecificationType EST,
unsigned NumExceptions) {
4847 return {NumExceptions, 0, 0};
4860 llvm_unreachable(
"bad exception specification kind");
4865 ExceptionSpecSizeHolder getExceptionSpecSize()
const {
4866 return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
4870 bool hasExtraBitfields()
const {
4871 assert((getExceptionSpecType() != EST_Dynamic ||
4872 FunctionTypeBits.HasExtraBitfields) &&
4873 "ExtraBitfields are required for given ExceptionSpecType");
4874 return FunctionTypeBits.HasExtraBitfields;
4878 bool hasArmTypeAttributes()
const {
4879 return FunctionTypeBits.HasExtraBitfields &&
4880 getTrailingObjects<FunctionTypeExtraBitfields>()
4881 ->HasArmTypeAttributes;
4884 bool hasExtQualifiers()
const {
4885 return FunctionTypeBits.HasExtQuals;
4892 assert(i < getNumParams() &&
"invalid parameter index");
4893 return param_type_begin()[i];
4917 FunctionTypeBits.ExceptionSpecType);
4934 bool hasDependentExceptionSpec()
const;
4938 bool hasInstantiationDependentExceptionSpec()
const;
4943 Result.Type = getExceptionSpecType();
4945 Result.Exceptions = exceptions();
4947 Result.NoexceptExpr = getNoexceptExpr();
4949 Result.SourceDecl = getExceptionSpecDecl();
4950 Result.SourceTemplate = getExceptionSpecTemplate();
4952 Result.SourceDecl = getExceptionSpecDecl();
4960 ? getTrailingObjects<FunctionTypeExtraBitfields>()
4967 assert(i < getNumExceptions() &&
"Invalid exception number!");
4968 return exception_begin()[i];
4976 return *getTrailingObjects<Expr *>();
4987 return getTrailingObjects<FunctionDecl *>()[0];
4997 return getTrailingObjects<FunctionDecl *>()[1];
5008 return ResultIfDependent ? canThrow() !=
CT_Can : canThrow() ==
CT_Cannot;
5015 return isVariadic() ? *getTrailingObjects<SourceLocation>()
5025 bool isTemplateVariadic()
const;
5031 if (hasExtQualifiers())
5032 return *getTrailingObjects<Qualifiers>();
5034 return getFastTypeQuals();
5049 return getTrailingObjects<QualType>();
5053 return param_type_begin() + getNumParams();
5064 getTrailingObjects<ExceptionType>());
5068 return exception_begin() + getNumExceptions();
5074 return FunctionTypeBits.HasExtParameterInfos;
5078 assert(hasExtParameterInfos());
5087 if (!hasExtParameterInfos())
5089 return getTrailingObjects<ExtParameterInfo>();
5095 if (!hasArmTypeAttributes())
5096 return SME_NormalFunction;
5097 return getTrailingObjects<FunctionTypeArmAttributes>()
5098 ->AArch64SMEAttributes;
5102 assert(I < getNumParams() &&
"parameter index out of range");
5103 if (hasExtParameterInfos())
5104 return getTrailingObjects<ExtParameterInfo>()[I];
5109 assert(I < getNumParams() &&
"parameter index out of range");
5110 if (hasExtParameterInfos())
5111 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
5112 return ParameterABI::Ordinary;
5116 assert(I < getNumParams() &&
"parameter index out of range");
5117 if (hasExtParameterInfos())
5118 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
5125 void printExceptionSpecification(raw_ostream &OS,
5132 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx);
5165 return Profile(
ID,
Decl);
5175 public llvm::FoldingSetNode,
5176 private llvm::TrailingObjects<UsingType, QualType> {
5179 friend TrailingObjects;
5200 ID.AddPointer(Found);
5207 public llvm::FoldingSetNode,
5208 private llvm::TrailingObjects<TypedefType, QualType> {
5211 friend TrailingObjects;
5233 if (!Underlying.
isNull())
5250 :
Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
5251 UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
5252 assert(isa<AttributedType>(UnderlyingTy) &&
5253 "Expected a macro qualified type to only wrap attributed types.");
5287 return TypeOfBits.IsUnqual ? TypeOfKind::Unqualified
5288 : TypeOfKind::Qualified;
5295 bool isSugared()
const;
5307 public llvm::FoldingSetNode {
5312 Profile(
ID, Context, getUnderlyingExpr(),
5313 getKind() == TypeOfKind::Unqualified);
5316 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5317 Expr *E,
bool IsUnqual);
5331 T->getDependence()),
5333 TypeOfBits.IsUnqual = Kind == TypeOfKind::Unqualified;
5350 return TypeOfBits.IsUnqual ? TypeOfKind::Unqualified
5351 : TypeOfKind::Qualified;
5375 bool isSugared()
const;
5391 Profile(
ID, Context, getUnderlyingExpr());
5394 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5400 public llvm::FoldingSetNode,
5401 private llvm::TrailingObjects<PackIndexingType, QualType> {
5402 friend TrailingObjects;
5423 if (hasSelectedType())
5424 return getSelectedType();
5429 assert(hasSelectedType() &&
"Type is dependant");
5430 return *(getExpansionsPtr() + *getSelectedIndex());
5433 std::optional<unsigned> getSelectedIndex()
const;
5438 return {getExpansionsPtr(), Size};
5446 if (hasSelectedType())
5447 getSelectedType().Profile(
ID);
5449 Profile(
ID, Context, getPattern(), getIndexExpr());
5451 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5455 const QualType *getExpansionsPtr()
const {
5456 return getTrailingObjects<QualType>();
5459 static TypeDependence computeDependence(QualType Pattern, Expr *IndexExpr,
5460 ArrayRef<QualType> Expansions = {});
5462 unsigned numTrailingObjects(OverloadToken<QualType>)
const {
return Size; }
5469#define TRANSFORM_TYPE_TRAIT_DEF(Enum, _) Enum,
5470#include "clang/Basic/TransformTypeTraits.def"
5478 QualType UnderlyingType;
5509 public llvm::FoldingSetNode {
5515 Profile(
ID, getBaseType(), getUTTKind());
5521 ID.AddInteger((
unsigned)UKind);
5540 bool isBeingDefined()
const;
5560 return reinterpret_cast<RecordDecl*
>(TagType::getDecl());
5565 bool hasConstFields()
const;
5583 return reinterpret_cast<EnumDecl*
>(TagType::getDecl());
5616 :
Type(Attributed, canon, equivalent->getDependence()),
5617 ModifiedType(modified), EquivalentType(equivalent) {
5618 AttributedTypeBits.AttrKind = attrKind;
5623 return static_cast<Kind>(AttributedTypeBits.AttrKind);
5647 bool isQualifier()
const;
5649 bool isMSTypeSpec()
const;
5651 bool isWebAssemblyFuncrefSpec()
const;
5653 bool isCallingConv()
const;
5655 std::optional<NullabilityKind> getImmediateNullability()
const;
5661 case NullabilityKind::NonNull:
5662 return attr::TypeNonNull;
5664 case NullabilityKind::Nullable:
5665 return attr::TypeNullable;
5667 case NullabilityKind::NullableResult:
5668 return attr::TypeNullableResult;
5670 case NullabilityKind::Unspecified:
5671 return attr::TypeNullUnspecified;
5673 llvm_unreachable(
"Unknown nullability kind.");
5685 static std::optional<NullabilityKind> stripOuterNullability(
QualType &T);
5688 Profile(
ID, getAttrKind(), ModifiedType, EquivalentType);
5693 ID.AddInteger(attrKind);
5708 const BTFTypeTagAttr *BTFAttr;
5711 const BTFTypeTagAttr *BTFAttr)
5712 :
Type(BTFTagAttributed, Canon, Wrapped->getDependence()),
5713 WrappedType(Wrapped), BTFAttr(BTFAttr) {}
5717 const BTFTypeTagAttr *
getAttr()
const {
return BTFAttr; }
5723 Profile(
ID, WrappedType, BTFAttr);
5727 const BTFTypeTagAttr *BTFAttr) {
5729 ID.AddPointer(BTFAttr);
5741 struct CanonicalTTPTInfo {
5742 unsigned Depth : 15;
5743 unsigned ParameterPack : 1;
5744 unsigned Index : 16;
5757 :
Type(TemplateTypeParm, Canon,
5763 TemplateTypeParmType(
unsigned D,
unsigned I,
bool PP)
5764 :
Type(TemplateTypeParm, QualType(this, 0),
5765 TypeDependence::DependentInstantiation |
5766 (PP ? TypeDependence::UnexpandedPack : TypeDependence::
None)) {
5767 CanTTPTInfo.Depth = D;
5768 CanTTPTInfo.Index = I;
5769 CanTTPTInfo.ParameterPack = PP;
5772 const CanonicalTTPTInfo& getCanTTPTInfo()
const {
5773 QualType Can = getCanonicalTypeInternal();
5774 return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
5778 unsigned getDepth()
const {
return getCanTTPTInfo().Depth; }
5779 unsigned getIndex()
const {
return getCanTTPTInfo().Index; }
5783 return isCanonicalUnqualified() ? nullptr : TTPDecl;
5795 static void Profile(llvm::FoldingSetNodeID &
ID,
unsigned Depth,
5796 unsigned Index,
bool ParameterPack,
5798 ID.AddInteger(Depth);
5799 ID.AddInteger(Index);
5800 ID.AddBoolean(ParameterPack);
5801 ID.AddPointer(TTPDecl);
5818 public llvm::FoldingSetNode,
5819 private llvm::TrailingObjects<SubstTemplateTypeParmType, QualType> {
5823 Decl *AssociatedDecl;
5826 unsigned Index, std::optional<unsigned> PackIndex);
5832 return SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType
5833 ? *getTrailingObjects<QualType>()
5834 : getCanonicalTypeInternal();
5847 unsigned getIndex()
const {
return SubstTemplateTypeParmTypeBits.Index; }
5850 if (SubstTemplateTypeParmTypeBits.PackIndex == 0)
5851 return std::nullopt;
5852 return SubstTemplateTypeParmTypeBits.PackIndex - 1;
5859 Profile(
ID, getReplacementType(), getAssociatedDecl(), getIndex(),
5864 const Decl *AssociatedDecl,
unsigned Index,
5865 std::optional<unsigned> PackIndex) {
5866 Replacement.Profile(
ID);
5867 ID.AddPointer(AssociatedDecl);
5868 ID.AddInteger(Index);
5869 ID.AddInteger(PackIndex ? *PackIndex - 1 : 0);
5896 llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
5899 unsigned Index,
bool Final,
5908 Decl *getAssociatedDecl()
const;
5915 unsigned getIndex()
const {
return SubstTemplateTypeParmPackTypeBits.Index; }
5918 bool getFinal()
const;
5921 return SubstTemplateTypeParmPackTypeBits.NumArgs;
5929 void Profile(llvm::FoldingSetNodeID &
ID);
5930 static void Profile(llvm::FoldingSetNodeID &
ID,
const Decl *AssociatedDecl,
5931 unsigned Index,
bool Final,
5954 ExtraDependence | (DeducedAsType.isNull()
5956 : DeducedAsType->getDependence() &
5958 DeducedAsType(DeducedAsType) {}
5963 return isSugared() ? DeducedAsType :
QualType(
this, 0);
5970 return !DeducedAsType.
isNull() || isDependentType();
5993 AutoTypeBits.NumArgs};
5997 return TypeConstraintConcept;
6001 return TypeConstraintConcept !=
nullptr;
6005 return getKeyword() == AutoTypeKeyword::DecltypeAuto;
6009 return getKeyword() == AutoTypeKeyword::GNUAutoType;
6016 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context);
6017 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
6029 public llvm::FoldingSetNode {
6037 bool IsDeducedAsDependent)
6038 :
DeducedType(DeducedTemplateSpecialization, DeducedAsType,
6040 (IsDeducedAsDependent
6043 DeducedAsType.isNull() ?
QualType(this, 0)
6044 : DeducedAsType.getCanonicalType()),
6045 Template(Template) {}
6052 Profile(
ID, getTemplateName(), getDeducedType(), isDependentType());
6056 QualType Deduced,
bool IsDependent) {
6124 static bool anyInstantiationDependentTemplateArguments(
6130 return isa<InjectedClassNameType>(getCanonicalTypeInternal());
6148 bool isTypeAlias()
const {
return TemplateSpecializationTypeBits.TypeAlias; }
6159 TemplateSpecializationTypeBits.NumArgs};
6163 return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
6167 return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
6170 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx);
6182void printTemplateArgumentList(raw_ostream &OS,
6183 ArrayRef<TemplateArgument> Args,
6184 const PrintingPolicy &Policy,
6185 const TemplateParameterList *TPL =
nullptr);
6187void printTemplateArgumentList(raw_ostream &OS,
6188 ArrayRef<TemplateArgumentLoc> Args,
6189 const PrintingPolicy &Policy,
6190 const TemplateParameterList *TPL =
nullptr);
6192void printTemplateArgumentList(raw_ostream &OS,
6193 const TemplateArgumentListInfo &Args,
6194 const PrintingPolicy &Policy,
6195 const TemplateParameterList *TPL =
nullptr);
6199bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg,
6200 const NamedDecl *Param,
6201 ArrayRef<TemplateArgument> Args,
6245 Decl(D), InjectedType(TST) {
6246 assert(isa<TemplateSpecializationType>(TST));
6255 return cast<TemplateSpecializationType>(InjectedType.
getTypePtr());
6259 return getInjectedTST()->getTemplateName();
6325 TypeWithKeywordBits.Keyword = llvm::to_underlying(Keyword);
6338 static TagTypeKind getTagTypeKindForTypeSpec(
unsigned TypeSpec);
6353 return getKeywordName(getKeywordForTagTypeKind(Kind));
6370 public llvm::FoldingSetNode,
6371 private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
6373 friend TrailingObjects;
6392 NamedType->getDependence() |
6396 NNS(NNS), NamedType(NamedType) {
6397 ElaboratedTypeBits.HasOwnedTagDecl =
false;
6399 ElaboratedTypeBits.HasOwnedTagDecl =
true;
6400 *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
6420 return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
6425 Profile(
ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
6431 ID.AddInteger(llvm::to_underlying(Keyword));
6434 ID.AddPointer(OwnedTagDecl);
6466 NNS(NNS), Name(Name) {}
6485 Profile(
ID, getKeyword(), NNS, Name);
6490 ID.AddInteger(llvm::to_underlying(Keyword));
6492 ID.AddPointer(Name);
6504 public llvm::FoldingSetNode {
6525 DependentTemplateSpecializationTypeBits.NumArgs};
6532 Profile(
ID, Context, getKeyword(), NNS, Name, template_arguments());
6535 static void Profile(llvm::FoldingSetNodeID &
ID,
6543 return T->
getTypeClass() == DependentTemplateSpecialization;
6576 std::optional<unsigned> NumExpansions)
6577 :
Type(PackExpansion, Canon,
6582 PackExpansionTypeBits.NumExpansions =
6583 NumExpansions ? *NumExpansions + 1 : 0;
6595 if (PackExpansionTypeBits.NumExpansions)
6596 return PackExpansionTypeBits.NumExpansions - 1;
6597 return std::nullopt;
6604 Profile(
ID, getPattern(), getNumExpansions());
6608 std::optional<unsigned> NumExpansions) {
6610 ID.AddBoolean(NumExpansions.has_value());
6612 ID.AddInteger(*NumExpansions);
6632 return static_cast<T*
>(
this)->getProtocolStorageImpl();
6636 static_cast<T*
>(
this)->setNumProtocolsImpl(N);
6640 setNumProtocols(protocols.size());
6641 assert(getNumProtocols() == protocols.size() &&
6642 "bitfield overflow in protocol count");
6643 if (!protocols.empty())
6644 memcpy(getProtocolStorage(), protocols.data(),
6661 return static_cast<const T*
>(
this)->getNumProtocolsImpl();
6666 assert(I < getNumProtocols() &&
"Out-of-range protocol access");
6667 return qual_begin()[I];
6680 public llvm::FoldingSetNode {
6685 unsigned NumProtocols : 6;
6696 unsigned getNumProtocolsImpl()
const {
6697 return NumProtocols;
6700 void setNumProtocolsImpl(
unsigned N) {
6704 ObjCTypeParamType(
const ObjCTypeParamDecl *D,
6706 ArrayRef<ObjCProtocolDecl *> protocols);
6716 void Profile(llvm::FoldingSetNodeID &
ID);
6717 static void Profile(llvm::FoldingSetNodeID &
ID,
6773 mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
6774 CachedSuperClassType;
6777 const QualType *getTypeArgStorage()
const {
6784 unsigned getNumProtocolsImpl()
const {
6785 return ObjCObjectTypeBits.NumProtocols;
6787 void setNumProtocolsImpl(
unsigned N) {
6788 ObjCObjectTypeBits.NumProtocols = N;
6802 ObjCObjectTypeBits.NumProtocols = 0;
6803 ObjCObjectTypeBits.NumTypeArgs = 0;
6804 ObjCObjectTypeBits.IsKindOf = 0;
6807 void computeSuperClassTypeSlow()
const;
6819 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
6823 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
6829 if (!qual_empty())
return false;
6830 if (
const BuiltinType *
T = getBaseType()->getAs<BuiltinType>())
6831 return T->getKind() == BuiltinType::ObjCId ||
6832 T->getKind() == BuiltinType::ObjCClass;
6844 bool isSpecialized()
const;
6848 return ObjCObjectTypeBits.NumTypeArgs > 0;
6865 return llvm::ArrayRef(getTypeArgStorage(), ObjCObjectTypeBits.NumTypeArgs);
6872 bool isKindOfType()
const;
6881 if (!CachedSuperClassType.getInt())
6882 computeSuperClassTypeSlow();
6884 assert(CachedSuperClassType.getInt() &&
"Superclass not set?");
6885 return QualType(CachedSuperClassType.getPointer(), 0);
6918 void Profile(llvm::FoldingSetNodeID &
ID);
6919 static void Profile(llvm::FoldingSetNodeID &
ID,
6926inline QualType *ObjCObjectType::getTypeArgStorage() {
6927 return reinterpret_cast<QualType *
>(
static_cast<ObjCObjectTypeImpl*
>(
this)+1);
6930inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
6931 return reinterpret_cast<ObjCProtocolDecl**
>(
6932 getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
6935inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
6936 return reinterpret_cast<ObjCProtocolDecl**
>(
6937 static_cast<ObjCTypeParamType*
>(
this)+1);
6990 if (
const auto *
T = dyn_cast<ObjCInterfaceType>(ObjT))
6991 return T->getDecl();
6993 baseType = ObjT->getBaseType();
7014 :
Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
7015 PointeeType(Pointee) {}
7158 QualType getSuperClassType()
const;
7166 Profile(
ID, getPointeeType());
7170 ID.AddPointer(
T.getAsOpaquePtr());
7184 :
Type(
Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}
7195 Profile(
ID, getValueType());
7199 ID.AddPointer(
T.getAsOpaquePtr());
7215 :
Type(
Pipe, CanonicalPtr, elemType->getDependence()),
7226 Profile(
ID, getElementType(), isReadOnly());
7230 ID.AddPointer(
T.getAsOpaquePtr());
7244 LLVM_PREFERRED_TYPE(
bool)
7245 unsigned IsUnsigned : 1;
7246 unsigned NumBits : 24;
7263 static void Profile(llvm::FoldingSetNodeID &
ID,
bool IsUnsigned,
7265 ID.AddBoolean(IsUnsigned);
7266 ID.AddInteger(NumBits);
7274 llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;
7282 Expr *getNumBitsExpr()
const;
7290 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
7291 bool IsUnsigned,
Expr *NumBitsExpr);
7307 addFastQualifiers(
type.getLocalFastQualifiers());
7308 if (!
type.hasLocalNonFastQualifiers())
7309 return type.getTypePtrUnsafe();
7354 Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
7359inline const Type *QualType::getTypePtr()
const {
7360 return getCommonPtr()->BaseType;
7363inline const Type *QualType::getTypePtrOrNull()
const {
7364 return (isNull() ?
nullptr : getCommonPtr()->BaseType);
7367inline bool QualType::isReferenceable()
const {
7371 const Type &Self = **
this;
7372 if (Self.isObjectType() || Self.isReferenceType())
7375 return F->getMethodQuals().empty() && F->getRefQualifier() ==
RQ_None;
7381 if (!hasLocalNonFastQualifiers())
7383 Qualifiers::fromFastMask(getLocalFastQualifiers()));
7385 const ExtQuals *eq = getExtQualsUnsafe();
7393 if (hasLocalNonFastQualifiers())
7394 Quals = getExtQualsUnsafe()->getQualifiers();
7400 Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
7405inline unsigned QualType::getCVRQualifiers()
const {
7406 unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
7407 cvr |= getLocalCVRQualifiers();
7412 QualType canon = getCommonPtr()->CanonicalType;
7416inline bool QualType::isCanonical()
const {
7420inline bool QualType::isCanonicalAsParam()
const {
7421 if (!isCanonical())
return false;
7422 if (hasLocalQualifiers())
return false;
7424 const Type *
T = getTypePtr();
7428 return !isa<FunctionType>(
T) &&
7429 (!isa<ArrayType>(
T) || isa<ArrayParameterType>(
T));
7432inline bool QualType::isConstQualified()
const {
7433 return isLocalConstQualified() ||
7434 getCommonPtr()->CanonicalType.isLocalConstQualified();
7437inline bool QualType::isRestrictQualified()
const {
7438 return isLocalRestrictQualified() ||
7439 getCommonPtr()->CanonicalType.isLocalRestrictQualified();
7443inline bool QualType::isVolatileQualified()
const {
7444 return isLocalVolatileQualified() ||
7445 getCommonPtr()->CanonicalType.isLocalVolatileQualified();
7448inline bool QualType::hasQualifiers()
const {
7449 return hasLocalQualifiers() ||
7450 getCommonPtr()->CanonicalType.hasLocalQualifiers();
7454 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
7457 return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
7461 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
7464 return getSplitUnqualifiedTypeImpl(*
this);
7467inline void QualType::removeLocalConst() {
7468 removeLocalFastQualifiers(Qualifiers::Const);
7471inline void QualType::removeLocalRestrict() {
7472 removeLocalFastQualifiers(Qualifiers::Restrict);
7475inline void QualType::removeLocalVolatile() {
7476 removeLocalFastQualifiers(Qualifiers::Volatile);
7480inline bool QualType::hasAddressSpace()
const {
7481 return getQualifiers().hasAddressSpace();
7485inline LangAS QualType::getAddressSpace()
const {
7486 return getQualifiers().getAddressSpace();
7491 return getQualifiers().getObjCGCAttr();
7494inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion()
const {
7495 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
7496 return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
7500inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion()
const {
7501 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
7502 return hasNonTrivialToPrimitiveDestructCUnion(RD);
7506inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion()
const {
7507 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
7508 return hasNonTrivialToPrimitiveCopyCUnion(RD);
7514 if (
const auto *FT = PT->getPointeeType()->getAs<
FunctionType>())
7515 return FT->getExtInfo();
7517 return FT->getExtInfo();
7531inline bool QualType::isMoreQualifiedThan(
QualType other)
const {
7541inline bool QualType::isAtLeastAsQualifiedAs(
QualType other)
const {
7545 if (getUnqualifiedType()->isVoidType())
7548 return getQualifiers().compatiblyIncludes(OtherQuals);
7567inline bool QualType::isCForbiddenLValueType()
const {
7568 return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
7569 getTypePtr()->isFunctionType());
7575inline bool Type::isFundamentalType()
const {
7576 return isVoidType() ||
7580 (isArithmeticType() && !isEnumeralType());
7586inline bool Type::isCompoundType()
const {
7590 return isArrayType() ||
7596 isReferenceType() ||
7605 isMemberPointerType();
7608inline bool Type::isFunctionType()
const {
7609 return isa<FunctionType>(CanonicalType);
7612inline bool Type::isPointerType()
const {
7613 return isa<PointerType>(CanonicalType);
7616inline bool Type::isAnyPointerType()
const {
7617 return isPointerType() || isObjCObjectPointerType();
7620inline bool Type::isBlockPointerType()
const {
7621 return isa<BlockPointerType>(CanonicalType);
7624inline bool Type::isReferenceType()
const {
7625 return isa<ReferenceType>(CanonicalType);
7628inline bool Type::isLValueReferenceType()
const {
7629 return isa<LValueReferenceType>(CanonicalType);
7632inline bool Type::isRValueReferenceType()
const {
7633 return isa<RValueReferenceType>(CanonicalType);
7636inline bool Type::isObjectPointerType()
const {
7640 if (
const auto *
T = getAs<PointerType>())
7646inline bool Type::isFunctionPointerType()
const {
7647 if (
const auto *
T = getAs<PointerType>())
7653inline bool Type::isFunctionReferenceType()
const {
7654 if (
const auto *
T = getAs<ReferenceType>())
7660inline bool Type::isMemberPointerType()
const {
7661 return isa<MemberPointerType>(CanonicalType);
7664inline bool Type::isMemberFunctionPointerType()
const {
7665 if (
const auto *
T = getAs<MemberPointerType>())
7666 return T->isMemberFunctionPointer();
7671inline bool Type::isMemberDataPointerType()
const {
7672 if (
const auto *
T = getAs<MemberPointerType>())
7673 return T->isMemberDataPointer();
7678inline bool Type::isArrayType()
const {
7679 return isa<ArrayType>(CanonicalType);
7682inline bool Type::isConstantArrayType()
const {
7683 return isa<ConstantArrayType>(CanonicalType);
7686inline bool Type::isIncompleteArrayType()
const {
7687 return isa<IncompleteArrayType>(CanonicalType);
7690inline bool Type::isVariableArrayType()
const {
7691 return isa<VariableArrayType>(CanonicalType);
7694inline bool Type::isArrayParameterType()
const {
7695 return isa<ArrayParameterType>(CanonicalType);
7698inline bool Type::isDependentSizedArrayType()
const {
7699 return isa<DependentSizedArrayType>(CanonicalType);
7702inline bool Type::isBuiltinType()
const {
7703 return isa<BuiltinType>(CanonicalType);
7706inline bool Type::isRecordType()
const {
7707 return isa<RecordType>(CanonicalType);
7710inline bool Type::isEnumeralType()
const {
7711 return isa<EnumType>(CanonicalType);
7714inline bool Type::isAnyComplexType()
const {
7715 return isa<ComplexType>(CanonicalType);
7718inline bool Type::isVectorType()
const {
7719 return isa<VectorType>(CanonicalType);
7722inline bool Type::isExtVectorType()
const {
7723 return isa<ExtVectorType>(CanonicalType);
7726inline bool Type::isExtVectorBoolType()
const {
7727 if (!isExtVectorType())
7729 return cast<ExtVectorType>(CanonicalType)->getElementType()->isBooleanType();
7732inline bool Type::isMatrixType()
const {
7733 return isa<MatrixType>(CanonicalType);
7736inline bool Type::isConstantMatrixType()
const {
7737 return isa<ConstantMatrixType>(CanonicalType);
7740inline bool Type::isDependentAddressSpaceType()
const {
7741 return isa<DependentAddressSpaceType>(CanonicalType);
7744inline bool Type::isObjCObjectPointerType()
const {
7745 return isa<ObjCObjectPointerType>(CanonicalType);
7748inline bool Type::isObjCObjectType()
const {
7749 return isa<ObjCObjectType>(CanonicalType);
7752inline bool Type::isObjCObjectOrInterfaceType()
const {
7753 return isa<ObjCInterfaceType>(CanonicalType) ||
7754 isa<ObjCObjectType>(CanonicalType);
7757inline bool Type::isAtomicType()
const {
7758 return isa<AtomicType>(CanonicalType);
7761inline bool Type::isUndeducedAutoType()
const {
7762 return isa<AutoType>(CanonicalType);
7765inline bool Type::isObjCQualifiedIdType()
const {
7766 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
7767 return OPT->isObjCQualifiedIdType();
7771inline bool Type::isObjCQualifiedClassType()
const {
7772 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
7773 return OPT->isObjCQualifiedClassType();
7777inline bool Type::isObjCIdType()
const {
7778 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
7779 return OPT->isObjCIdType();
7783inline bool Type::isObjCClassType()
const {
7784 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
7785 return OPT->isObjCClassType();
7789inline bool Type::isObjCSelType()
const {
7790 if (
const auto *OPT = getAs<PointerType>())
7791 return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
7795inline bool Type::isObjCBuiltinType()
const {
7796 return isObjCIdType() || isObjCClassType() || isObjCSelType();
7799inline bool Type::isDecltypeType()
const {
7800 return isa<DecltypeType>(
this);
7803#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7804 inline bool Type::is##Id##Type() const { \
7805 return isSpecificBuiltinType(BuiltinType::Id); \
7807#include "clang/Basic/OpenCLImageTypes.def"
7809inline bool Type::isSamplerT()
const {
7810 return isSpecificBuiltinType(BuiltinType::OCLSampler);
7813inline bool Type::isEventT()
const {
7814 return isSpecificBuiltinType(BuiltinType::OCLEvent);
7817inline bool Type::isClkEventT()
const {
7818 return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
7821inline bool Type::isQueueT()
const {
7822 return isSpecificBuiltinType(BuiltinType::OCLQueue);
7825inline bool Type::isReserveIDT()
const {
7826 return isSpecificBuiltinType(BuiltinType::OCLReserveID);
7829inline bool Type::isImageType()
const {
7830#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
7832#include "clang/Basic/OpenCLImageTypes.def"
7836inline bool Type::isPipeType()
const {
7837 return isa<PipeType>(CanonicalType);
7840inline bool Type::isBitIntType()
const {
7841 return isa<BitIntType>(CanonicalType);
7844#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7845 inline bool Type::is##Id##Type() const { \
7846 return isSpecificBuiltinType(BuiltinType::Id); \
7848#include "clang/Basic/OpenCLExtensionTypes.def"
7850inline bool Type::isOCLIntelSubgroupAVCType()
const {
7851#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
7852 isOCLIntelSubgroupAVC##Id##Type() ||
7854#include "clang/Basic/OpenCLExtensionTypes.def"
7858inline bool Type::isOCLExtOpaqueType()
const {
7859#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
7861#include "clang/Basic/OpenCLExtensionTypes.def"
7865inline bool Type::isOpenCLSpecificType()
const {
7866 return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
7867 isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
7870inline bool Type::isTemplateTypeParmType()
const {
7871 return isa<TemplateTypeParmType>(CanonicalType);
7874inline bool Type::isSpecificBuiltinType(
unsigned K)
const {
7875 if (
const BuiltinType *BT = getAs<BuiltinType>()) {
7881inline bool Type::isPlaceholderType()
const {
7882 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
7883 return BT->isPlaceholderType();
7888 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
7889 if (BT->isPlaceholderType())
7894inline bool Type::isSpecificPlaceholderType(
unsigned K)
const {
7896 return isSpecificBuiltinType(K);
7899inline bool Type::isNonOverloadPlaceholderType()
const {
7900 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
7901 return BT->isNonOverloadPlaceholderType();
7905inline bool Type::isVoidType()
const {
7906 return isSpecificBuiltinType(BuiltinType::Void);
7909inline bool Type::isHalfType()
const {
7911 return isSpecificBuiltinType(BuiltinType::Half);
7914inline bool Type::isFloat16Type()
const {
7915 return isSpecificBuiltinType(BuiltinType::Float16);
7918inline bool Type::isFloat32Type()
const {
7919 return isSpecificBuiltinType(BuiltinType::Float);
7922inline bool Type::isDoubleType()
const {
7923 return isSpecificBuiltinType(BuiltinType::Double);
7926inline bool Type::isBFloat16Type()
const {
7927 return isSpecificBuiltinType(BuiltinType::BFloat16);
7930inline bool Type::isFloat128Type()
const {
7931 return isSpecificBuiltinType(BuiltinType::Float128);
7934inline bool Type::isIbm128Type()
const {
7935 return isSpecificBuiltinType(BuiltinType::Ibm128);
7938inline bool Type::isNullPtrType()
const {
7939 return isSpecificBuiltinType(BuiltinType::NullPtr);
7945inline bool Type::isIntegerType()
const {
7946 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
7947 return BT->getKind() >= BuiltinType::Bool &&
7948 BT->getKind() <= BuiltinType::Int128;
7949 if (
const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
7955 return isBitIntType();
7958inline bool Type::isFixedPointType()
const {
7959 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7960 return BT->getKind() >= BuiltinType::ShortAccum &&
7961 BT->getKind() <= BuiltinType::SatULongFract;
7966inline bool Type::isFixedPointOrIntegerType()
const {
7967 return isFixedPointType() || isIntegerType();
7970inline bool Type::isConvertibleToFixedPointType()
const {
7971 return isRealFloatingType() || isFixedPointOrIntegerType();
7974inline bool Type::isSaturatedFixedPointType()
const {
7975 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7976 return BT->getKind() >= BuiltinType::SatShortAccum &&
7977 BT->getKind() <= BuiltinType::SatULongFract;
7982inline bool Type::isUnsaturatedFixedPointType()
const {
7983 return isFixedPointType() && !isSaturatedFixedPointType();
7986inline bool Type::isSignedFixedPointType()
const {
7987 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7988 return ((BT->getKind() >= BuiltinType::ShortAccum &&
7989 BT->getKind() <= BuiltinType::LongAccum) ||
7990 (BT->getKind() >= BuiltinType::ShortFract &&
7991 BT->getKind() <= BuiltinType::LongFract) ||
7992 (BT->getKind() >= BuiltinType::SatShortAccum &&
7993 BT->getKind() <= BuiltinType::SatLongAccum) ||
7994 (BT->getKind() >= BuiltinType::SatShortFract &&
7995 BT->getKind() <= BuiltinType::SatLongFract));
8000inline bool Type::isUnsignedFixedPointType()
const {
8001 return isFixedPointType() && !isSignedFixedPointType();
8004inline bool Type::isScalarType()
const {
8005 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8006 return BT->getKind() > BuiltinType::Void &&
8007 BT->getKind() <= BuiltinType::NullPtr;
8008 if (
const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
8012 return isa<PointerType>(CanonicalType) ||
8013 isa<BlockPointerType>(CanonicalType) ||
8014 isa<MemberPointerType>(CanonicalType) ||
8015 isa<ComplexType>(CanonicalType) ||
8016 isa<ObjCObjectPointerType>(CanonicalType) ||
8020inline bool Type::isIntegralOrEnumerationType()
const {
8021 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8022 return BT->getKind() >= BuiltinType::Bool &&
8023 BT->getKind() <= BuiltinType::Int128;
8027 if (
const auto *ET = dyn_cast<EnumType>(CanonicalType))
8030 return isBitIntType();
8033inline bool Type::isBooleanType()
const {
8034 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8035 return BT->getKind() == BuiltinType::Bool;
8039inline bool Type::isUndeducedType()
const {
8040 auto *DT = getContainedDeducedType();
8041 return DT && !DT->isDeduced();
8046inline bool Type::isOverloadableType()
const {
8047 if (!CanonicalType->isDependentType())
8049 return !isArrayType() && !isFunctionType() && !isAnyPointerType() &&
8050 !isMemberPointerType();
8054inline bool Type::isTypedefNameType()
const {
8055 if (getAs<TypedefType>())
8057 if (
auto *TST = getAs<TemplateSpecializationType>())
8058 return TST->isTypeAlias();
8063inline bool Type::canDecayToPointerType()
const {
8064 return isFunctionType() || (isArrayType() && !isArrayParameterType());
8067inline bool Type::hasPointerRepresentation()
const {
8068 return (isPointerType() || isReferenceType() || isBlockPointerType() ||
8069 isObjCObjectPointerType() || isNullPtrType());
8072inline bool Type::hasObjCPointerRepresentation()
const {
8073 return isObjCObjectPointerType();
8076inline const Type *Type::getBaseElementTypeUnsafe()
const {
8083inline const Type *Type::getPointeeOrArrayElementType()
const {
8085 if (
type->isAnyPointerType())
8086 return type->getPointeeType().getTypePtr();
8087 else if (
type->isArrayType())
8088 return type->getBaseElementTypeUnsafe();
8096 DiagnosticsEngine::ArgumentKind::ak_addrspace);
8105 DiagnosticsEngine::ArgumentKind::ak_qual);
8113 PD.
AddTaggedVal(
reinterpret_cast<uint64_t
>(
T.getAsOpaquePtr()),
8114 DiagnosticsEngine::ak_qualtype);
8120template <
typename T>
8122 std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
8123 std::is_base_of<ArrayType, T>::value>;
8126template <
typename T>
const T *Type::getAs()
const {
8128 "ArrayType cannot be used with getAs!");
8131 if (
const auto *Ty = dyn_cast<T>(
this))
8135 if (!isa<T>(CanonicalType))
8140 return cast<T>(getUnqualifiedDesugaredType());
8143template <
typename T>
const T *Type::getAsAdjusted()
const {
8147 if (
const auto *Ty = dyn_cast<T>(
this))
8151 if (!isa<T>(CanonicalType))
8156 const Type *Ty =
this;
8158 if (
const auto *A = dyn_cast<AttributedType>(Ty))
8159 Ty = A->getModifiedType().getTypePtr();
8160 else if (
const auto *A = dyn_cast<BTFTagAttributedType>(Ty))
8161 Ty = A->getWrappedType().getTypePtr();
8162 else if (
const auto *E = dyn_cast<ElaboratedType>(Ty))
8163 Ty = E->desugar().getTypePtr();
8164 else if (
const auto *
P = dyn_cast<ParenType>(Ty))
8165 Ty =
P->desugar().getTypePtr();
8166 else if (
const auto *A = dyn_cast<AdjustedType>(Ty))
8167 Ty = A->desugar().getTypePtr();
8168 else if (
const auto *M = dyn_cast<MacroQualifiedType>(Ty))
8169 Ty = M->desugar().getTypePtr();
8176 return dyn_cast<T>(Ty);
8181 if (
const auto *arr = dyn_cast<ArrayType>(
this))
8185 if (!isa<ArrayType>(CanonicalType))
8190 return cast<ArrayType>(getUnqualifiedDesugaredType());
8193template <
typename T>
const T *Type::castAs()
const {
8195 "ArrayType cannot be used with castAs!");
8197 if (
const auto *ty = dyn_cast<T>(
this))
return ty;
8198 assert(isa<T>(CanonicalType));
8199 return cast<T>(getUnqualifiedDesugaredType());
8202inline const ArrayType *Type::castAsArrayTypeUnsafe()
const {
8203 assert(isa<ArrayType>(CanonicalType));
8204 if (
const auto *arr = dyn_cast<ArrayType>(
this))
return arr;
8205 return cast<ArrayType>(getUnqualifiedDesugaredType());
8210 :
AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
8212 QualType Adjusted = getAdjustedType();
8214 assert(isa<PointerType>(Adjusted));
8221 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.
ArrayRef< TemplateArgument > getTypeConstraintArguments() const
static bool classof(const Type *T)
bool isDecltypeAuto() const
ConceptDecl * getTypeConstraintConcept() const
AutoTypeKeyword getKeyword() const
bool isGNUAutoType() const
bool isConstrained() const
static bool classof(const Type *T)
const BTFTypeTagAttr * getAttr() const
QualType getWrappedType() const
void Profile(llvm::FoldingSetNodeID &ID)
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.
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.
const char * getNameAsCString(const PrintingPolicy &Policy) const
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)
bool isCountInBytes() const
Expr * getCountExpr() 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).
static bool classof(const Type *T)
Expr * getUnderlyingExpr() const
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.
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
static bool classof(const Type *T)
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
void Profile(llvm::FoldingSetNodeID &ID)
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
Expr * getSizeExpr() const
SourceLocation getLBracketLoc() 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 * getColumnExpr() const
Expr * getRowExpr() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
SourceLocation getAttributeLoc() const
static bool classof(const Type *T)
Represents a template specialization type whose template cannot be resolved, e.g.
const IdentifierInfo * getIdentifier() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
ArrayRef< TemplateArgument > template_arguments() const
NestedNameSpecifier * getQualifier() 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)
TagDecl * getOwnedTagDecl() const
Return the (re)declaration of this type owned by this occurrence of this type, or nullptr if there is...
QualType desugar() const
Remove a single level of sugar.
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl)
bool isSugared() const
Returns whether this type directly provides sugar.
void Profile(llvm::FoldingSetNodeID &ID)
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.
EnumDecl * getDecl() const
static bool classof(const Type *T)
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
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
const Type * getBaseType() 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
ExtParameterInfo getExtParameterInfo(unsigned I) const
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
bool isParamConsumed(unsigned I) const
exception_iterator exception_end() const
const ExtParameterInfo * getExtParameterInfosOrNull() const
Return a pointer to the beginning of the array of extra parameter information, if present,...
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
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.
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
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
param_type_iterator param_type_end() const
FunctionDecl * getExceptionSpecTemplate() const
If this function type has an uninstantiated exception specification, this is the function whose excep...
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > exceptions() const
ParameterABI getParameterABI(unsigned I) const
ArrayRef< QualType > param_types() const
exception_iterator exception_begin() const
ArrayRef< ExtParameterInfo > getExtParameterInfos() 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.
FunctionDecl * getExceptionSpecDecl() const
If this function type has an exception specification which hasn't been determined yet (either because...
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)
const TemplateSpecializationType * getInjectedTST() const
TemplateName getTemplateName() const
QualType getInjectedSpecializationType() 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.
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)
const Type * getClass() const
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)
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...
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments for this type.
void Profile(llvm::FoldingSetNodeID &ID)
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
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)
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.
ObjCProtocolDecl * getProtocol(unsigned I) const
Retrieve a qualifying protocol by index on the object type.
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
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,.
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments for this type.
qual_iterator qual_begin() const
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.
bool isKindOfTypeAsWritten() const
Whether this is a "__kindof" type as written.
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were 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)
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
void initialize(ArrayRef< ObjCProtocolDecl * > protocols)
ObjCProtocolDecl ** getProtocolStorage()
ArrayRef< ObjCProtocolDecl * > getProtocols() const
Retrieve all of the protocol qualifiers.
unsigned getNumProtocols() const
Return the number of qualifying protocols in this type, or 0 if there are none.
void setNumProtocols(unsigned N)
qual_iterator qual_end() const
ObjCProtocolDecl *const * getProtocolStorage() const
ObjCProtocolDecl * getProtocol(unsigned I) const
Fetch a protocol by index.
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.
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...
std::optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
bool hasSelectedType() const
QualType getPattern() const
void Profile(llvm::FoldingSetNodeID &ID)
QualType getSelectedType() const
ArrayRef< QualType > getExpansions() const
Expr * getIndexExpr() 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)
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
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)
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.
const Type * operator->() const
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
void * getAsOpaquePtr() 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.
const Type & operator*() const
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)
void addAddressSpace(LangAS space)
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)
Qualifiers & operator+=(Qualifiers R)
void removeFastQualifiers()
bool hasQualifiers() const
Return true if the set contains any qualifiers.
void removeCVRQualifiers()
Qualifiers withVolatile() const
void addCVRUQualifiers(unsigned mask)
Qualifiers & operator-=(Qualifiers R)
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
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 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...
RecordType(const RecordDecl *D)
RecordDecl * getDecl() const
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.
void Profile(llvm::FoldingSetNodeID &ID)
static bool classof(const Type *T)
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
std::optional< unsigned > getPackIndex() const
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.
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.
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)
TypeOfKind getKind() const
Returns the kind of 'typeof' type this is.
Expr * getUnderlyingExpr() const
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.
TypedefBitfields TypedefBits
bool isBooleanType() const
Type(const Type &)=delete
ReferenceTypeBitfields ReferenceTypeBits
ElaboratedTypeBitfields ElaboratedTypeBits
ArrayTypeBitfields ArrayTypeBits
VectorTypeBitfields VectorTypeBits
TypeWithKeywordBitfields TypeWithKeywordBits
TypeOfBitfields TypeOfBits
const T * castAs() const
Member-template castAs<specific type>.
BuiltinTypeBitfields BuiltinTypeBits
bool isReferenceType() 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)
CountAttributedTypeBitfields CountAttributedTypeBits
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Type & operator=(const Type &)=delete
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
DependentTemplateSpecializationTypeBitfields DependentTemplateSpecializationTypeBits
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
QualType getCanonicalTypeInternal() const
bool containsErrors() const
Whether this type is an error type.
AttributedTypeBitfields AttributedTypeBits
bool isFunctionProtoType() const
PackExpansionTypeBitfields PackExpansionTypeBits
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isFromAST() const
Whether this type comes from an AST file.
bool isObjectType() const
Determine whether this type is an object type.
FunctionTypeBitfields FunctionTypeBits
void setDependence(TypeDependence D)
bool isFunctionType() const
SubstTemplateTypeParmTypeBitfields SubstTemplateTypeParmTypeBits
TypeDependence getDependence() const
Visibility getVisibility() const
Determine the visibility of this type.
bool isObjCInertUnsafeUnretainedType() const
Was this type written with the special inert-in-ARC __unsafe_unretained qualifier?
ObjCObjectTypeBitfields ObjCObjectTypeBits
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.
const T * getAs() const
Member-template getAs<specific type>'.
SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits
TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits
bool isFunctionNoProtoType() const
AutoTypeBitfields AutoTypeBits
Type & operator=(Type &&)=delete
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)
UnresolvedUsingTypenameDecl * getDecl() const
static bool classof(const Type *T)
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)
static void Profile(llvm::FoldingSetNodeID &ID, const UsingShadowDecl *Found, QualType Underlying)
static bool classof(const Type *T)
UsingShadowDecl * getFoundDecl() const
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)
Expr * getSizeExpr() const
SourceLocation getRBracketLoc() 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.
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.
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.
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.
@ 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.
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)
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
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.
@ 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...
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)
std::pair< const Type *, Qualifiers > asPair() const
Qualifiers Quals
The local qualifiers.
static inline ::clang::ExtQuals * getFromVoidPointer(void *P)
static void * getAsVoidPointer(::clang::ExtQuals *P)
static void * getAsVoidPointer(::clang::Type *P)
static inline ::clang::Type * getFromVoidPointer(void *P)
static void * getAsVoidPointer(clang::QualType P)
static clang::QualType getFromVoidPointer(void *P)
static SimpleType getSimplifiedValue(::clang::QualType Val)