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;
121class FunctionEffectSet;
124class ObjCInterfaceDecl;
125class ObjCProtocolDecl;
126class ObjCTypeParamDecl;
127struct PrintingPolicy;
131class TemplateArgument;
132class TemplateArgumentListInfo;
133class TemplateArgumentLoc;
134class TemplateTypeParmDecl;
135class TypedefNameDecl;
136class UnresolvedUsingTypenameDecl;
137class UsingShadowDecl;
142#define TYPE(Class, Base) class Class##Type;
143#include "clang/AST/TypeNodes.inc"
150 EnabledMask = 1 << EnabledShift,
151 AddressDiscriminatedShift = EnabledShift + EnabledBits,
152 AddressDiscriminatedBits = 1,
153 AddressDiscriminatedMask = 1 << AddressDiscriminatedShift,
154 AuthenticationModeShift =
155 AddressDiscriminatedShift + AddressDiscriminatedBits,
156 AuthenticationModeBits = 2,
157 AuthenticationModeMask = ((1 << AuthenticationModeBits) - 1)
158 << AuthenticationModeShift,
159 IsaPointerShift = AuthenticationModeShift + AuthenticationModeBits,
161 IsaPointerMask = ((1 << IsaPointerBits) - 1) << IsaPointerShift,
162 AuthenticatesNullValuesShift = IsaPointerShift + IsaPointerBits,
163 AuthenticatesNullValuesBits = 1,
164 AuthenticatesNullValuesMask = ((1 << AuthenticatesNullValuesBits) - 1)
165 << AuthenticatesNullValuesShift,
166 KeyShift = AuthenticatesNullValuesShift + AuthenticatesNullValuesBits,
168 KeyMask = ((1 << KeyBits) - 1) << KeyShift,
169 DiscriminatorShift = KeyShift + KeyBits,
170 DiscriminatorBits = 16,
171 DiscriminatorMask = ((1u << DiscriminatorBits) - 1) << DiscriminatorShift,
182 static_assert((EnabledBits + AddressDiscriminatedBits +
183 AuthenticationModeBits + IsaPointerBits +
184 AuthenticatesNullValuesBits + KeyBits + DiscriminatorBits) ==
186 "PointerAuthQualifier should be exactly 32 bits");
187 static_assert((EnabledMask + AddressDiscriminatedMask +
188 AuthenticationModeMask + IsaPointerMask +
189 AuthenticatesNullValuesMask + KeyMask + DiscriminatorMask) ==
191 "All masks should cover the entire bits");
192 static_assert((EnabledMask ^ AddressDiscriminatedMask ^
193 AuthenticationModeMask ^ IsaPointerMask ^
194 AuthenticatesNullValuesMask ^ KeyMask ^ DiscriminatorMask) ==
196 "All masks should cover the entire bits");
199 unsigned ExtraDiscriminator,
201 bool IsIsaPointer,
bool AuthenticatesNullValues)
203 (IsAddressDiscriminated
204 ? llvm::to_underlying(AddressDiscriminatedMask)
207 (llvm::to_underlying(AuthenticationMode)
208 << AuthenticationModeShift) |
209 (ExtraDiscriminator << DiscriminatorShift) |
210 (IsIsaPointer << IsaPointerShift) |
211 (AuthenticatesNullValues << AuthenticatesNullValuesShift)) {
214 assert((
Data == 0) ==
233 Create(
unsigned Key,
bool IsAddressDiscriminated,
unsigned ExtraDiscriminator,
235 bool AuthenticatesNullValues) {
240 AuthenticationMode, IsIsaPointer,
241 AuthenticatesNullValues);
245 assert((
Data == 0) ==
254 return (
Data & KeyMask) >> KeyShift;
261 return (
Data & AddressDiscriminatedMask) >> AddressDiscriminatedShift;
266 return (
Data >> DiscriminatorShift);
271 AuthenticationModeShift);
276 return (
Data & IsaPointerMask) >> IsaPointerShift;
281 return (
Data & AuthenticatesNullValuesMask) >> AuthenticatesNullValuesShift;
289 return Lhs.Data == Rhs.Data;
292 return Lhs.Data != Rhs.Data;
305 assert((
Result.Data == 0) ==
385 Q.Mask = L.Mask & R.Mask;
479 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
480 Mask = (Mask & ~CVRMask) | mask;
483 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
484 Mask &= ~static_cast<uint64_t>(mask);
490 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
494 assert(!(mask & ~
CVRMask & ~UMask) &&
"bitmask contains non-CVRU bits");
500 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
508 Mask = (Mask & ~GCAttrMask) | (
type << GCAttrShift);
533 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
536 Mask = (Mask & ~LifetimeMask) | (
type << LifetimeShift);
542 Mask |= (
type << LifetimeShift);
559 return static_cast<LangAS>(Mask >> AddressSpaceShift);
580 Mask = (Mask & ~AddressSpaceMask)
581 | (((uint32_t) space) << AddressSpaceShift);
594 Mask = (Mask & ~PtrAuthMask) |
608 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
609 Mask = (Mask & ~FastMask) | mask;
612 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
613 Mask &= ~static_cast<uint64_t>(mask);
619 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
634 bool empty()
const {
return !Mask; }
807 bool appendSpaceIfNonEmpty =
false)
const;
809 void Profile(llvm::FoldingSetNodeID &
ID)
const {
ID.AddInteger(Mask); }
816 "PointerAuthQualifier must be 32 bits");
818 static constexpr uint64_t UMask = 0x8;
819 static constexpr uint64_t UShift = 3;
820 static constexpr uint64_t GCAttrMask = 0x30;
821 static constexpr uint64_t GCAttrShift = 4;
822 static constexpr uint64_t LifetimeMask = 0x1C0;
823 static constexpr uint64_t LifetimeShift = 6;
824 static constexpr uint64_t AddressSpaceMask =
825 ~(
CVRMask | UMask | GCAttrMask | LifetimeMask);
826 static constexpr uint64_t AddressSpaceShift = 9;
827 static constexpr uint64_t PtrAuthShift = 32;
828 static constexpr uint64_t PtrAuthMask = uint64_t(0xffffffff) << PtrAuthShift;
838 : Quals(Quals), HasAtomic(HasAtomic) {}
887 std::pair<const Type *,Qualifiers>
asPair()
const {
888 return std::pair<const Type *, Qualifiers>(
Ty,
Quals);
892 return a.
Ty ==
b.Ty && a.
Quals ==
b.Quals;
895 return a.
Ty !=
b.Ty || a.
Quals !=
b.Quals;
945 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
948 const ExtQuals *getExtQualsUnsafe()
const {
952 const Type *getTypePtrUnsafe()
const {
953 return Value.getPointer().get<
const Type*>();
956 const ExtQualsTypeCommonBase *getCommonPtr()
const {
957 assert(!
isNull() &&
"Cannot retrieve a NULL type pointer");
958 auto CommonPtrVal =
reinterpret_cast<uintptr_t>(
Value.getOpaqueValue());
960 return reinterpret_cast<ExtQualsTypeCommonBase*
>(CommonPtrVal);
992 T.Value.setFromOpaqueValue(
const_cast<void*
>(Ptr));
1009 return Value.getPointer().isNull();
1036 std::optional<NonConstantStorageReason>
1192 &&
"non-fast qualifier bits set in mask!");
1210 T.addFastQualifiers(TQs);
1223 T.removeLocalFastQualifiers();
1317 return getSingleStepDesugaredTypeImpl(*
this, Context);
1323 if (isa<ParenType>(*
this))
1330 return LHS.Value == RHS.Value;
1333 return LHS.Value != RHS.Value;
1336 return LHS.Value < RHS.Value;
1350 const Twine &PlaceHolder = Twine(),
1351 unsigned Indentation = 0)
const;
1355 unsigned Indentation = 0) {
1361 const Twine &PlaceHolder,
1362 unsigned Indentation = 0);
1379 const Twine &PlaceHolder;
1380 unsigned Indentation;
1384 const Twine &PlaceHolder,
unsigned Indentation)
1385 :
T(
T), Policy(Policy), PlaceHolder(PlaceHolder),
1386 Indentation(Indentation) {}
1390 SQT.T.
print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1396 const Twine &PlaceHolder = Twine(),
1397 unsigned Indentation = 0)
const {
1401 void dump(
const char *
s)
const;
1403 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
1543 return isDestructedTypeImpl(*
this);
1645raw_ostream &
operator<<(raw_ostream &OS, QualType QT);
1665 return P.getAsOpaquePtr();
1673 static constexpr int NumLowBitsAvailable = 0;
1693 const Type *
const BaseType;
1699 : BaseType(baseType), CanonicalType(canon) {}
1713 public llvm::FoldingSetNode {
1736 canon.isNull() ?
QualType(this_(), 0) : canon),
1738 assert(Quals.hasNonFastQualifiers()
1739 &&
"ExtQuals created with no fast qualifiers");
1740 assert(!Quals.hasFastQualifiers()
1741 &&
"ExtQuals created with fast qualifiers");
1751 return Quals.getObjCLifetime();
1761 Profile(
ID, getBaseType(), Quals);
1765 const Type *BaseType,
1768 ID.AddPointer(BaseType);
1799enum class ArraySizeModifier;
1800enum class ElaboratedTypeKeyword;
1801enum class VectorKind;
1832#define TYPE(Class, Base) Class,
1833#define LAST_TYPE(Class) TypeLast = Class
1834#define ABSTRACT_TYPE(Class, Base)
1835#include "clang/AST/TypeNodes.inc"
1840 class TypeBitfields {
1842 template <
class T>
friend class TypePropertyCache;
1845 LLVM_PREFERRED_TYPE(TypeClass)
1850 unsigned Dependence : llvm::BitWidth<TypeDependence>;
1854 LLVM_PREFERRED_TYPE(
bool)
1855 mutable unsigned CacheValid : 1;
1859 mutable unsigned CachedLinkage : 3;
1862 LLVM_PREFERRED_TYPE(
bool)
1863 mutable unsigned CachedLocalOrUnnamed : 1;
1866 LLVM_PREFERRED_TYPE(
bool)
1867 mutable unsigned FromAST : 1;
1869 bool isCacheValid()
const {
1874 assert(isCacheValid() &&
"getting linkage from invalid cache");
1875 return static_cast<Linkage>(CachedLinkage);
1878 bool hasLocalOrUnnamedType()
const {
1879 assert(isCacheValid() &&
"getting linkage from invalid cache");
1880 return CachedLocalOrUnnamed;
1883 enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
1892 LLVM_PREFERRED_TYPE(TypeBitfields)
1898 unsigned IndexTypeQuals : 3;
1903 unsigned SizeModifier : 3;
1905 enum { NumArrayTypeBits = NumTypeBits + 6 };
1914 LLVM_PREFERRED_TYPE(
bool)
1915 unsigned HasExternalSize : 1;
1917 LLVM_PREFERRED_TYPE(
unsigned)
1918 unsigned SizeWidth : 5;
1924 LLVM_PREFERRED_TYPE(TypeBitfields)
1928 static constexpr unsigned NumOfBuiltinTypeBits = 9;
1929 unsigned Kind : NumOfBuiltinTypeBits;
1939 LLVM_PREFERRED_TYPE(TypeBitfields)
1945 unsigned ExtInfo : 13;
1951 unsigned RefQualifier : 2;
1960 unsigned FastTypeQuals : Qualifiers::FastWidth;
1962 LLVM_PREFERRED_TYPE(
bool)
1963 unsigned HasExtQuals : 1;
1969 unsigned NumParams : 16;
1973 unsigned ExceptionSpecType : 4;
1976 LLVM_PREFERRED_TYPE(
bool)
1977 unsigned HasExtParameterInfos : 1;
1980 LLVM_PREFERRED_TYPE(
bool)
1981 unsigned HasExtraBitfields : 1;
1984 LLVM_PREFERRED_TYPE(
bool)
1985 unsigned Variadic : 1;
1988 LLVM_PREFERRED_TYPE(
bool)
1989 unsigned HasTrailingReturn : 1;
1995 LLVM_PREFERRED_TYPE(TypeBitfields)
1999 unsigned NumTypeArgs : 7;
2002 unsigned NumProtocols : 6;
2005 LLVM_PREFERRED_TYPE(
bool)
2006 unsigned IsKindOf : 1;
2012 LLVM_PREFERRED_TYPE(TypeBitfields)
2026 LLVM_PREFERRED_TYPE(
bool)
2027 unsigned SpelledAsLValue : 1;
2031 LLVM_PREFERRED_TYPE(
bool)
2032 unsigned InnerRef : 1;
2038 LLVM_PREFERRED_TYPE(TypeBitfields)
2043 unsigned Keyword : 8;
2046 enum { NumTypeWithKeywordBits = NumTypeBits + 8 };
2055 LLVM_PREFERRED_TYPE(
bool)
2056 unsigned HasOwnedTagDecl : 1;
2063 LLVM_PREFERRED_TYPE(TypeBitfields)
2069 unsigned VecKind : 4;
2071 uint32_t NumElements;
2077 LLVM_PREFERRED_TYPE(TypeBitfields)
2081 unsigned AttrKind : 32 - NumTypeBits;
2087 LLVM_PREFERRED_TYPE(TypeBitfields)
2093 unsigned Keyword : 2;
2109 LLVM_PREFERRED_TYPE(TypeBitfields)
2118 LLVM_PREFERRED_TYPE(TypeBitfields)
2122 LLVM_PREFERRED_TYPE(
bool)
2123 unsigned hasTypeDifferentFromDecl : 1;
2129 LLVM_PREFERRED_TYPE(TypeBitfields)
2133 LLVM_PREFERRED_TYPE(
bool)
2134 unsigned hasTypeDifferentFromDecl : 1;
2140 LLVM_PREFERRED_TYPE(TypeBitfields)
2143 LLVM_PREFERRED_TYPE(
bool)
2144 unsigned HasNonCanonicalUnderlyingType : 1;
2147 unsigned Index : 15;
2154 unsigned PackIndex : 16;
2160 LLVM_PREFERRED_TYPE(TypeBitfields)
2164 unsigned Index : 16;
2170 unsigned NumArgs : 16;
2176 LLVM_PREFERRED_TYPE(TypeBitfields)
2180 LLVM_PREFERRED_TYPE(
bool)
2181 unsigned TypeAlias : 1;
2212 LLVM_PREFERRED_TYPE(TypeBitfields)
2226 unsigned NumExpansions;
2232 LLVM_PREFERRED_TYPE(TypeBitfields)
2235 static constexpr unsigned NumCoupledDeclsBits = 4;
2236 unsigned NumCoupledDecls : NumCoupledDeclsBits;
2237 LLVM_PREFERRED_TYPE(
bool)
2238 unsigned CountInBytes : 1;
2239 LLVM_PREFERRED_TYPE(
bool)
2240 unsigned OrNull : 1;
2273 void setFromAST(
bool V =
true)
const {
2274 TypeBits.FromAST =
V;
2282 canon.isNull() ?
QualType(this_(), 0) : canon) {
2283 static_assert(
sizeof(*this) <=
2285 "changing bitfields changed sizeof(Type)!");
2286 static_assert(
alignof(
decltype(*this)) %
TypeAlignment == 0,
2287 "Insufficient alignment!");
2289 TypeBits.Dependence =
static_cast<unsigned>(
Dependence);
2290 TypeBits.CacheValid =
false;
2291 TypeBits.CachedLocalOrUnnamed =
false;
2292 TypeBits.CachedLinkage = llvm::to_underlying(Linkage::Invalid);
2293 TypeBits.FromAST =
false;
2300 TypeBits.Dependence =
static_cast<unsigned>(
D);
2337 return getDependence() & TypeDependence::UnexpandedPack;
2343 return CanonicalType ==
QualType(
this, 0);
2349 QualType getLocallyUnqualifiedSingleStepDesugaredType()
const;
2357 bool isSizelessType()
const;
2358 bool isSizelessBuiltinType()
const;
2361 bool isSizelessVectorType()
const;
2364 bool isSVESizelessBuiltinType()
const;
2367 bool isRVVSizelessBuiltinType()
const;
2370 bool isWebAssemblyExternrefType()
const;
2375 bool isWebAssemblyTableType()
const;
2380 bool isSveVLSBuiltinType()
const;
2390 bool isRVVVLSBuiltinType()
const;
2412 bool isIncompleteType(
NamedDecl **Def =
nullptr)
const;
2417 return !isFunctionType();
2425 return !isReferenceType() && !isFunctionType() && !isVoidType();
2430 bool isLiteralType(
const ASTContext &Ctx)
const;
2433 bool isStructuralType()
const;
2437 bool isStandardLayoutType()
const;
2443 bool isBuiltinType()
const;
2446 bool isSpecificBuiltinType(
unsigned K)
const;
2451 bool isPlaceholderType()
const;
2455 bool isSpecificPlaceholderType(
unsigned K)
const;
2459 bool isNonOverloadPlaceholderType()
const;
2463 bool isIntegerType()
const;
2464 bool isEnumeralType()
const;
2467 bool isScopedEnumeralType()
const;
2469 bool isCharType()
const;
2470 bool isWideCharType()
const;
2471 bool isChar8Type()
const;
2472 bool isChar16Type()
const;
2473 bool isChar32Type()
const;
2474 bool isAnyCharacterType()
const;
2475 bool isIntegralType(
const ASTContext &Ctx)
const;
2478 bool isIntegralOrEnumerationType()
const;
2481 bool isIntegralOrUnscopedEnumerationType()
const;
2482 bool isUnscopedEnumerationType()
const;
2485 bool isRealFloatingType()
const;
2488 bool isComplexType()
const;
2489 bool isAnyComplexType()
const;
2490 bool isFloatingType()
const;
2491 bool isHalfType()
const;
2492 bool isFloat16Type()
const;
2493 bool isFloat32Type()
const;
2494 bool isDoubleType()
const;
2495 bool isBFloat16Type()
const;
2496 bool isFloat128Type()
const;
2497 bool isIbm128Type()
const;
2498 bool isRealType()
const;
2499 bool isArithmeticType()
const;
2500 bool isVoidType()
const;
2501 bool isScalarType()
const;
2502 bool isAggregateType()
const;
2503 bool isFundamentalType()
const;
2504 bool isCompoundType()
const;
2508 bool isFunctionType()
const;
2511 bool isPointerType()
const;
2512 bool isSignableType()
const;
2513 bool isAnyPointerType()
const;
2514 bool isCountAttributedType()
const;
2515 bool isBlockPointerType()
const;
2516 bool isVoidPointerType()
const;
2517 bool isReferenceType()
const;
2518 bool isLValueReferenceType()
const;
2519 bool isRValueReferenceType()
const;
2520 bool isObjectPointerType()
const;
2521 bool isFunctionPointerType()
const;
2522 bool isFunctionReferenceType()
const;
2523 bool isMemberPointerType()
const;
2524 bool isMemberFunctionPointerType()
const;
2525 bool isMemberDataPointerType()
const;
2526 bool isArrayType()
const;
2527 bool isConstantArrayType()
const;
2528 bool isIncompleteArrayType()
const;
2529 bool isVariableArrayType()
const;
2530 bool isArrayParameterType()
const;
2531 bool isDependentSizedArrayType()
const;
2533 bool isClassType()
const;
2534 bool isStructureType()
const;
2535 bool isStructureTypeWithFlexibleArrayMember()
const;
2536 bool isObjCBoxableRecordType()
const;
2537 bool isInterfaceType()
const;
2538 bool isStructureOrClassType()
const;
2539 bool isUnionType()
const;
2540 bool isComplexIntegerType()
const;
2541 bool isVectorType()
const;
2542 bool isExtVectorType()
const;
2543 bool isExtVectorBoolType()
const;
2544 bool isSubscriptableVectorType()
const;
2545 bool isMatrixType()
const;
2546 bool isConstantMatrixType()
const;
2547 bool isDependentAddressSpaceType()
const;
2548 bool isObjCObjectPointerType()
const;
2549 bool isObjCRetainableType()
const;
2550 bool isObjCLifetimeType()
const;
2551 bool isObjCIndirectLifetimeType()
const;
2552 bool isObjCNSObjectType()
const;
2553 bool isObjCIndependentClassType()
const;
2556 bool isObjCObjectType()
const;
2557 bool isObjCQualifiedInterfaceType()
const;
2558 bool isObjCQualifiedIdType()
const;
2559 bool isObjCQualifiedClassType()
const;
2560 bool isObjCObjectOrInterfaceType()
const;
2561 bool isObjCIdType()
const;
2562 bool isDecltypeType()
const;
2570 return hasAttr(attr::ObjCInertUnsafeUnretained);
2580 bool isObjCIdOrObjectKindOfType(
const ASTContext &ctx,
2583 bool isObjCClassType()
const;
2591 bool isObjCClassOrClassKindOfType()
const;
2593 bool isBlockCompatibleObjCPointerType(
ASTContext &ctx)
const;
2594 bool isObjCSelType()
const;
2595 bool isObjCBuiltinType()
const;
2596 bool isObjCARCBridgableType()
const;
2597 bool isCARCBridgableType()
const;
2598 bool isTemplateTypeParmType()
const;
2599 bool isNullPtrType()
const;
2601 bool isNothrowT()
const;
2602 bool isAlignValT()
const;
2603 bool isStdByteType()
const;
2604 bool isAtomicType()
const;
2605 bool isUndeducedAutoType()
const;
2607 bool isTypedefNameType()
const;
2609#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2610 bool is##Id##Type() const;
2611#include "clang/Basic/OpenCLImageTypes.def"
2613 bool isImageType()
const;
2615 bool isSamplerT()
const;
2616 bool isEventT()
const;
2617 bool isClkEventT()
const;
2618 bool isQueueT()
const;
2619 bool isReserveIDT()
const;
2621#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2622 bool is##Id##Type() const;
2623#include "clang/Basic/OpenCLExtensionTypes.def"
2625 bool isOCLIntelSubgroupAVCType()
const;
2626 bool isOCLExtOpaqueType()
const;
2628 bool isPipeType()
const;
2629 bool isBitIntType()
const;
2630 bool isOpenCLSpecificType()
const;
2635 bool isObjCARCImplicitlyUnretainedType()
const;
2638 bool isCUDADeviceBuiltinSurfaceType()
const;
2640 bool isCUDADeviceBuiltinTextureType()
const;
2659 ScalarTypeKind getScalarTypeKind()
const;
2667 return getDependence() & TypeDependence::Error;
2673 return getDependence() & TypeDependence::Dependent;
2681 return getDependence() & TypeDependence::Instantiation;
2687 bool isUndeducedType()
const;
2691 return getDependence() & TypeDependence::VariablyModified;
2696 bool hasSizedVLAType()
const;
2699 bool hasUnnamedOrLocalType()
const;
2701 bool isOverloadableType()
const;
2704 bool isElaboratedTypeSpecifier()
const;
2706 bool canDecayToPointerType()
const;
2711 bool hasPointerRepresentation()
const;
2715 bool hasObjCPointerRepresentation()
const;
2719 bool hasIntegerRepresentation()
const;
2723 bool hasSignedIntegerRepresentation()
const;
2727 bool hasUnsignedIntegerRepresentation()
const;
2731 bool hasFloatingRepresentation()
const;
2736 const RecordType *getAsStructureType()
const;
2739 const ComplexType *getAsComplexIntegerType()
const;
2760 TagDecl *getAsTagDecl()
const;
2778 return dyn_cast_or_null<AutoType>(getContainedDeducedType());
2784 bool hasAutoForTrailingReturnType()
const;
2792 template <
typename T>
const T *getAs()
const;
2799 template <
typename T>
const T *getAsAdjusted()
const;
2803 const ArrayType *getAsArrayTypeUnsafe()
const;
2811 template <
typename T>
const T *castAs()
const;
2815 const ArrayType *castAsArrayTypeUnsafe()
const;
2824 const Type *getBaseElementTypeUnsafe()
const;
2829 const Type *getArrayElementTypeNoTypeQual()
const;
2834 const Type *getPointeeOrArrayElementType()
const;
2842 const Type *getUnqualifiedDesugaredType()
const;
2847 bool isSignedIntegerType()
const;
2852 bool isUnsignedIntegerType()
const;
2856 bool isSignedIntegerOrEnumerationType()
const;
2860 bool isUnsignedIntegerOrEnumerationType()
const;
2864 bool isFixedPointType()
const;
2867 bool isFixedPointOrIntegerType()
const;
2870 bool isConvertibleToFixedPointType()
const;
2874 bool isSaturatedFixedPointType()
const;
2878 bool isUnsaturatedFixedPointType()
const;
2882 bool isSignedFixedPointType()
const;
2886 bool isUnsignedFixedPointType()
const;
2891 bool isConstantSizeType()
const;
2895 bool isSpecifierType()
const;
2902 return getLinkageAndVisibility().getVisibility();
2907 return getLinkageAndVisibility().isVisibilityExplicit();
2915 bool isLinkageValid()
const;
2922 std::optional<NullabilityKind> getNullability()
const;
2929 bool canHaveNullability(
bool ResultIfUnknown =
true)
const;
2946 std::optional<ArrayRef<QualType>>
2947 getObjCSubstitutions(
const DeclContext *dc)
const;
2951 bool acceptsObjCTypeParams()
const;
2953 const char *getTypeClassName()
const;
2956 return CanonicalType;
2961 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
2966template <>
const TypedefType *Type::getAs()
const;
2967template <>
const UsingType *Type::getAs()
const;
2972template <>
const TemplateSpecializationType *Type::getAs()
const;
2976template <>
const AttributedType *Type::getAs()
const;
2980template <>
const BoundsAttributedType *Type::getAs()
const;
2984template <>
const CountAttributedType *Type::getAs()
const;
2988#define TYPE(Class, Base)
2989#define LEAF_TYPE(Class) \
2990template <> inline const Class##Type *Type::getAs() const { \
2991 return dyn_cast<Class##Type>(CanonicalType); \
2993template <> inline const Class##Type *Type::castAs() const { \
2994 return cast<Class##Type>(CanonicalType); \
2996#include "clang/AST/TypeNodes.inc"
3004#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
3005#include "clang/Basic/OpenCLImageTypes.def"
3007#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
3008#include "clang/Basic/OpenCLExtensionTypes.def"
3010#define SVE_TYPE(Name, Id, SingletonId) Id,
3011#include "clang/Basic/AArch64SVEACLETypes.def"
3013#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
3014#include "clang/Basic/PPCTypes.def"
3016#define RVV_TYPE(Name, Id, SingletonId) Id,
3017#include "clang/Basic/RISCVVTypes.def"
3019#define WASM_TYPE(Name, Id, SingletonId) Id,
3020#include "clang/Basic/WebAssemblyReferenceTypes.def"
3022#define AMDGPU_TYPE(Name, Id, SingletonId) Id,
3023#include "clang/Basic/AMDGPUTypes.def"
3025#define BUILTIN_TYPE(Id, SingletonId) Id,
3026#define LAST_BUILTIN_TYPE(Id) LastKind = Id
3027#include "clang/AST/BuiltinTypes.def"
3037 static_assert(Kind::LastKind <
3038 (1 << BuiltinTypeBitfields::NumOfBuiltinTypeBits) &&
3039 "Defined builtin type exceeds the allocated space for serial "
3041 BuiltinTypeBits.Kind = K;
3050 StringRef str =
getName(Policy);
3051 assert(!str.empty() && str.data()[str.size()] ==
'\0');
3080 return K >= Overload;
3087 return isPlaceholderTypeKind(
getKind());
3114 :
Type(
Complex, CanonicalPtr, Element->getDependence()),
3115 ElementType(Element) {}
3124 Profile(
ID, getElementType());
3128 ID.AddPointer(Element.getAsOpaquePtr());
3141 :
Type(
Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}
3150 Profile(
ID, getInnerType());
3167 :
Type(
Pointer, CanonicalPtr, Pointee->getDependence()),
3168 PointeeType(Pointee) {}
3191 using BaseTy = llvm::PointerIntPair<ValueDecl *, 1, unsigned>;
3206 bool isDeref()
const;
3208 unsigned getInt()
const;
3209 void *getOpaqueValue()
const;
3211 void setFromOpaqueValue(
void *
V);
3242 return decl_range(dependent_decl_begin(), dependent_decl_end());
3246 return {dependent_decl_begin(), dependent_decl_end()};
3249 bool referencesFieldDecls()
const;
3256 case CountAttributed:
3268 public llvm::TrailingObjects<CountAttributedType,
3269 TypeCoupledDeclRefInfo> {
3280 bool CountInBytes,
bool OrNull,
3283 unsigned numTrailingObjects(OverloadToken<TypeCoupledDeclRefInfo>)
const {
3284 return CountAttributedTypeBits.NumCoupledDecls;
3297 bool isOrNull()
const {
return CountAttributedTypeBits.OrNull; }
3301 return isCountInBytes() ? SizedByOrNull : CountedByOrNull;
3302 return isCountInBytes() ? SizedBy : CountedBy;
3306 Profile(
ID, desugar(), CountExpr, isCountInBytes(), isOrNull());
3309 static void Profile(llvm::FoldingSetNodeID &
ID,
QualType WrappedTy,
3310 Expr *CountExpr,
bool CountInBytes,
bool Nullable);
3329 :
Type(TC, CanonicalPtr, OriginalTy->getDependence()),
3330 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
3340 Profile(
ID, OriginalTy, AdjustedTy);
3378 :
Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
3379 PointeeType(Pointee) {}
3407 bool SpelledAsLValue)
3408 :
Type(tc, CanonicalRef, Referencee->getDependence()),
3409 PointeeType(Referencee) {
3410 ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
3423 while (
T->isInnerRef())
3425 return T->PointeeType;
3429 Profile(
ID, PointeeType, isSpelledAsLValue());
3434 bool SpelledAsLValue) {
3436 ID.AddBoolean(SpelledAsLValue);
3450 bool SpelledAsLValue)
3492 :
Type(MemberPointer, CanonicalPtr,
3494 Pointee->getDependence()),
3495 PointeeType(Pointee),
Class(Cls) {}
3523 const Type *Class) {
3549 unsigned tq,
const Expr *sz =
nullptr);
3559 return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
3563 return ArrayTypeBits.IndexTypeQuals;
3581 struct ExternalSize {
3582 ExternalSize(
const llvm::APInt &Sz,
const Expr *SE)
3583 : Size(Sz), SizeExpr(SE) {}
3585 const Expr *SizeExpr;
3595 :
ArrayType(ConstantArray, Et, Can,
SM, TQ, nullptr), Size(Sz) {
3596 ConstantArrayTypeBits.HasExternalSize =
false;
3597 ConstantArrayTypeBits.SizeWidth = Width / 8;
3600 assert(Width < 0xFF &&
"Type width in bits must be less than 8 bits");
3603 ConstantArrayType(QualType Et, QualType Can, ExternalSize *SzPtr,
3604 ArraySizeModifier
SM,
unsigned TQ)
3605 : ArrayType(ConstantArray, Et, Can,
SM, TQ, SzPtr->SizeExpr),
3607 ConstantArrayTypeBits.HasExternalSize =
true;
3608 ConstantArrayTypeBits.SizeWidth = 0;
3610 assert((SzPtr->SizeExpr ==
nullptr || !Can.isNull()) &&
3611 "canonical constant array should not have size expression");
3614 static ConstantArrayType *
Create(
const ASTContext &Ctx, QualType ET,
3615 QualType Can,
const llvm::APInt &Sz,
3616 const Expr *SzExpr, ArraySizeModifier SzMod,
3621 :
ArrayType(Tc, ATy->getElementType(), Can, ATy->getSizeModifier(),
3622 ATy->getIndexTypeQualifiers().getAsOpaqueValue(), nullptr) {
3623 ConstantArrayTypeBits.HasExternalSize =
3625 if (!ConstantArrayTypeBits.HasExternalSize) {
3635 return ConstantArrayTypeBits.HasExternalSize
3637 : llvm::APInt(ConstantArrayTypeBits.SizeWidth * 8, Size);
3642 return ConstantArrayTypeBits.HasExternalSize
3643 ? SizePtr->Size.getBitWidth()
3644 :
static_cast<unsigned>(ConstantArrayTypeBits.SizeWidth * 8);
3649 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.isZero()
3655 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.getZExtValue()
3661 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.getSExtValue()
3662 :
static_cast<int64_t
>(Size);
3668 return ConstantArrayTypeBits.HasExternalSize
3669 ? SizePtr->Size.getLimitedValue()
3675 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->SizeExpr :
nullptr;
3683 static unsigned getNumAddressingBits(
const ASTContext &Context,
3685 const llvm::APInt &NumElements);
3687 unsigned getNumAddressingBits(
const ASTContext &Context)
const;
3691 static unsigned getMaxSizeBits(
const ASTContext &Context);
3694 Profile(
ID, Ctx, getElementType(), getZExtSize(), getSizeExpr(),
3695 getSizeModifier(), getIndexTypeCVRQualifiers());
3698 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx,
3730 :
ArrayType(IncompleteArray, et, can, sm, tq) {}
3743 Profile(
ID, getElementType(), getSizeModifier(),
3744 getIndexTypeCVRQualifiers());
3750 ID.AddInteger(llvm::to_underlying(SizeMod));
3751 ID.AddInteger(TypeQuals);
3782 :
ArrayType(VariableArray, et, can, sm, tq, e),
3783 SizeExpr((
Stmt*) e), Brackets(brackets) {}
3791 return (
Expr*) SizeExpr;
3806 llvm_unreachable(
"Cannot unique VariableArrayTypes.");
3846 return (
Expr*) SizeExpr;
3861 Profile(
ID, Context, getElementType(),
3862 getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
3865 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
3867 unsigned TypeQuals,
Expr *
E);
3884 Expr *AddrSpaceExpr;
3907 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
3947 Profile(
ID, Context, getElementType(), getSizeExpr());
3950 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
4016 Profile(
ID, getElementType(), getNumElements(),
4017 getTypeClass(), getVectorKind());
4024 ID.AddInteger(NumElements);
4026 ID.AddInteger(llvm::to_underlying(VecKind));
4069 Profile(
ID, Context, getElementType(), getSizeExpr(), getVectorKind());
4072 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
4087 :
VectorType(ExtVector, vecType, nElements, canonType,
4094 case 'x':
case 'r':
return 0;
4095 case 'y':
case 'g':
return 1;
4096 case 'z':
case 'b':
return 2;
4097 case 'w':
case 'a':
return 3;
4115 case 'a':
return 10;
4117 case 'b':
return 11;
4119 case 'c':
return 12;
4121 case 'd':
return 13;
4123 case 'e':
return 14;
4125 case 'f':
return 15;
4130 if (isNumericAccessor)
4131 return getNumericAccessorIdx(
c);
4133 return getPointAccessorIdx(
c);
4137 if (
int idx = getAccessorIdx(
c, isNumericAccessor)+1)
4138 return unsigned(idx-1) < getNumElements();
4163 const Expr *RowExpr =
nullptr,
const Expr *ColumnExpr =
nullptr);
4197 static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;
4200 unsigned NColumns,
QualType CanonElementType);
4203 unsigned NColumns,
QualType CanonElementType);
4214 return getNumRows() * getNumColumns();
4219 return NumElements > 0 && NumElements <= MaxElementsPerDimension;
4224 return MaxElementsPerDimension;
4228 Profile(
ID, getElementType(), getNumRows(), getNumColumns(),
4233 unsigned NumRows,
unsigned NumColumns,
4236 ID.AddInteger(NumRows);
4237 ID.AddInteger(NumColumns);
4269 Profile(
ID, Context, getElementType(), getRowExpr(), getColumnExpr());
4272 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
4308 HasPassObjSize = 0x20,
4311 unsigned char Data = 0;
4320 copy.Data = (copy.Data & ~ABIMask) |
unsigned(kind);
4330 copy.Data |= IsConsumed;
4332 copy.Data &= ~IsConsumed;
4339 Copy.Data |= HasPassObjSize;
4347 Copy.Data |= IsNoEscape;
4349 Copy.Data &= ~IsNoEscape;
4361 return lhs.Data == rhs.Data;
4365 return lhs.Data != rhs.Data;
4400 enum { CallConvMask = 0x1F };
4401 enum { NoReturnMask = 0x20 };
4402 enum { ProducesResultMask = 0x40 };
4403 enum { NoCallerSavedRegsMask = 0x80 };
4405 RegParmMask = 0x700,
4408 enum { NoCfCheckMask = 0x800 };
4409 enum { CmseNSCallMask = 0x1000 };
4410 uint16_t Bits =
CC_C;
4412 ExtInfo(
unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
4418 bool producesResult,
bool noCallerSavedRegs,
bool NoCfCheck,
4420 assert((!hasRegParm || regParm < 7) &&
"Invalid regparm value");
4421 Bits = ((
unsigned)cc) | (noReturn ? NoReturnMask : 0) |
4422 (producesResult ? ProducesResultMask : 0) |
4423 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
4424 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
4425 (NoCfCheck ? NoCfCheckMask : 0) |
4426 (cmseNSCall ? CmseNSCallMask : 0);
4442 bool getHasRegParm()
const {
return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
4445 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
4454 return Bits ==
Other.Bits;
4457 return Bits !=
Other.Bits;
4465 return ExtInfo(Bits | NoReturnMask);
4467 return ExtInfo(Bits & ~NoReturnMask);
4472 return ExtInfo(Bits | ProducesResultMask);
4474 return ExtInfo(Bits & ~ProducesResultMask);
4479 return ExtInfo(Bits | CmseNSCallMask);
4481 return ExtInfo(Bits & ~CmseNSCallMask);
4485 if (noCallerSavedRegs)
4486 return ExtInfo(Bits | NoCallerSavedRegsMask);
4488 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
4493 return ExtInfo(Bits | NoCfCheckMask);
4495 return ExtInfo(Bits & ~NoCfCheckMask);
4499 assert(RegParm < 7 &&
"Invalid regparm value");
4500 return ExtInfo((Bits & ~RegParmMask) |
4501 ((RegParm + 1) << RegParmOffset));
4505 return ExtInfo((Bits & ~CallConvMask) | (
unsigned) cc);
4509 ID.AddInteger(Bits);
4527 LLVM_PREFERRED_TYPE(
bool)
4530 LLVM_PREFERRED_TYPE(
bool)
4531 unsigned EffectsHaveConditions : 1;
4532 unsigned NumFunctionEffects : 4;
4535 : NumExceptionType(0), HasArmTypeAttributes(
false),
4536 EffectsHaveConditions(
false), NumFunctionEffects(0) {}
4543 SME_NormalFunction = 0,
4544 SME_PStateSMEnabledMask = 1 << 0,
4545 SME_PStateSMCompatibleMask = 1 << 1,
4549 SME_ZAMask = 0b111 << SME_ZAShift,
4551 SME_ZT0Mask = 0b111 << SME_ZT0Shift,
4567 return (
ArmStateValue)((AttrBits & SME_ZAMask) >> SME_ZAShift);
4571 return (
ArmStateValue)((AttrBits & SME_ZT0Mask) >> SME_ZT0Shift);
4589 FunctionTypeBits.ExtInfo = Info.Bits;
4593 if (isFunctionProtoType())
4594 return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
4614 static_assert((
~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
4615 "Const, volatile and restrict are assumed to be a subset of "
4616 "the fast qualifiers.");
4618 bool isConst()
const {
return getFastTypeQuals().hasConst(); }
4619 bool isVolatile()
const {
return getFastTypeQuals().hasVolatile(); }
4620 bool isRestrict()
const {
return getFastTypeQuals().hasRestrict(); }
4628 static StringRef getNameForCallConv(
CallingConv CC);
4643 Result->getDependence() &
4655 Profile(
ID, getReturnType(), getExtInfo());
4690 FE_InferrableOnCallees = 0x1,
4693 FE_ExcludeThrow = 0x2,
4694 FE_ExcludeCatch = 0x4,
4695 FE_ExcludeObjCMessageSend = 0x8,
4696 FE_ExcludeStaticLocalVars = 0x10,
4697 FE_ExcludeThreadLocalVars = 0x20
4701 LLVM_PREFERRED_TYPE(
Kind)
4717 Kind oppositeKind()
const;
4728 case Kind::NonBlocking:
4729 return FE_InferrableOnCallees | FE_ExcludeThrow | FE_ExcludeCatch |
4730 FE_ExcludeObjCMessageSend | FE_ExcludeStaticLocalVars |
4731 FE_ExcludeThreadLocalVars;
4732 case Kind::NonAllocating:
4734 return FE_InferrableOnCallees | FE_ExcludeThrow | FE_ExcludeCatch |
4735 FE_ExcludeObjCMessageSend | FE_ExcludeThreadLocalVars;
4736 case Kind::Blocking:
4737 case Kind::Allocating:
4742 llvm_unreachable(
"unknown effect kind");
4746 StringRef name()
const;
4752 bool canInferOnFunction(
const Decl &Callee)
const;
4758 bool shouldDiagnoseFunctionCall(
bool Direct,
4762 return LHS.FKind == RHS.FKind;
4765 return !(LHS == RHS);
4768 return LHS.FKind < RHS.FKind;
4775 Expr *Cond =
nullptr;
4784 return Cond == RHS.Cond;
4798 : Effect(
E), Cond(C) {}
4801 std::string description()
const;
4809 const Container *Outer =
nullptr;
4816 return Idx ==
Other.Idx;
4819 return Idx !=
Other.Idx;
4828 assert(Outer !=
nullptr &&
"invalid FunctionEffectIterator");
4829 bool HasConds = !Outer->Conditions.empty();
4831 HasConds ? Outer->Conditions[Idx]
4870 : Effects(FX), Conditions(Conds) {}
4883 bool empty()
const {
return Effects.empty(); }
4884 size_t size()
const {
return Effects.size(); }
4896 return LHS.Effects == RHS.Effects && LHS.Conditions == RHS.Conditions;
4900 return !(LHS == RHS);
4903 void dump(llvm::raw_ostream &OS)
const;
4918 : Effects(FX.effects()), Conditions(FX.conditions()) {}
4920 bool empty()
const {
return Effects.empty(); }
4921 size_t size()
const {
return Effects.size(); }
4930 void dump(llvm::raw_ostream &OS)
const;
4967 public llvm::FoldingSetNode,
4968 private llvm::TrailingObjects<
4969 FunctionProtoType, QualType, SourceLocation,
4970 FunctionType::FunctionTypeExtraBitfields,
4971 FunctionType::FunctionTypeArmAttributes, FunctionType::ExceptionType,
4972 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers,
4973 FunctionEffect, EffectConditionExpr> {
4975 friend TrailingObjects;
5072 AArch64SMEAttributes(SME_NormalFunction) {}
5076 AArch64SMEAttributes(SME_NormalFunction) {}
5080 Result.ExceptionSpec = ESI;
5086 requiresFunctionProtoTypeArmAttributes() ||
5087 !FunctionEffects.
empty();
5091 return AArch64SMEAttributes != SME_NormalFunction;
5096 AArch64SMEAttributes |=
Kind;
5098 AArch64SMEAttributes &= ~Kind;
5103 unsigned numTrailingObjects(OverloadToken<QualType>)
const {
5104 return getNumParams();
5107 unsigned numTrailingObjects(OverloadToken<SourceLocation>)
const {
5108 return isVariadic();
5111 unsigned numTrailingObjects(OverloadToken<FunctionTypeArmAttributes>)
const {
5112 return hasArmTypeAttributes();
5115 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>)
const {
5116 return hasExtraBitfields();
5119 unsigned numTrailingObjects(OverloadToken<ExceptionType>)
const {
5120 return getExceptionSpecSize().NumExceptionType;
5123 unsigned numTrailingObjects(OverloadToken<Expr *>)
const {
5124 return getExceptionSpecSize().NumExprPtr;
5127 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>)
const {
5128 return getExceptionSpecSize().NumFunctionDeclPtr;
5131 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>)
const {
5132 return hasExtParameterInfos() ? getNumParams() : 0;
5135 unsigned numTrailingObjects(OverloadToken<Qualifiers>)
const {
5136 return hasExtQualifiers() ? 1 : 0;
5139 unsigned numTrailingObjects(OverloadToken<FunctionEffect>)
const {
5140 return getNumFunctionEffects();
5143 unsigned numTrailingObjects(OverloadToken<EffectConditionExpr>)
const {
5144 return getNumFunctionEffectConditions();
5149 static bool containsAnyUnexpandedParameterPack(
const QualType *ArgArray,
5151 for (
unsigned Idx = 0; Idx < numArgs; ++Idx)
5152 if (ArgArray[Idx]->containsUnexpandedParameterPack())
5158 FunctionProtoType(QualType result, ArrayRef<QualType> params,
5159 QualType canonical,
const ExtProtoInfo &epi);
5164 struct ExceptionSpecSizeHolder {
5165 unsigned NumExceptionType;
5166 unsigned NumExprPtr;
5167 unsigned NumFunctionDeclPtr;
5172 static ExceptionSpecSizeHolder
5173 getExceptionSpecSize(ExceptionSpecificationType EST,
unsigned NumExceptions) {
5184 return {NumExceptions, 0, 0};
5197 llvm_unreachable(
"bad exception specification kind");
5202 ExceptionSpecSizeHolder getExceptionSpecSize()
const {
5203 return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
5207 bool hasExtraBitfields()
const {
5208 assert((getExceptionSpecType() != EST_Dynamic ||
5209 FunctionTypeBits.HasExtraBitfields) &&
5210 "ExtraBitfields are required for given ExceptionSpecType");
5211 return FunctionTypeBits.HasExtraBitfields;
5215 bool hasArmTypeAttributes()
const {
5216 return FunctionTypeBits.HasExtraBitfields &&
5217 getTrailingObjects<FunctionTypeExtraBitfields>()
5218 ->HasArmTypeAttributes;
5221 bool hasExtQualifiers()
const {
5222 return FunctionTypeBits.HasExtQuals;
5229 assert(i < getNumParams() &&
"invalid parameter index");
5230 return param_type_begin()[i];
5255 FunctionTypeBits.ExceptionSpecType);
5272 bool hasDependentExceptionSpec()
const;
5276 bool hasInstantiationDependentExceptionSpec()
const;
5281 Result.Type = getExceptionSpecType();
5283 Result.Exceptions = exceptions();
5285 Result.NoexceptExpr = getNoexceptExpr();
5287 Result.SourceDecl = getExceptionSpecDecl();
5288 Result.SourceTemplate = getExceptionSpecTemplate();
5290 Result.SourceDecl = getExceptionSpecDecl();
5298 ? getTrailingObjects<FunctionTypeExtraBitfields>()
5305 assert(i < getNumExceptions() &&
"Invalid exception number!");
5306 return exception_begin()[i];
5314 return *getTrailingObjects<Expr *>();
5325 return getTrailingObjects<FunctionDecl *>()[0];
5335 return getTrailingObjects<FunctionDecl *>()[1];
5346 return ResultIfDependent ? canThrow() !=
CT_Can : canThrow() ==
CT_Cannot;
5353 return isVariadic() ? *getTrailingObjects<SourceLocation>()
5363 bool isTemplateVariadic()
const;
5369 if (hasExtQualifiers())
5370 return *getTrailingObjects<Qualifiers>();
5372 return getFastTypeQuals();
5387 return getTrailingObjects<QualType>();
5391 return param_type_begin() + getNumParams();
5402 getTrailingObjects<ExceptionType>());
5406 return exception_begin() + getNumExceptions();
5412 return FunctionTypeBits.HasExtParameterInfos;
5416 assert(hasExtParameterInfos());
5425 if (!hasExtParameterInfos())
5427 return getTrailingObjects<ExtParameterInfo>();
5433 if (!hasArmTypeAttributes())
5434 return SME_NormalFunction;
5435 return getTrailingObjects<FunctionTypeArmAttributes>()
5436 ->AArch64SMEAttributes;
5440 assert(I < getNumParams() &&
"parameter index out of range");
5441 if (hasExtParameterInfos())
5442 return getTrailingObjects<ExtParameterInfo>()[I];
5447 assert(I < getNumParams() &&
"parameter index out of range");
5448 if (hasExtParameterInfos())
5449 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
5450 return ParameterABI::Ordinary;
5454 assert(I < getNumParams() &&
"parameter index out of range");
5455 if (hasExtParameterInfos())
5456 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
5461 return hasExtraBitfields()
5462 ? getTrailingObjects<FunctionTypeExtraBitfields>()
5463 ->NumFunctionEffects
5469 if (hasExtraBitfields()) {
5470 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5471 if (Bitfields->NumFunctionEffects > 0)
5472 return {getTrailingObjects<FunctionEffect>(),
5473 Bitfields->NumFunctionEffects};
5479 if (hasExtraBitfields()) {
5480 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5481 if (Bitfields->EffectsHaveConditions)
5482 return Bitfields->NumFunctionEffects;
5489 if (hasExtraBitfields()) {
5490 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5491 if (Bitfields->EffectsHaveConditions)
5492 return {getTrailingObjects<EffectConditionExpr>(),
5493 Bitfields->NumFunctionEffects};
5500 if (hasExtraBitfields()) {
5501 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5502 if (Bitfields->NumFunctionEffects > 0) {
5503 const size_t NumConds = Bitfields->EffectsHaveConditions
5504 ? Bitfields->NumFunctionEffects
5507 {getTrailingObjects<FunctionEffect>(),
5508 Bitfields->NumFunctionEffects},
5509 {NumConds ? getTrailingObjects<EffectConditionExpr>() :
nullptr,
5519 void printExceptionSpecification(raw_ostream &OS,
5526 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx);
5559 return Profile(
ID,
Decl);
5569 public llvm::FoldingSetNode,
5570 private llvm::TrailingObjects<UsingType, QualType> {
5573 friend TrailingObjects;
5601 public llvm::FoldingSetNode,
5602 private llvm::TrailingObjects<TypedefType, QualType> {
5605 friend TrailingObjects;
5627 if (!Underlying.
isNull())
5644 :
Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
5645 UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
5646 assert(isa<AttributedType>(UnderlyingTy) &&
5647 "Expected a macro qualified type to only wrap attributed types.");
5683 return static_cast<TypeOfKind>(TypeOfBits.Kind);
5690 bool isSugared()
const;
5702 public llvm::FoldingSetNode {
5708 Profile(
ID, Context, getUnderlyingExpr(),
5709 getKind() == TypeOfKind::Unqualified);
5712 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5713 Expr *
E,
bool IsUnqual);
5738 return static_cast<TypeOfKind>(TypeOfBits.Kind);
5762 bool isSugared()
const;
5778 Profile(
ID, Context, getUnderlyingExpr());
5781 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5787 public llvm::FoldingSetNode,
5788 private llvm::TrailingObjects<PackIndexingType, QualType> {
5789 friend TrailingObjects;
5810 if (hasSelectedType())
5811 return getSelectedType();
5816 assert(hasSelectedType() &&
"Type is dependant");
5817 return *(getExpansionsPtr() + *getSelectedIndex());
5820 std::optional<unsigned> getSelectedIndex()
const;
5825 return {getExpansionsPtr(), Size};
5833 if (hasSelectedType())
5834 getSelectedType().Profile(
ID);
5836 Profile(
ID, Context, getPattern(), getIndexExpr());
5838 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5842 const QualType *getExpansionsPtr()
const {
5843 return getTrailingObjects<QualType>();
5846 static TypeDependence computeDependence(QualType Pattern, Expr *IndexExpr,
5847 ArrayRef<QualType> Expansions = {});
5849 unsigned numTrailingObjects(OverloadToken<QualType>)
const {
return Size; }
5856#define TRANSFORM_TYPE_TRAIT_DEF(Enum, _) Enum,
5857#include "clang/Basic/TransformTypeTraits.def"
5865 QualType UnderlyingType;
5896 public llvm::FoldingSetNode {
5902 Profile(
ID, getBaseType(), getUTTKind());
5908 ID.AddInteger((
unsigned)UKind);
5927 bool isBeingDefined()
const;
5947 return reinterpret_cast<RecordDecl*
>(TagType::getDecl());
5952 bool hasConstFields()
const;
5970 return reinterpret_cast<EnumDecl*
>(TagType::getDecl());
6003 :
Type(Attributed, canon, equivalent->getDependence()),
6004 ModifiedType(modified), EquivalentType(equivalent) {
6005 AttributedTypeBits.AttrKind = attrKind;
6010 return static_cast<Kind>(AttributedTypeBits.AttrKind);
6034 bool isQualifier()
const;
6036 bool isMSTypeSpec()
const;
6038 bool isWebAssemblyFuncrefSpec()
const;
6040 bool isCallingConv()
const;
6042 std::optional<NullabilityKind> getImmediateNullability()
const;
6048 case NullabilityKind::NonNull:
6049 return attr::TypeNonNull;
6051 case NullabilityKind::Nullable:
6052 return attr::TypeNullable;
6054 case NullabilityKind::NullableResult:
6055 return attr::TypeNullableResult;
6057 case NullabilityKind::Unspecified:
6058 return attr::TypeNullUnspecified;
6060 llvm_unreachable(
"Unknown nullability kind.");
6072 static std::optional<NullabilityKind> stripOuterNullability(
QualType &T);
6075 Profile(
ID, getAttrKind(), ModifiedType, EquivalentType);
6080 ID.AddInteger(attrKind);
6095 const BTFTypeTagAttr *BTFAttr;
6098 const BTFTypeTagAttr *BTFAttr)
6099 :
Type(BTFTagAttributed, Canon, Wrapped->getDependence()),
6100 WrappedType(Wrapped), BTFAttr(BTFAttr) {}
6104 const BTFTypeTagAttr *
getAttr()
const {
return BTFAttr; }
6110 Profile(
ID, WrappedType, BTFAttr);
6114 const BTFTypeTagAttr *BTFAttr) {
6116 ID.AddPointer(BTFAttr);
6128 struct CanonicalTTPTInfo {
6129 unsigned Depth : 15;
6130 unsigned ParameterPack : 1;
6131 unsigned Index : 16;
6144 :
Type(TemplateTypeParm, Canon,
6150 TemplateTypeParmType(
unsigned D,
unsigned I,
bool PP)
6151 :
Type(TemplateTypeParm, QualType(this, 0),
6152 TypeDependence::DependentInstantiation |
6153 (PP ? TypeDependence::UnexpandedPack : TypeDependence::
None)) {
6154 CanTTPTInfo.Depth =
D;
6155 CanTTPTInfo.Index = I;
6156 CanTTPTInfo.ParameterPack = PP;
6159 const CanonicalTTPTInfo& getCanTTPTInfo()
const {
6160 QualType Can = getCanonicalTypeInternal();
6161 return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
6165 unsigned getDepth()
const {
return getCanTTPTInfo().Depth; }
6166 unsigned getIndex()
const {
return getCanTTPTInfo().Index; }
6170 return isCanonicalUnqualified() ? nullptr : TTPDecl;
6182 static void Profile(llvm::FoldingSetNodeID &
ID,
unsigned Depth,
6183 unsigned Index,
bool ParameterPack,
6185 ID.AddInteger(Depth);
6186 ID.AddInteger(Index);
6187 ID.AddBoolean(ParameterPack);
6188 ID.AddPointer(TTPDecl);
6205 public llvm::FoldingSetNode,
6206 private llvm::TrailingObjects<SubstTemplateTypeParmType, QualType> {
6210 Decl *AssociatedDecl;
6213 unsigned Index, std::optional<unsigned> PackIndex);
6219 return SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType
6220 ? *getTrailingObjects<QualType>()
6221 : getCanonicalTypeInternal();
6234 unsigned getIndex()
const {
return SubstTemplateTypeParmTypeBits.Index; }
6237 if (SubstTemplateTypeParmTypeBits.PackIndex == 0)
6238 return std::nullopt;
6239 return SubstTemplateTypeParmTypeBits.PackIndex - 1;
6246 Profile(
ID, getReplacementType(), getAssociatedDecl(),
getIndex(),
6251 const Decl *AssociatedDecl,
unsigned Index,
6252 std::optional<unsigned> PackIndex) {
6253 Replacement.Profile(
ID);
6254 ID.AddPointer(AssociatedDecl);
6255 ID.AddInteger(Index);
6256 ID.AddInteger(PackIndex ? *PackIndex - 1 : 0);
6283 llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
6286 unsigned Index,
bool Final,
6295 Decl *getAssociatedDecl()
const;
6302 unsigned getIndex()
const {
return SubstTemplateTypeParmPackTypeBits.Index; }
6305 bool getFinal()
const;
6308 return SubstTemplateTypeParmPackTypeBits.NumArgs;
6316 void Profile(llvm::FoldingSetNodeID &
ID);
6317 static void Profile(llvm::FoldingSetNodeID &
ID,
const Decl *AssociatedDecl,
6318 unsigned Index,
bool Final,
6341 ExtraDependence | (DeducedAsType.isNull()
6343 : DeducedAsType->getDependence() &
6345 DeducedAsType(DeducedAsType) {}
6350 return isSugared() ? DeducedAsType :
QualType(
this, 0);
6357 return !DeducedAsType.
isNull() || isDependentType();
6380 AutoTypeBits.NumArgs};
6384 return TypeConstraintConcept;
6388 return TypeConstraintConcept !=
nullptr;
6392 return getKeyword() == AutoTypeKeyword::DecltypeAuto;
6396 return getKeyword() == AutoTypeKeyword::GNUAutoType;
6403 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context);
6404 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
6416 public llvm::FoldingSetNode {
6424 bool IsDeducedAsDependent,
QualType Canon)
6425 :
DeducedType(DeducedTemplateSpecialization, DeducedAsType,
6427 (IsDeducedAsDependent
6431 Template(Template) {}
6438 Profile(
ID, getTemplateName(), getDeducedType(), isDependentType());
6442 QualType Deduced,
bool IsDependent) {
6508 static bool anyInstantiationDependentTemplateArguments(
6514 return isa<InjectedClassNameType>(getCanonicalTypeInternal());
6532 bool isTypeAlias()
const {
return TemplateSpecializationTypeBits.TypeAlias; }
6543 TemplateSpecializationTypeBits.NumArgs};
6547 return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
6551 return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
6554 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx);
6566void printTemplateArgumentList(raw_ostream &OS,
6567 ArrayRef<TemplateArgument> Args,
6568 const PrintingPolicy &Policy,
6569 const TemplateParameterList *TPL =
nullptr);
6571void printTemplateArgumentList(raw_ostream &OS,
6572 ArrayRef<TemplateArgumentLoc> Args,
6573 const PrintingPolicy &Policy,
6574 const TemplateParameterList *TPL =
nullptr);
6576void printTemplateArgumentList(raw_ostream &OS,
6577 const TemplateArgumentListInfo &Args,
6578 const PrintingPolicy &Policy,
6579 const TemplateParameterList *TPL =
nullptr);
6583bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg,
6584 const NamedDecl *Param,
6585 ArrayRef<TemplateArgument> Args,
6629 Decl(
D), InjectedType(TST) {
6630 assert(isa<TemplateSpecializationType>(TST));
6639 return cast<TemplateSpecializationType>(InjectedType.
getTypePtr());
6643 return getInjectedTST()->getTemplateName();
6709 TypeWithKeywordBits.Keyword = llvm::to_underlying(Keyword);
6722 static TagTypeKind getTagTypeKindForTypeSpec(
unsigned TypeSpec);
6737 return getKeywordName(getKeywordForTagTypeKind(
Kind));
6754 public llvm::FoldingSetNode,
6755 private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
6757 friend TrailingObjects;
6776 NamedType->getDependence() |
6780 NNS(NNS), NamedType(NamedType) {
6781 ElaboratedTypeBits.HasOwnedTagDecl =
false;
6783 ElaboratedTypeBits.HasOwnedTagDecl =
true;
6784 *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
6804 return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
6809 Profile(
ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
6815 ID.AddInteger(llvm::to_underlying(Keyword));
6818 ID.AddPointer(OwnedTagDecl);
6850 NNS(NNS), Name(Name) {}
6869 Profile(
ID, getKeyword(), NNS, Name);
6874 ID.AddInteger(llvm::to_underlying(Keyword));
6876 ID.AddPointer(Name);
6888 public llvm::FoldingSetNode {
6909 DependentTemplateSpecializationTypeBits.NumArgs};
6916 Profile(
ID, Context, getKeyword(), NNS, Name, template_arguments());
6919 static void Profile(llvm::FoldingSetNodeID &
ID,
6927 return T->
getTypeClass() == DependentTemplateSpecialization;
6960 std::optional<unsigned> NumExpansions)
6961 :
Type(PackExpansion, Canon,
6966 PackExpansionTypeBits.NumExpansions =
6967 NumExpansions ? *NumExpansions + 1 : 0;
6979 if (PackExpansionTypeBits.NumExpansions)
6980 return PackExpansionTypeBits.NumExpansions - 1;
6981 return std::nullopt;
6988 Profile(
ID, getPattern(), getNumExpansions());
6992 std::optional<unsigned> NumExpansions) {
6994 ID.AddBoolean(NumExpansions.has_value());
6996 ID.AddInteger(*NumExpansions);
7016 return static_cast<T*
>(
this)->getProtocolStorageImpl();
7020 static_cast<T*
>(
this)->setNumProtocolsImpl(N);
7024 setNumProtocols(protocols.size());
7025 assert(getNumProtocols() == protocols.size() &&
7026 "bitfield overflow in protocol count");
7027 if (!protocols.empty())
7028 memcpy(getProtocolStorage(), protocols.data(),
7045 return static_cast<const T*
>(
this)->getNumProtocolsImpl();
7050 assert(I < getNumProtocols() &&
"Out-of-range protocol access");
7051 return qual_begin()[I];
7064 public llvm::FoldingSetNode {
7069 unsigned NumProtocols : 6;
7080 unsigned getNumProtocolsImpl()
const {
7081 return NumProtocols;
7084 void setNumProtocolsImpl(
unsigned N) {
7088 ObjCTypeParamType(
const ObjCTypeParamDecl *
D,
7090 ArrayRef<ObjCProtocolDecl *> protocols);
7100 void Profile(llvm::FoldingSetNodeID &
ID);
7101 static void Profile(llvm::FoldingSetNodeID &
ID,
7157 mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
7158 CachedSuperClassType;
7161 const QualType *getTypeArgStorage()
const {
7168 unsigned getNumProtocolsImpl()
const {
7169 return ObjCObjectTypeBits.NumProtocols;
7171 void setNumProtocolsImpl(
unsigned N) {
7172 ObjCObjectTypeBits.NumProtocols = N;
7186 ObjCObjectTypeBits.NumProtocols = 0;
7187 ObjCObjectTypeBits.NumTypeArgs = 0;
7188 ObjCObjectTypeBits.IsKindOf = 0;
7191 void computeSuperClassTypeSlow()
const;
7203 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
7207 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
7213 if (!qual_empty())
return false;
7214 if (
const BuiltinType *
T = getBaseType()->getAs<BuiltinType>())
7215 return T->getKind() == BuiltinType::ObjCId ||
7216 T->getKind() == BuiltinType::ObjCClass;
7228 bool isSpecialized()
const;
7232 return ObjCObjectTypeBits.NumTypeArgs > 0;
7249 return llvm::ArrayRef(getTypeArgStorage(), ObjCObjectTypeBits.NumTypeArgs);
7256 bool isKindOfType()
const;
7265 if (!CachedSuperClassType.getInt())
7266 computeSuperClassTypeSlow();
7268 assert(CachedSuperClassType.getInt() &&
"Superclass not set?");
7269 return QualType(CachedSuperClassType.getPointer(), 0);
7302 void Profile(llvm::FoldingSetNodeID &
ID);
7303 static void Profile(llvm::FoldingSetNodeID &
ID,
7310inline QualType *ObjCObjectType::getTypeArgStorage() {
7311 return reinterpret_cast<QualType *
>(
static_cast<ObjCObjectTypeImpl*
>(
this)+1);
7314inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
7315 return reinterpret_cast<ObjCProtocolDecl**
>(
7316 getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
7319inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
7320 return reinterpret_cast<ObjCProtocolDecl**
>(
7321 static_cast<ObjCTypeParamType*
>(
this)+1);
7374 if (
const auto *
T = dyn_cast<ObjCInterfaceType>(ObjT))
7375 return T->getDecl();
7377 baseType = ObjT->getBaseType();
7398 :
Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
7399 PointeeType(Pointee) {}
7542 QualType getSuperClassType()
const;
7554 ID.AddPointer(
T.getAsOpaquePtr());
7568 :
Type(
Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}
7579 Profile(
ID, getValueType());
7583 ID.AddPointer(
T.getAsOpaquePtr());
7599 :
Type(
Pipe, CanonicalPtr, elemType->getDependence()),
7610 Profile(
ID, getElementType(), isReadOnly());
7614 ID.AddPointer(
T.getAsOpaquePtr());
7628 LLVM_PREFERRED_TYPE(
bool)
7629 unsigned IsUnsigned : 1;
7630 unsigned NumBits : 24;
7647 static void Profile(llvm::FoldingSetNodeID &
ID,
bool IsUnsigned,
7649 ID.AddBoolean(IsUnsigned);
7650 ID.AddInteger(NumBits);
7658 llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;
7666 Expr *getNumBitsExpr()
const;
7674 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
7675 bool IsUnsigned,
Expr *NumBitsExpr);
7691 addFastQualifiers(
type.getLocalFastQualifiers());
7692 if (!
type.hasLocalNonFastQualifiers())
7693 return type.getTypePtrUnsafe();
7738 Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
7743inline const Type *QualType::getTypePtr()
const {
7744 return getCommonPtr()->BaseType;
7747inline const Type *QualType::getTypePtrOrNull()
const {
7748 return (isNull() ?
nullptr : getCommonPtr()->BaseType);
7751inline bool QualType::isReferenceable()
const {
7755 const Type &Self = **
this;
7756 if (Self.isObjectType() || Self.isReferenceType())
7759 return F->getMethodQuals().empty() && F->getRefQualifier() ==
RQ_None;
7765 if (!hasLocalNonFastQualifiers())
7767 Qualifiers::fromFastMask(getLocalFastQualifiers()));
7769 const ExtQuals *eq = getExtQualsUnsafe();
7777 if (hasLocalNonFastQualifiers())
7778 Quals = getExtQualsUnsafe()->getQualifiers();
7784 Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
7789inline unsigned QualType::getCVRQualifiers()
const {
7790 unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
7791 cvr |= getLocalCVRQualifiers();
7796 QualType canon = getCommonPtr()->CanonicalType;
7800inline bool QualType::isCanonical()
const {
7804inline bool QualType::isCanonicalAsParam()
const {
7805 if (!isCanonical())
return false;
7806 if (hasLocalQualifiers())
return false;
7808 const Type *
T = getTypePtr();
7812 return !isa<FunctionType>(
T) &&
7813 (!isa<ArrayType>(
T) || isa<ArrayParameterType>(
T));
7816inline bool QualType::isConstQualified()
const {
7817 return isLocalConstQualified() ||
7818 getCommonPtr()->CanonicalType.isLocalConstQualified();
7821inline bool QualType::isRestrictQualified()
const {
7822 return isLocalRestrictQualified() ||
7823 getCommonPtr()->CanonicalType.isLocalRestrictQualified();
7827inline bool QualType::isVolatileQualified()
const {
7828 return isLocalVolatileQualified() ||
7829 getCommonPtr()->CanonicalType.isLocalVolatileQualified();
7832inline bool QualType::hasQualifiers()
const {
7833 return hasLocalQualifiers() ||
7834 getCommonPtr()->CanonicalType.hasLocalQualifiers();
7838 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
7841 return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
7845 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
7848 return getSplitUnqualifiedTypeImpl(*
this);
7851inline void QualType::removeLocalConst() {
7852 removeLocalFastQualifiers(Qualifiers::Const);
7855inline void QualType::removeLocalRestrict() {
7856 removeLocalFastQualifiers(Qualifiers::Restrict);
7859inline void QualType::removeLocalVolatile() {
7860 removeLocalFastQualifiers(Qualifiers::Volatile);
7864inline bool QualType::hasAddressSpace()
const {
7865 return getQualifiers().hasAddressSpace();
7869inline LangAS QualType::getAddressSpace()
const {
7870 return getQualifiers().getAddressSpace();
7875 return getQualifiers().getObjCGCAttr();
7878inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion()
const {
7879 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
7880 return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
7884inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion()
const {
7885 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
7886 return hasNonTrivialToPrimitiveDestructCUnion(RD);
7890inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion()
const {
7891 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
7892 return hasNonTrivialToPrimitiveCopyCUnion(RD);
7898 if (
const auto *FT = PT->getPointeeType()->getAs<
FunctionType>())
7899 return FT->getExtInfo();
7901 return FT->getExtInfo();
7915inline bool QualType::isMoreQualifiedThan(
QualType other)
const {
7925inline bool QualType::isAtLeastAsQualifiedAs(
QualType other)
const {
7929 if (getUnqualifiedType()->isVoidType())
7932 return getQualifiers().compatiblyIncludes(OtherQuals);
7951inline bool QualType::isCForbiddenLValueType()
const {
7952 return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
7953 getTypePtr()->isFunctionType());
7959inline bool Type::isFundamentalType()
const {
7960 return isVoidType() ||
7964 (isArithmeticType() && !isEnumeralType());
7970inline bool Type::isCompoundType()
const {
7974 return isArrayType() ||
7980 isReferenceType() ||
7989 isMemberPointerType();
7992inline bool Type::isFunctionType()
const {
7993 return isa<FunctionType>(CanonicalType);
7996inline bool Type::isPointerType()
const {
7997 return isa<PointerType>(CanonicalType);
8000inline bool Type::isAnyPointerType()
const {
8001 return isPointerType() || isObjCObjectPointerType();
8004inline bool Type::isSignableType()
const {
return isPointerType(); }
8006inline bool Type::isBlockPointerType()
const {
8007 return isa<BlockPointerType>(CanonicalType);
8010inline bool Type::isReferenceType()
const {
8011 return isa<ReferenceType>(CanonicalType);
8014inline bool Type::isLValueReferenceType()
const {
8015 return isa<LValueReferenceType>(CanonicalType);
8018inline bool Type::isRValueReferenceType()
const {
8019 return isa<RValueReferenceType>(CanonicalType);
8022inline bool Type::isObjectPointerType()
const {
8026 if (
const auto *
T = getAs<PointerType>())
8032inline bool Type::isFunctionPointerType()
const {
8033 if (
const auto *
T = getAs<PointerType>())
8039inline bool Type::isFunctionReferenceType()
const {
8040 if (
const auto *
T = getAs<ReferenceType>())
8046inline bool Type::isMemberPointerType()
const {
8047 return isa<MemberPointerType>(CanonicalType);
8050inline bool Type::isMemberFunctionPointerType()
const {
8051 if (
const auto *
T = getAs<MemberPointerType>())
8052 return T->isMemberFunctionPointer();
8057inline bool Type::isMemberDataPointerType()
const {
8058 if (
const auto *
T = getAs<MemberPointerType>())
8059 return T->isMemberDataPointer();
8064inline bool Type::isArrayType()
const {
8065 return isa<ArrayType>(CanonicalType);
8068inline bool Type::isConstantArrayType()
const {
8069 return isa<ConstantArrayType>(CanonicalType);
8072inline bool Type::isIncompleteArrayType()
const {
8073 return isa<IncompleteArrayType>(CanonicalType);
8076inline bool Type::isVariableArrayType()
const {
8077 return isa<VariableArrayType>(CanonicalType);
8080inline bool Type::isArrayParameterType()
const {
8081 return isa<ArrayParameterType>(CanonicalType);
8084inline bool Type::isDependentSizedArrayType()
const {
8085 return isa<DependentSizedArrayType>(CanonicalType);
8088inline bool Type::isBuiltinType()
const {
8089 return isa<BuiltinType>(CanonicalType);
8092inline bool Type::isRecordType()
const {
8093 return isa<RecordType>(CanonicalType);
8096inline bool Type::isEnumeralType()
const {
8097 return isa<EnumType>(CanonicalType);
8100inline bool Type::isAnyComplexType()
const {
8101 return isa<ComplexType>(CanonicalType);
8104inline bool Type::isVectorType()
const {
8105 return isa<VectorType>(CanonicalType);
8108inline bool Type::isExtVectorType()
const {
8109 return isa<ExtVectorType>(CanonicalType);
8112inline bool Type::isExtVectorBoolType()
const {
8113 if (!isExtVectorType())
8115 return cast<ExtVectorType>(CanonicalType)->getElementType()->isBooleanType();
8118inline bool Type::isSubscriptableVectorType()
const {
8119 return isVectorType() || isSveVLSBuiltinType();
8122inline bool Type::isMatrixType()
const {
8123 return isa<MatrixType>(CanonicalType);
8126inline bool Type::isConstantMatrixType()
const {
8127 return isa<ConstantMatrixType>(CanonicalType);
8130inline bool Type::isDependentAddressSpaceType()
const {
8131 return isa<DependentAddressSpaceType>(CanonicalType);
8134inline bool Type::isObjCObjectPointerType()
const {
8135 return isa<ObjCObjectPointerType>(CanonicalType);
8138inline bool Type::isObjCObjectType()
const {
8139 return isa<ObjCObjectType>(CanonicalType);
8142inline bool Type::isObjCObjectOrInterfaceType()
const {
8143 return isa<ObjCInterfaceType>(CanonicalType) ||
8144 isa<ObjCObjectType>(CanonicalType);
8147inline bool Type::isAtomicType()
const {
8148 return isa<AtomicType>(CanonicalType);
8151inline bool Type::isUndeducedAutoType()
const {
8152 return isa<AutoType>(CanonicalType);
8155inline bool Type::isObjCQualifiedIdType()
const {
8156 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
8157 return OPT->isObjCQualifiedIdType();
8161inline bool Type::isObjCQualifiedClassType()
const {
8162 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
8163 return OPT->isObjCQualifiedClassType();
8167inline bool Type::isObjCIdType()
const {
8168 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
8169 return OPT->isObjCIdType();
8173inline bool Type::isObjCClassType()
const {
8174 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
8175 return OPT->isObjCClassType();
8179inline bool Type::isObjCSelType()
const {
8180 if (
const auto *OPT = getAs<PointerType>())
8181 return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
8185inline bool Type::isObjCBuiltinType()
const {
8186 return isObjCIdType() || isObjCClassType() || isObjCSelType();
8189inline bool Type::isDecltypeType()
const {
8190 return isa<DecltypeType>(
this);
8193#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8194 inline bool Type::is##Id##Type() const { \
8195 return isSpecificBuiltinType(BuiltinType::Id); \
8197#include "clang/Basic/OpenCLImageTypes.def"
8199inline bool Type::isSamplerT()
const {
8200 return isSpecificBuiltinType(BuiltinType::OCLSampler);
8203inline bool Type::isEventT()
const {
8204 return isSpecificBuiltinType(BuiltinType::OCLEvent);
8207inline bool Type::isClkEventT()
const {
8208 return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
8211inline bool Type::isQueueT()
const {
8212 return isSpecificBuiltinType(BuiltinType::OCLQueue);
8215inline bool Type::isReserveIDT()
const {
8216 return isSpecificBuiltinType(BuiltinType::OCLReserveID);
8219inline bool Type::isImageType()
const {
8220#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
8222#include "clang/Basic/OpenCLImageTypes.def"
8226inline bool Type::isPipeType()
const {
8227 return isa<PipeType>(CanonicalType);
8230inline bool Type::isBitIntType()
const {
8231 return isa<BitIntType>(CanonicalType);
8234#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
8235 inline bool Type::is##Id##Type() const { \
8236 return isSpecificBuiltinType(BuiltinType::Id); \
8238#include "clang/Basic/OpenCLExtensionTypes.def"
8240inline bool Type::isOCLIntelSubgroupAVCType()
const {
8241#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
8242 isOCLIntelSubgroupAVC##Id##Type() ||
8244#include "clang/Basic/OpenCLExtensionTypes.def"
8248inline bool Type::isOCLExtOpaqueType()
const {
8249#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
8251#include "clang/Basic/OpenCLExtensionTypes.def"
8255inline bool Type::isOpenCLSpecificType()
const {
8256 return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
8257 isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
8260inline bool Type::isTemplateTypeParmType()
const {
8261 return isa<TemplateTypeParmType>(CanonicalType);
8264inline bool Type::isSpecificBuiltinType(
unsigned K)
const {
8265 if (
const BuiltinType *BT = getAs<BuiltinType>()) {
8271inline bool Type::isPlaceholderType()
const {
8272 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
8273 return BT->isPlaceholderType();
8278 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
8279 if (BT->isPlaceholderType())
8284inline bool Type::isSpecificPlaceholderType(
unsigned K)
const {
8286 return isSpecificBuiltinType(K);
8289inline bool Type::isNonOverloadPlaceholderType()
const {
8290 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
8291 return BT->isNonOverloadPlaceholderType();
8295inline bool Type::isVoidType()
const {
8296 return isSpecificBuiltinType(BuiltinType::Void);
8299inline bool Type::isHalfType()
const {
8301 return isSpecificBuiltinType(BuiltinType::Half);
8304inline bool Type::isFloat16Type()
const {
8305 return isSpecificBuiltinType(BuiltinType::Float16);
8308inline bool Type::isFloat32Type()
const {
8309 return isSpecificBuiltinType(BuiltinType::Float);
8312inline bool Type::isDoubleType()
const {
8313 return isSpecificBuiltinType(BuiltinType::Double);
8316inline bool Type::isBFloat16Type()
const {
8317 return isSpecificBuiltinType(BuiltinType::BFloat16);
8320inline bool Type::isFloat128Type()
const {
8321 return isSpecificBuiltinType(BuiltinType::Float128);
8324inline bool Type::isIbm128Type()
const {
8325 return isSpecificBuiltinType(BuiltinType::Ibm128);
8328inline bool Type::isNullPtrType()
const {
8329 return isSpecificBuiltinType(BuiltinType::NullPtr);
8335inline bool Type::isIntegerType()
const {
8336 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8337 return BT->getKind() >= BuiltinType::Bool &&
8338 BT->getKind() <= BuiltinType::Int128;
8339 if (
const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
8345 return isBitIntType();
8348inline bool Type::isFixedPointType()
const {
8349 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8350 return BT->getKind() >= BuiltinType::ShortAccum &&
8351 BT->getKind() <= BuiltinType::SatULongFract;
8356inline bool Type::isFixedPointOrIntegerType()
const {
8357 return isFixedPointType() || isIntegerType();
8360inline bool Type::isConvertibleToFixedPointType()
const {
8361 return isRealFloatingType() || isFixedPointOrIntegerType();
8364inline bool Type::isSaturatedFixedPointType()
const {
8365 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8366 return BT->getKind() >= BuiltinType::SatShortAccum &&
8367 BT->getKind() <= BuiltinType::SatULongFract;
8372inline bool Type::isUnsaturatedFixedPointType()
const {
8373 return isFixedPointType() && !isSaturatedFixedPointType();
8376inline bool Type::isSignedFixedPointType()
const {
8377 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8378 return ((BT->getKind() >= BuiltinType::ShortAccum &&
8379 BT->getKind() <= BuiltinType::LongAccum) ||
8380 (BT->getKind() >= BuiltinType::ShortFract &&
8381 BT->getKind() <= BuiltinType::LongFract) ||
8382 (BT->getKind() >= BuiltinType::SatShortAccum &&
8383 BT->getKind() <= BuiltinType::SatLongAccum) ||
8384 (BT->getKind() >= BuiltinType::SatShortFract &&
8385 BT->getKind() <= BuiltinType::SatLongFract));
8390inline bool Type::isUnsignedFixedPointType()
const {
8391 return isFixedPointType() && !isSignedFixedPointType();
8394inline bool Type::isScalarType()
const {
8395 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8396 return BT->getKind() > BuiltinType::Void &&
8397 BT->getKind() <= BuiltinType::NullPtr;
8398 if (
const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
8402 return isa<PointerType>(CanonicalType) ||
8403 isa<BlockPointerType>(CanonicalType) ||
8404 isa<MemberPointerType>(CanonicalType) ||
8405 isa<ComplexType>(CanonicalType) ||
8406 isa<ObjCObjectPointerType>(CanonicalType) ||
8410inline bool Type::isIntegralOrEnumerationType()
const {
8411 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8412 return BT->getKind() >= BuiltinType::Bool &&
8413 BT->getKind() <= BuiltinType::Int128;
8417 if (
const auto *ET = dyn_cast<EnumType>(CanonicalType))
8420 return isBitIntType();
8423inline bool Type::isBooleanType()
const {
8424 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8425 return BT->getKind() == BuiltinType::Bool;
8429inline bool Type::isUndeducedType()
const {
8430 auto *DT = getContainedDeducedType();
8431 return DT && !DT->isDeduced();
8436inline bool Type::isOverloadableType()
const {
8437 if (!isDependentType())
8439 return !isArrayType() && !isFunctionType() && !isAnyPointerType() &&
8440 !isMemberPointerType();
8444inline bool Type::isTypedefNameType()
const {
8445 if (getAs<TypedefType>())
8447 if (
auto *TST = getAs<TemplateSpecializationType>())
8448 return TST->isTypeAlias();
8453inline bool Type::canDecayToPointerType()
const {
8454 return isFunctionType() || (isArrayType() && !isArrayParameterType());
8457inline bool Type::hasPointerRepresentation()
const {
8458 return (isPointerType() || isReferenceType() || isBlockPointerType() ||
8459 isObjCObjectPointerType() || isNullPtrType());
8462inline bool Type::hasObjCPointerRepresentation()
const {
8463 return isObjCObjectPointerType();
8466inline const Type *Type::getBaseElementTypeUnsafe()
const {
8473inline const Type *Type::getPointeeOrArrayElementType()
const {
8475 if (
type->isAnyPointerType())
8476 return type->getPointeeType().getTypePtr();
8477 else if (
type->isArrayType())
8478 return type->getBaseElementTypeUnsafe();
8486 DiagnosticsEngine::ArgumentKind::ak_addrspace);
8495 DiagnosticsEngine::ArgumentKind::ak_qual);
8503 PD.
AddTaggedVal(
reinterpret_cast<uint64_t
>(
T.getAsOpaquePtr()),
8504 DiagnosticsEngine::ak_qualtype);
8510template <
typename T>
8512 std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
8513 std::is_base_of<ArrayType, T>::value>;
8516template <
typename T>
const T *Type::getAs()
const {
8518 "ArrayType cannot be used with getAs!");
8521 if (
const auto *Ty = dyn_cast<T>(
this))
8525 if (!isa<T>(CanonicalType))
8530 return cast<T>(getUnqualifiedDesugaredType());
8533template <
typename T>
const T *Type::getAsAdjusted()
const {
8537 if (
const auto *Ty = dyn_cast<T>(
this))
8541 if (!isa<T>(CanonicalType))
8546 const Type *Ty =
this;
8548 if (
const auto *A = dyn_cast<AttributedType>(Ty))
8549 Ty = A->getModifiedType().getTypePtr();
8550 else if (
const auto *A = dyn_cast<BTFTagAttributedType>(Ty))
8551 Ty = A->getWrappedType().getTypePtr();
8552 else if (
const auto *
E = dyn_cast<ElaboratedType>(Ty))
8553 Ty =
E->desugar().getTypePtr();
8554 else if (
const auto *
P = dyn_cast<ParenType>(Ty))
8555 Ty =
P->desugar().getTypePtr();
8556 else if (
const auto *A = dyn_cast<AdjustedType>(Ty))
8557 Ty = A->desugar().getTypePtr();
8558 else if (
const auto *M = dyn_cast<MacroQualifiedType>(Ty))
8559 Ty = M->desugar().getTypePtr();
8566 return dyn_cast<T>(Ty);
8571 if (
const auto *arr = dyn_cast<ArrayType>(
this))
8575 if (!isa<ArrayType>(CanonicalType))
8580 return cast<ArrayType>(getUnqualifiedDesugaredType());
8583template <
typename T>
const T *Type::castAs()
const {
8585 "ArrayType cannot be used with castAs!");
8587 if (
const auto *ty = dyn_cast<T>(
this))
return ty;
8588 assert(isa<T>(CanonicalType));
8589 return cast<T>(getUnqualifiedDesugaredType());
8592inline const ArrayType *Type::castAsArrayTypeUnsafe()
const {
8593 assert(isa<ArrayType>(CanonicalType));
8594 if (
const auto *arr = dyn_cast<ArrayType>(
this))
return arr;
8595 return cast<ArrayType>(getUnqualifiedDesugaredType());
8600 :
AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
8602 QualType Adjusted = getAdjustedType();
8604 assert(isa<PointerType>(Adjusted));
8611 return cast<PointerType>(Decayed)->getPointeeType();
8629 return FPT->getFunctionEffects();
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 std::optional< NonLoc > getIndex(ProgramStateRef State, const ElementRegion *ER, CharKind CK)
enum clang::sema::@1651::IndirectLocalPathEntry::EntryKind Kind
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 QualType getPointeeType(const MemRegion *R)
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.
void Profile(llvm::FoldingSetNodeID &ID) const
TemplateName getTemplateName() const
Retrieve the name of the template that we are deducing.
static bool classof(const Type *T)
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(const ASTContext &Context, 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)
Wrap a function effect's condition expression in another struct so that FunctionProtoType's TrailingO...
EffectConditionExpr(Expr *E)
Expr * getCondition() const
bool operator==(const EffectConditionExpr &RHS) const
EffectConditionExpr()=default
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.
Support iteration in parallel through a pair of FunctionEffect and EffectConditionExpr containers.
bool operator==(const FunctionEffectIterator &Other) const
bool operator!=(const FunctionEffectIterator &Other) const
FunctionEffectIterator operator++()
FunctionEffectIterator(const Container &O, size_t I)
FunctionEffectWithCondition operator*() const
A mutable set of FunctionEffects and possibly conditions attached to them.
FunctionEffectSet(const FunctionEffectsRef &FX)
FunctionEffectSet()=default
Represents an abstract function effect, using just an enumeration describing its kind.
Kind kind() const
The kind of the effect.
friend bool operator<(const FunctionEffect &LHS, const FunctionEffect &RHS)
friend bool operator==(const FunctionEffect &LHS, const FunctionEffect &RHS)
uint32_t toOpaqueInt32() const
For serialization.
friend bool operator!=(const FunctionEffect &LHS, const FunctionEffect &RHS)
Kind
Identifies the particular effect.
Flags flags() const
Flags describing some behaviors of the effect.
static FunctionEffect fromOpaqueInt32(uint32_t Value)
An immutable set of FunctionEffects and possibly conditions attached to them.
ArrayRef< FunctionEffect > effects() const
ArrayRef< EffectConditionExpr > conditions() const
FunctionEffectsRef()=default
friend bool operator==(const FunctionEffectsRef &LHS, const FunctionEffectsRef &RHS)
static FunctionEffectsRef get(QualType QT)
Extract the effects from a Type if it is a function, block, or member function pointer,...
friend bool operator!=(const FunctionEffectsRef &LHS, const FunctionEffectsRef &RHS)
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
unsigned getNumFunctionEffectConditions() const
ExtParameterInfo getExtParameterInfo(unsigned I) const
ArrayRef< EffectConditionExpr > getFunctionEffectConditions() const
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
ArrayRef< FunctionEffect > getFunctionEffectsWithoutConditions() const
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
FunctionEffectsRef getFunctionEffects() 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 getNumFunctionEffects() 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
bool isAddressDiscriminated() const
PointerAuthQualifier withoutKeyNone() const
unsigned getExtraDiscriminator() const
PointerAuthenticationMode getAuthenticationMode() const
@ MaxDiscriminator
The maximum supported pointer-authentication discriminator.
@ MaxKey
The maximum supported pointer-authentication key.
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.
bool isBitwiseCloneableType(const ASTContext &Context) const
Return true if the type is safe to bitwise copy using memcpy/memmove.
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.
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()
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
@ FastWidth
The width of the "fast" qualifier mask.
@ MaxAddressSpace
The maximum supported address space number.
@ FastMask
The fast qualifier mask.
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 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...
FunctionEffectWithCondition Rejected
FunctionEffectWithCondition Kept
A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e....
FunctionEffectWithCondition()=default
FunctionEffectWithCondition(const FunctionEffect &E, const EffectConditionExpr &C)
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
FunctionEffectsRef FunctionEffects
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)