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/DXILABI.h"
48#include "llvm/Support/ErrorHandling.h"
49#include "llvm/Support/PointerLikeTypeTraits.h"
50#include "llvm/Support/TrailingObjects.h"
51#include "llvm/Support/type_traits.h"
70class TemplateParameterList;
79namespace serialization {
80 template <
class T>
class AbstractTypeReader;
117template <
typename>
class CanQual;
122class ExtQualsTypeCommonBase;
124class FunctionEffectsRef;
125class FunctionEffectKindSet;
126class FunctionEffectSet;
129class ObjCInterfaceDecl;
130class ObjCProtocolDecl;
131class ObjCTypeParamDecl;
132struct PrintingPolicy;
136class TemplateArgument;
137class TemplateArgumentListInfo;
138class TemplateArgumentLoc;
139class TemplateTypeParmDecl;
140class TypedefNameDecl;
141class UnresolvedUsingTypenameDecl;
142class UsingShadowDecl;
147#define TYPE(Class, Base) class Class##Type;
148#include "clang/AST/TypeNodes.inc"
155 EnabledMask = 1 << EnabledShift,
156 AddressDiscriminatedShift = EnabledShift + EnabledBits,
157 AddressDiscriminatedBits = 1,
158 AddressDiscriminatedMask = 1 << AddressDiscriminatedShift,
159 AuthenticationModeShift =
160 AddressDiscriminatedShift + AddressDiscriminatedBits,
161 AuthenticationModeBits = 2,
162 AuthenticationModeMask = ((1 << AuthenticationModeBits) - 1)
163 << AuthenticationModeShift,
164 IsaPointerShift = AuthenticationModeShift + AuthenticationModeBits,
166 IsaPointerMask = ((1 << IsaPointerBits) - 1) << IsaPointerShift,
167 AuthenticatesNullValuesShift = IsaPointerShift + IsaPointerBits,
168 AuthenticatesNullValuesBits = 1,
169 AuthenticatesNullValuesMask = ((1 << AuthenticatesNullValuesBits) - 1)
170 << AuthenticatesNullValuesShift,
171 KeyShift = AuthenticatesNullValuesShift + AuthenticatesNullValuesBits,
173 KeyMask = ((1 << KeyBits) - 1) << KeyShift,
174 DiscriminatorShift = KeyShift + KeyBits,
175 DiscriminatorBits = 16,
176 DiscriminatorMask = ((1u << DiscriminatorBits) - 1) << DiscriminatorShift,
187 static_assert((EnabledBits + AddressDiscriminatedBits +
188 AuthenticationModeBits + IsaPointerBits +
189 AuthenticatesNullValuesBits + KeyBits + DiscriminatorBits) ==
191 "PointerAuthQualifier should be exactly 32 bits");
192 static_assert((EnabledMask + AddressDiscriminatedMask +
193 AuthenticationModeMask + IsaPointerMask +
194 AuthenticatesNullValuesMask + KeyMask + DiscriminatorMask) ==
196 "All masks should cover the entire bits");
197 static_assert((EnabledMask ^ AddressDiscriminatedMask ^
198 AuthenticationModeMask ^ IsaPointerMask ^
199 AuthenticatesNullValuesMask ^ KeyMask ^ DiscriminatorMask) ==
201 "All masks should cover the entire bits");
204 unsigned ExtraDiscriminator,
206 bool IsIsaPointer,
bool AuthenticatesNullValues)
208 (IsAddressDiscriminated
209 ? llvm::to_underlying(AddressDiscriminatedMask)
212 (llvm::to_underlying(AuthenticationMode)
213 << AuthenticationModeShift) |
214 (ExtraDiscriminator << DiscriminatorShift) |
215 (IsIsaPointer << IsaPointerShift) |
216 (AuthenticatesNullValues << AuthenticatesNullValuesShift)) {
219 assert((
Data == 0) ==
238 Create(
unsigned Key,
bool IsAddressDiscriminated,
unsigned ExtraDiscriminator,
240 bool AuthenticatesNullValues) {
245 AuthenticationMode, IsIsaPointer,
246 AuthenticatesNullValues);
250 assert((
Data == 0) ==
259 return (
Data & KeyMask) >> KeyShift;
266 return (
Data & AddressDiscriminatedMask) >> AddressDiscriminatedShift;
271 return (
Data >> DiscriminatorShift);
276 AuthenticationModeShift);
281 return (
Data & IsaPointerMask) >> IsaPointerShift;
286 return (
Data & AuthenticatesNullValuesMask) >> AuthenticatesNullValuesShift;
294 return Lhs.Data == Rhs.Data;
297 return Lhs.Data != Rhs.Data;
310 assert((
Result.Data == 0) ==
391 Q.Mask = L.Mask & R.Mask;
485 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
486 Mask = (Mask & ~CVRMask) | mask;
489 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
490 Mask &= ~static_cast<uint64_t>(mask);
496 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
500 assert(!(mask & ~
CVRMask & ~UMask) &&
"bitmask contains non-CVRU bits");
506 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
514 Mask = (Mask & ~GCAttrMask) | (
type << GCAttrShift);
539 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
542 Mask = (Mask & ~LifetimeMask) | (
type << LifetimeShift);
548 Mask |= (
type << LifetimeShift);
565 return static_cast<LangAS>(Mask >> AddressSpaceShift);
586 Mask = (Mask & ~AddressSpaceMask)
587 | (((uint32_t) space) << AddressSpaceShift);
600 Mask = (Mask & ~PtrAuthMask) |
614 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
615 Mask = (Mask & ~FastMask) | mask;
618 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
619 Mask &= ~static_cast<uint64_t>(mask);
625 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
640 bool empty()
const {
return !Mask; }
795 bool appendSpaceIfNonEmpty =
false)
const;
797 void Profile(llvm::FoldingSetNodeID &
ID)
const {
ID.AddInteger(Mask); }
804 "PointerAuthQualifier must be 32 bits");
806 static constexpr uint64_t UMask = 0x8;
807 static constexpr uint64_t UShift = 3;
808 static constexpr uint64_t GCAttrMask = 0x30;
809 static constexpr uint64_t GCAttrShift = 4;
810 static constexpr uint64_t LifetimeMask = 0x1C0;
811 static constexpr uint64_t LifetimeShift = 6;
812 static constexpr uint64_t AddressSpaceMask =
813 ~(
CVRMask | UMask | GCAttrMask | LifetimeMask);
814 static constexpr uint64_t AddressSpaceShift = 9;
815 static constexpr uint64_t PtrAuthShift = 32;
816 static constexpr uint64_t PtrAuthMask = uint64_t(0xffffffff) << PtrAuthShift;
826 : Quals(Quals), HasAtomic(HasAtomic) {}
875 std::pair<const Type *,Qualifiers>
asPair()
const {
876 return std::pair<const Type *, Qualifiers>(
Ty,
Quals);
880 return a.
Ty ==
b.Ty && a.
Quals ==
b.Quals;
883 return a.
Ty !=
b.Ty || a.
Quals !=
b.Quals;
933 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
936 const ExtQuals *getExtQualsUnsafe()
const {
937 return cast<const ExtQuals *>(
Value.getPointer());
940 const Type *getTypePtrUnsafe()
const {
941 return cast<const Type *>(
Value.getPointer());
944 const ExtQualsTypeCommonBase *getCommonPtr()
const {
945 assert(!
isNull() &&
"Cannot retrieve a NULL type pointer");
946 auto CommonPtrVal =
reinterpret_cast<uintptr_t>(
Value.getOpaqueValue());
948 return reinterpret_cast<ExtQualsTypeCommonBase*
>(CommonPtrVal);
980 T.Value.setFromOpaqueValue(
const_cast<void*
>(Ptr));
997 return Value.getPointer().isNull();
1024 std::optional<NonConstantStorageReason>
1067 return isa<const ExtQuals *>(
Value.getPointer());
1180 &&
"non-fast qualifier bits set in mask!");
1198 T.addFastQualifiers(TQs);
1211 T.removeLocalFastQualifiers();
1305 return getSingleStepDesugaredTypeImpl(*
this, Context);
1311 if (isa<ParenType>(*
this))
1318 return LHS.Value == RHS.Value;
1321 return LHS.Value != RHS.Value;
1324 return LHS.Value < RHS.Value;
1338 const Twine &PlaceHolder = Twine(),
1339 unsigned Indentation = 0)
const;
1343 unsigned Indentation = 0) {
1349 const Twine &PlaceHolder,
1350 unsigned Indentation = 0);
1367 const Twine &PlaceHolder;
1368 unsigned Indentation;
1372 const Twine &PlaceHolder,
unsigned Indentation)
1373 :
T(
T), Policy(Policy), PlaceHolder(PlaceHolder),
1374 Indentation(Indentation) {}
1378 SQT.T.
print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1384 const Twine &PlaceHolder = Twine(),
1385 unsigned Indentation = 0)
const {
1389 void dump(
const char *
s)
const;
1391 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
1532 return isDestructedTypeImpl(*
this);
1634raw_ostream &
operator<<(raw_ostream &OS, QualType QT);
1654 return P.getAsOpaquePtr();
1662 static constexpr int NumLowBitsAvailable = 0;
1683 const Type *
const BaseType;
1689 : BaseType(baseType), CanonicalType(canon) {}
1703 public llvm::FoldingSetNode {
1726 canon.isNull() ?
QualType(this_(), 0) : canon),
1728 assert(Quals.hasNonFastQualifiers()
1729 &&
"ExtQuals created with no fast qualifiers");
1730 assert(!Quals.hasFastQualifiers()
1731 &&
"ExtQuals created with fast qualifiers");
1741 return Quals.getObjCLifetime();
1751 Profile(
ID, getBaseType(), Quals);
1755 const Type *BaseType,
1758 ID.AddPointer(BaseType);
1798enum class ArraySizeModifier;
1799enum class ElaboratedTypeKeyword;
1800enum class VectorKind;
1831#define TYPE(Class, Base) Class,
1832#define LAST_TYPE(Class) TypeLast = Class
1833#define ABSTRACT_TYPE(Class, Base)
1834#include "clang/AST/TypeNodes.inc"
1839 class TypeBitfields {
1841 template <
class T>
friend class TypePropertyCache;
1844 LLVM_PREFERRED_TYPE(TypeClass)
1849 unsigned Dependence : llvm::BitWidth<TypeDependence>;
1853 LLVM_PREFERRED_TYPE(
bool)
1854 mutable unsigned CacheValid : 1;
1858 mutable unsigned CachedLinkage : 3;
1861 LLVM_PREFERRED_TYPE(
bool)
1862 mutable unsigned CachedLocalOrUnnamed : 1;
1865 LLVM_PREFERRED_TYPE(
bool)
1866 mutable unsigned FromAST : 1;
1868 bool isCacheValid()
const {
1873 assert(isCacheValid() &&
"getting linkage from invalid cache");
1874 return static_cast<Linkage>(CachedLinkage);
1877 bool hasLocalOrUnnamedType()
const {
1878 assert(isCacheValid() &&
"getting linkage from invalid cache");
1879 return CachedLocalOrUnnamed;
1882 enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
1891 LLVM_PREFERRED_TYPE(TypeBitfields)
1897 unsigned IndexTypeQuals : 3;
1902 unsigned SizeModifier : 3;
1904 enum { NumArrayTypeBits = NumTypeBits + 6 };
1913 LLVM_PREFERRED_TYPE(
bool)
1914 unsigned HasExternalSize : 1;
1916 LLVM_PREFERRED_TYPE(
unsigned)
1917 unsigned SizeWidth : 5;
1923 LLVM_PREFERRED_TYPE(TypeBitfields)
1927 static constexpr unsigned NumOfBuiltinTypeBits = 9;
1928 unsigned Kind : NumOfBuiltinTypeBits;
1932 static constexpr int FunctionTypeNumParamsWidth = 16;
1933 static constexpr int FunctionTypeNumParamsLimit = (1 << 16) - 1;
1943 LLVM_PREFERRED_TYPE(TypeBitfields)
1949 unsigned ExtInfo : 13;
1955 unsigned RefQualifier : 2;
1964 unsigned FastTypeQuals : Qualifiers::FastWidth;
1966 LLVM_PREFERRED_TYPE(
bool)
1967 unsigned HasExtQuals : 1;
1973 unsigned NumParams : FunctionTypeNumParamsWidth;
1977 unsigned ExceptionSpecType : 4;
1980 LLVM_PREFERRED_TYPE(
bool)
1981 unsigned HasExtParameterInfos : 1;
1984 LLVM_PREFERRED_TYPE(
bool)
1985 unsigned HasExtraBitfields : 1;
1988 LLVM_PREFERRED_TYPE(
bool)
1989 unsigned Variadic : 1;
1992 LLVM_PREFERRED_TYPE(
bool)
1993 unsigned HasTrailingReturn : 1;
1999 LLVM_PREFERRED_TYPE(TypeBitfields)
2003 unsigned NumTypeArgs : 7;
2006 unsigned NumProtocols : 6;
2009 LLVM_PREFERRED_TYPE(
bool)
2010 unsigned IsKindOf : 1;
2016 LLVM_PREFERRED_TYPE(TypeBitfields)
2030 LLVM_PREFERRED_TYPE(
bool)
2031 unsigned SpelledAsLValue : 1;
2035 LLVM_PREFERRED_TYPE(
bool)
2036 unsigned InnerRef : 1;
2042 LLVM_PREFERRED_TYPE(TypeBitfields)
2047 unsigned Keyword : 8;
2050 enum { NumTypeWithKeywordBits = NumTypeBits + 8 };
2059 LLVM_PREFERRED_TYPE(
bool)
2060 unsigned HasOwnedTagDecl : 1;
2067 LLVM_PREFERRED_TYPE(TypeBitfields)
2073 unsigned VecKind : 4;
2075 uint32_t NumElements;
2081 LLVM_PREFERRED_TYPE(TypeBitfields)
2085 unsigned AttrKind : 32 - NumTypeBits;
2091 LLVM_PREFERRED_TYPE(TypeBitfields)
2097 unsigned Keyword : 2;
2113 LLVM_PREFERRED_TYPE(TypeBitfields)
2122 LLVM_PREFERRED_TYPE(TypeBitfields)
2126 LLVM_PREFERRED_TYPE(
bool)
2127 unsigned hasTypeDifferentFromDecl : 1;
2133 LLVM_PREFERRED_TYPE(TypeBitfields)
2137 LLVM_PREFERRED_TYPE(
bool)
2138 unsigned hasTypeDifferentFromDecl : 1;
2144 LLVM_PREFERRED_TYPE(TypeBitfields)
2148 unsigned Depth : 15;
2151 LLVM_PREFERRED_TYPE(
bool)
2152 unsigned ParameterPack : 1;
2155 unsigned Index : 16;
2161 LLVM_PREFERRED_TYPE(TypeBitfields)
2164 LLVM_PREFERRED_TYPE(
bool)
2165 unsigned HasNonCanonicalUnderlyingType : 1;
2168 unsigned SubstitutionFlag : 1;
2171 unsigned Index : 15;
2178 unsigned PackIndex : 16;
2184 LLVM_PREFERRED_TYPE(TypeBitfields)
2188 unsigned Index : 16;
2194 unsigned NumArgs : 16;
2200 LLVM_PREFERRED_TYPE(TypeBitfields)
2204 LLVM_PREFERRED_TYPE(
bool)
2205 unsigned TypeAlias : 1;
2236 LLVM_PREFERRED_TYPE(TypeBitfields)
2250 unsigned NumExpansions;
2256 LLVM_PREFERRED_TYPE(TypeBitfields)
2259 static constexpr unsigned NumCoupledDeclsBits = 4;
2260 unsigned NumCoupledDecls : NumCoupledDeclsBits;
2261 LLVM_PREFERRED_TYPE(
bool)
2262 unsigned CountInBytes : 1;
2263 LLVM_PREFERRED_TYPE(
bool)
2264 unsigned OrNull : 1;
2298 void setFromAST(
bool V =
true)
const {
2299 TypeBits.FromAST =
V;
2307 canon.isNull() ?
QualType(this_(), 0) : canon) {
2308 static_assert(
sizeof(*this) <=
2310 "changing bitfields changed sizeof(Type)!");
2311 static_assert(
alignof(
decltype(*this)) %
TypeAlignment == 0,
2312 "Insufficient alignment!");
2314 TypeBits.Dependence =
static_cast<unsigned>(
Dependence);
2315 TypeBits.CacheValid =
false;
2316 TypeBits.CachedLocalOrUnnamed =
false;
2317 TypeBits.CachedLinkage = llvm::to_underlying(Linkage::Invalid);
2318 TypeBits.FromAST =
false;
2325 TypeBits.Dependence =
static_cast<unsigned>(
D);
2362 return getDependence() & TypeDependence::UnexpandedPack;
2368 return CanonicalType ==
QualType(
this, 0);
2374 QualType getLocallyUnqualifiedSingleStepDesugaredType()
const;
2382 bool isSizelessType()
const;
2383 bool isSizelessBuiltinType()
const;
2386 bool isSizelessVectorType()
const;
2389 bool isSVESizelessBuiltinType()
const;
2392 bool isRVVSizelessBuiltinType()
const;
2395 bool isWebAssemblyExternrefType()
const;
2400 bool isWebAssemblyTableType()
const;
2405 bool isSveVLSBuiltinType()
const;
2415 bool isRVVVLSBuiltinType()
const;
2437 bool isIncompleteType(
NamedDecl **Def =
nullptr)
const;
2442 return !isFunctionType();
2450 return !isReferenceType() && !isFunctionType() && !isVoidType();
2455 bool isLiteralType(
const ASTContext &Ctx)
const;
2458 bool isStructuralType()
const;
2462 bool isStandardLayoutType()
const;
2468 bool isBuiltinType()
const;
2471 bool isSpecificBuiltinType(
unsigned K)
const;
2476 bool isPlaceholderType()
const;
2480 bool isSpecificPlaceholderType(
unsigned K)
const;
2484 bool isNonOverloadPlaceholderType()
const;
2488 bool isIntegerType()
const;
2489 bool isEnumeralType()
const;
2492 bool isScopedEnumeralType()
const;
2494 bool isCharType()
const;
2495 bool isWideCharType()
const;
2496 bool isChar8Type()
const;
2497 bool isChar16Type()
const;
2498 bool isChar32Type()
const;
2499 bool isAnyCharacterType()
const;
2500 bool isIntegralType(
const ASTContext &Ctx)
const;
2503 bool isIntegralOrEnumerationType()
const;
2506 bool isIntegralOrUnscopedEnumerationType()
const;
2507 bool isUnscopedEnumerationType()
const;
2510 bool isRealFloatingType()
const;
2513 bool isComplexType()
const;
2514 bool isAnyComplexType()
const;
2515 bool isFloatingType()
const;
2516 bool isHalfType()
const;
2517 bool isFloat16Type()
const;
2518 bool isFloat32Type()
const;
2519 bool isDoubleType()
const;
2520 bool isBFloat16Type()
const;
2521 bool isFloat128Type()
const;
2522 bool isIbm128Type()
const;
2523 bool isRealType()
const;
2524 bool isArithmeticType()
const;
2525 bool isVoidType()
const;
2526 bool isScalarType()
const;
2527 bool isAggregateType()
const;
2528 bool isFundamentalType()
const;
2529 bool isCompoundType()
const;
2533 bool isFunctionType()
const;
2536 bool isPointerType()
const;
2537 bool isPointerOrReferenceType()
const;
2538 bool isSignableType()
const;
2539 bool isAnyPointerType()
const;
2540 bool isCountAttributedType()
const;
2541 bool isBlockPointerType()
const;
2542 bool isVoidPointerType()
const;
2543 bool isReferenceType()
const;
2544 bool isLValueReferenceType()
const;
2545 bool isRValueReferenceType()
const;
2546 bool isObjectPointerType()
const;
2547 bool isFunctionPointerType()
const;
2548 bool isFunctionReferenceType()
const;
2549 bool isMemberPointerType()
const;
2550 bool isMemberFunctionPointerType()
const;
2551 bool isMemberDataPointerType()
const;
2552 bool isArrayType()
const;
2553 bool isConstantArrayType()
const;
2554 bool isIncompleteArrayType()
const;
2555 bool isVariableArrayType()
const;
2556 bool isArrayParameterType()
const;
2557 bool isDependentSizedArrayType()
const;
2559 bool isClassType()
const;
2560 bool isStructureType()
const;
2561 bool isStructureTypeWithFlexibleArrayMember()
const;
2562 bool isObjCBoxableRecordType()
const;
2563 bool isInterfaceType()
const;
2564 bool isStructureOrClassType()
const;
2565 bool isUnionType()
const;
2566 bool isComplexIntegerType()
const;
2567 bool isVectorType()
const;
2568 bool isExtVectorType()
const;
2569 bool isExtVectorBoolType()
const;
2570 bool isSubscriptableVectorType()
const;
2571 bool isMatrixType()
const;
2572 bool isConstantMatrixType()
const;
2573 bool isDependentAddressSpaceType()
const;
2574 bool isObjCObjectPointerType()
const;
2575 bool isObjCRetainableType()
const;
2576 bool isObjCLifetimeType()
const;
2577 bool isObjCIndirectLifetimeType()
const;
2578 bool isObjCNSObjectType()
const;
2579 bool isObjCIndependentClassType()
const;
2582 bool isObjCObjectType()
const;
2583 bool isObjCQualifiedInterfaceType()
const;
2584 bool isObjCQualifiedIdType()
const;
2585 bool isObjCQualifiedClassType()
const;
2586 bool isObjCObjectOrInterfaceType()
const;
2587 bool isObjCIdType()
const;
2588 bool isDecltypeType()
const;
2596 return hasAttr(attr::ObjCInertUnsafeUnretained);
2606 bool isObjCIdOrObjectKindOfType(
const ASTContext &ctx,
2609 bool isObjCClassType()
const;
2617 bool isObjCClassOrClassKindOfType()
const;
2619 bool isBlockCompatibleObjCPointerType(
ASTContext &ctx)
const;
2620 bool isObjCSelType()
const;
2621 bool isObjCBuiltinType()
const;
2622 bool isObjCARCBridgableType()
const;
2623 bool isCARCBridgableType()
const;
2624 bool isTemplateTypeParmType()
const;
2625 bool isNullPtrType()
const;
2627 bool isNothrowT()
const;
2628 bool isAlignValT()
const;
2629 bool isStdByteType()
const;
2630 bool isAtomicType()
const;
2631 bool isUndeducedAutoType()
const;
2633 bool isTypedefNameType()
const;
2635#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2636 bool is##Id##Type() const;
2637#include "clang/Basic/OpenCLImageTypes.def"
2639 bool isImageType()
const;
2641 bool isSamplerT()
const;
2642 bool isEventT()
const;
2643 bool isClkEventT()
const;
2644 bool isQueueT()
const;
2645 bool isReserveIDT()
const;
2647#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2648 bool is##Id##Type() const;
2649#include "clang/Basic/OpenCLExtensionTypes.def"
2651 bool isOCLIntelSubgroupAVCType()
const;
2652 bool isOCLExtOpaqueType()
const;
2654 bool isPipeType()
const;
2655 bool isBitIntType()
const;
2656 bool isOpenCLSpecificType()
const;
2658#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) bool is##Id##Type() const;
2659#include "clang/Basic/HLSLIntangibleTypes.def"
2660 bool isHLSLSpecificType()
const;
2661 bool isHLSLBuiltinIntangibleType()
const;
2662 bool isHLSLAttributedResourceType()
const;
2663 bool isHLSLIntangibleType()
2669 bool isObjCARCImplicitlyUnretainedType()
const;
2672 bool isCUDADeviceBuiltinSurfaceType()
const;
2674 bool isCUDADeviceBuiltinTextureType()
const;
2693 ScalarTypeKind getScalarTypeKind()
const;
2701 return getDependence() & TypeDependence::Error;
2707 return getDependence() & TypeDependence::Dependent;
2715 return getDependence() & TypeDependence::Instantiation;
2721 bool isUndeducedType()
const;
2725 return getDependence() & TypeDependence::VariablyModified;
2730 bool hasSizedVLAType()
const;
2733 bool hasUnnamedOrLocalType()
const;
2735 bool isOverloadableType()
const;
2738 bool isElaboratedTypeSpecifier()
const;
2740 bool canDecayToPointerType()
const;
2745 bool hasPointerRepresentation()
const;
2749 bool hasObjCPointerRepresentation()
const;
2753 bool hasIntegerRepresentation()
const;
2757 bool hasSignedIntegerRepresentation()
const;
2761 bool hasUnsignedIntegerRepresentation()
const;
2765 bool hasFloatingRepresentation()
const;
2770 const RecordType *getAsStructureType()
const;
2773 const ComplexType *getAsComplexIntegerType()
const;
2794 TagDecl *getAsTagDecl()
const;
2812 return dyn_cast_or_null<AutoType>(getContainedDeducedType());
2818 bool hasAutoForTrailingReturnType()
const;
2826 template <
typename T>
const T *getAs()
const;
2833 template <
typename T>
const T *getAsAdjusted()
const;
2837 const ArrayType *getAsArrayTypeUnsafe()
const;
2845 template <
typename T>
const T *castAs()
const;
2849 const ArrayType *castAsArrayTypeUnsafe()
const;
2858 const Type *getBaseElementTypeUnsafe()
const;
2863 const Type *getArrayElementTypeNoTypeQual()
const;
2868 const Type *getPointeeOrArrayElementType()
const;
2876 const Type *getUnqualifiedDesugaredType()
const;
2881 bool isSignedIntegerType()
const;
2886 bool isUnsignedIntegerType()
const;
2890 bool isSignedIntegerOrEnumerationType()
const;
2894 bool isUnsignedIntegerOrEnumerationType()
const;
2898 bool isFixedPointType()
const;
2901 bool isFixedPointOrIntegerType()
const;
2904 bool isConvertibleToFixedPointType()
const;
2908 bool isSaturatedFixedPointType()
const;
2912 bool isUnsaturatedFixedPointType()
const;
2916 bool isSignedFixedPointType()
const;
2920 bool isUnsignedFixedPointType()
const;
2925 bool isConstantSizeType()
const;
2929 bool isSpecifierType()
const;
2936 return getLinkageAndVisibility().getVisibility();
2941 return getLinkageAndVisibility().isVisibilityExplicit();
2949 bool isLinkageValid()
const;
2956 std::optional<NullabilityKind> getNullability()
const;
2963 bool canHaveNullability(
bool ResultIfUnknown =
true)
const;
2980 std::optional<ArrayRef<QualType>>
2981 getObjCSubstitutions(
const DeclContext *dc)
const;
2985 bool acceptsObjCTypeParams()
const;
2987 const char *getTypeClassName()
const;
2990 return CanonicalType;
2995 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
3000template <>
const TypedefType *Type::getAs()
const;
3001template <>
const UsingType *Type::getAs()
const;
3006template <>
const TemplateSpecializationType *Type::getAs()
const;
3010template <>
const AttributedType *Type::getAs()
const;
3014template <>
const BoundsAttributedType *Type::getAs()
const;
3018template <>
const CountAttributedType *Type::getAs()
const;
3022#define TYPE(Class, Base)
3023#define LEAF_TYPE(Class) \
3024template <> inline const Class##Type *Type::getAs() const { \
3025 return dyn_cast<Class##Type>(CanonicalType); \
3027template <> inline const Class##Type *Type::castAs() const { \
3028 return cast<Class##Type>(CanonicalType); \
3030#include "clang/AST/TypeNodes.inc"
3038#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
3039#include "clang/Basic/OpenCLImageTypes.def"
3041#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
3042#include "clang/Basic/OpenCLExtensionTypes.def"
3044#define SVE_TYPE(Name, Id, SingletonId) Id,
3045#include "clang/Basic/AArch64SVEACLETypes.def"
3047#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
3048#include "clang/Basic/PPCTypes.def"
3050#define RVV_TYPE(Name, Id, SingletonId) Id,
3051#include "clang/Basic/RISCVVTypes.def"
3053#define WASM_TYPE(Name, Id, SingletonId) Id,
3054#include "clang/Basic/WebAssemblyReferenceTypes.def"
3056#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) Id,
3057#include "clang/Basic/AMDGPUTypes.def"
3059#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) Id,
3060#include "clang/Basic/HLSLIntangibleTypes.def"
3062#define BUILTIN_TYPE(Id, SingletonId) Id,
3063#define LAST_BUILTIN_TYPE(Id) LastKind = Id
3064#include "clang/AST/BuiltinTypes.def"
3074 static_assert(Kind::LastKind <
3075 (1 << BuiltinTypeBitfields::NumOfBuiltinTypeBits) &&
3076 "Defined builtin type exceeds the allocated space for serial "
3078 BuiltinTypeBits.Kind = K;
3087 StringRef str =
getName(Policy);
3088 assert(!str.empty() && str.data()[str.size()] ==
'\0');
3117 return K >= Overload;
3124 return isPlaceholderTypeKind(
getKind());
3151 :
Type(
Complex, CanonicalPtr, Element->getDependence()),
3152 ElementType(Element) {}
3161 Profile(
ID, getElementType());
3165 ID.AddPointer(Element.getAsOpaquePtr());
3178 :
Type(
Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}
3187 Profile(
ID, getInnerType());
3204 :
Type(
Pointer, CanonicalPtr, Pointee->getDependence()),
3205 PointeeType(Pointee) {}
3228 using BaseTy = llvm::PointerIntPair<ValueDecl *, 1, unsigned>;
3243 bool isDeref()
const;
3245 unsigned getInt()
const;
3246 void *getOpaqueValue()
const;
3248 void setFromOpaqueValue(
void *
V);
3279 return decl_range(dependent_decl_begin(), dependent_decl_end());
3283 return {dependent_decl_begin(), dependent_decl_end()};
3286 bool referencesFieldDecls()
const;
3293 case CountAttributed:
3305 public llvm::TrailingObjects<CountAttributedType,
3306 TypeCoupledDeclRefInfo> {
3317 bool CountInBytes,
bool OrNull,
3320 unsigned numTrailingObjects(OverloadToken<TypeCoupledDeclRefInfo>)
const {
3321 return CountAttributedTypeBits.NumCoupledDecls;
3334 bool isOrNull()
const {
return CountAttributedTypeBits.OrNull; }
3338 return isCountInBytes() ? SizedByOrNull : CountedByOrNull;
3339 return isCountInBytes() ? SizedBy : CountedBy;
3343 Profile(
ID, desugar(), CountExpr, isCountInBytes(), isOrNull());
3346 static void Profile(llvm::FoldingSetNodeID &
ID,
QualType WrappedTy,
3347 Expr *CountExpr,
bool CountInBytes,
bool Nullable);
3366 :
Type(TC, CanonicalPtr, OriginalTy->getDependence()),
3367 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
3377 Profile(
ID, OriginalTy, AdjustedTy);
3415 :
Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
3416 PointeeType(Pointee) {}
3444 bool SpelledAsLValue)
3445 :
Type(tc, CanonicalRef, Referencee->getDependence()),
3446 PointeeType(Referencee) {
3447 ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
3460 while (
T->isInnerRef())
3462 return T->PointeeType;
3466 Profile(
ID, PointeeType, isSpelledAsLValue());
3471 bool SpelledAsLValue) {
3473 ID.AddBoolean(SpelledAsLValue);
3487 bool SpelledAsLValue)
3529 :
Type(MemberPointer, CanonicalPtr,
3531 Pointee->getDependence()),
3532 PointeeType(Pointee),
Class(Cls) {}
3560 const Type *Class) {
3586 unsigned tq,
const Expr *sz =
nullptr);
3596 return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
3600 return ArrayTypeBits.IndexTypeQuals;
3618 struct ExternalSize {
3619 ExternalSize(
const llvm::APInt &Sz,
const Expr *SE)
3620 : Size(Sz), SizeExpr(SE) {}
3622 const Expr *SizeExpr;
3632 :
ArrayType(ConstantArray, Et, Can,
SM, TQ, nullptr), Size(Sz) {
3633 ConstantArrayTypeBits.HasExternalSize =
false;
3634 ConstantArrayTypeBits.SizeWidth = Width / 8;
3637 assert(Width < 0xFF &&
"Type width in bits must be less than 8 bits");
3640 ConstantArrayType(QualType Et, QualType Can, ExternalSize *SzPtr,
3641 ArraySizeModifier
SM,
unsigned TQ)
3642 : ArrayType(ConstantArray, Et, Can,
SM, TQ, SzPtr->SizeExpr),
3644 ConstantArrayTypeBits.HasExternalSize =
true;
3645 ConstantArrayTypeBits.SizeWidth = 0;
3647 assert((SzPtr->SizeExpr ==
nullptr || !Can.isNull()) &&
3648 "canonical constant array should not have size expression");
3651 static ConstantArrayType *
Create(
const ASTContext &Ctx, QualType ET,
3652 QualType Can,
const llvm::APInt &Sz,
3653 const Expr *SzExpr, ArraySizeModifier SzMod,
3658 :
ArrayType(Tc, ATy->getElementType(), Can, ATy->getSizeModifier(),
3659 ATy->getIndexTypeQualifiers().getAsOpaqueValue(), nullptr) {
3660 ConstantArrayTypeBits.HasExternalSize =
3662 if (!ConstantArrayTypeBits.HasExternalSize) {
3672 return ConstantArrayTypeBits.HasExternalSize
3674 : llvm::APInt(ConstantArrayTypeBits.SizeWidth * 8, Size);
3679 return ConstantArrayTypeBits.HasExternalSize
3680 ? SizePtr->Size.getBitWidth()
3681 :
static_cast<unsigned>(ConstantArrayTypeBits.SizeWidth * 8);
3686 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.isZero()
3692 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.getZExtValue()
3698 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.getSExtValue()
3699 :
static_cast<int64_t
>(Size);
3705 return ConstantArrayTypeBits.HasExternalSize
3706 ? SizePtr->Size.getLimitedValue()
3712 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->SizeExpr :
nullptr;
3720 static unsigned getNumAddressingBits(
const ASTContext &Context,
3722 const llvm::APInt &NumElements);
3724 unsigned getNumAddressingBits(
const ASTContext &Context)
const;
3728 static unsigned getMaxSizeBits(
const ASTContext &Context);
3731 Profile(
ID, Ctx, getElementType(), getZExtSize(), getSizeExpr(),
3732 getSizeModifier(), getIndexTypeCVRQualifiers());
3735 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx,
3769 :
ArrayType(IncompleteArray, et, can, sm, tq) {}
3782 Profile(
ID, getElementType(), getSizeModifier(),
3783 getIndexTypeCVRQualifiers());
3789 ID.AddInteger(llvm::to_underlying(SizeMod));
3790 ID.AddInteger(TypeQuals);
3821 :
ArrayType(VariableArray, et, can, sm, tq, e),
3822 SizeExpr((
Stmt*) e), Brackets(brackets) {}
3830 return (
Expr*) SizeExpr;
3845 llvm_unreachable(
"Cannot unique VariableArrayTypes.");
3885 return (
Expr*) SizeExpr;
3900 Profile(
ID, Context, getElementType(),
3901 getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
3904 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
3906 unsigned TypeQuals,
Expr *
E);
3923 Expr *AddrSpaceExpr;
3946 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
3986 Profile(
ID, Context, getElementType(), getSizeExpr());
3989 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
4059 Profile(
ID, getElementType(), getNumElements(),
4060 getTypeClass(), getVectorKind());
4067 ID.AddInteger(NumElements);
4069 ID.AddInteger(llvm::to_underlying(VecKind));
4112 Profile(
ID, Context, getElementType(), getSizeExpr(), getVectorKind());
4115 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
4130 :
VectorType(ExtVector, vecType, nElements, canonType,
4137 case 'x':
case 'r':
return 0;
4138 case 'y':
case 'g':
return 1;
4139 case 'z':
case 'b':
return 2;
4140 case 'w':
case 'a':
return 3;
4158 case 'a':
return 10;
4160 case 'b':
return 11;
4162 case 'c':
return 12;
4164 case 'd':
return 13;
4166 case 'e':
return 14;
4168 case 'f':
return 15;
4173 if (isNumericAccessor)
4174 return getNumericAccessorIdx(
c);
4176 return getPointAccessorIdx(
c);
4180 if (
int idx = getAccessorIdx(
c, isNumericAccessor)+1)
4181 return unsigned(idx-1) < getNumElements();
4206 const Expr *RowExpr =
nullptr,
const Expr *ColumnExpr =
nullptr);
4240 static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;
4243 unsigned NColumns,
QualType CanonElementType);
4246 unsigned NColumns,
QualType CanonElementType);
4257 return getNumRows() * getNumColumns();
4262 return NumElements > 0 && NumElements <= MaxElementsPerDimension;
4267 return MaxElementsPerDimension;
4271 Profile(
ID, getElementType(), getNumRows(), getNumColumns(),
4276 unsigned NumRows,
unsigned NumColumns,
4279 ID.AddInteger(NumRows);
4280 ID.AddInteger(NumColumns);
4312 Profile(
ID, Context, getElementType(), getRowExpr(), getColumnExpr());
4315 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
4351 HasPassObjSize = 0x20,
4354 unsigned char Data = 0;
4363 copy.Data = (copy.Data & ~ABIMask) |
unsigned(kind);
4373 copy.Data |= IsConsumed;
4375 copy.Data &= ~IsConsumed;
4382 Copy.Data |= HasPassObjSize;
4390 Copy.Data |= IsNoEscape;
4392 Copy.Data &= ~IsNoEscape;
4404 return lhs.Data == rhs.Data;
4408 return lhs.Data != rhs.Data;
4443 enum { CallConvMask = 0x1F };
4444 enum { NoReturnMask = 0x20 };
4445 enum { ProducesResultMask = 0x40 };
4446 enum { NoCallerSavedRegsMask = 0x80 };
4448 RegParmMask = 0x700,
4451 enum { NoCfCheckMask = 0x800 };
4452 enum { CmseNSCallMask = 0x1000 };
4453 uint16_t Bits =
CC_C;
4455 ExtInfo(
unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
4461 bool producesResult,
bool noCallerSavedRegs,
bool NoCfCheck,
4463 assert((!hasRegParm || regParm < 7) &&
"Invalid regparm value");
4464 Bits = ((
unsigned)cc) | (noReturn ? NoReturnMask : 0) |
4465 (producesResult ? ProducesResultMask : 0) |
4466 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
4467 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
4468 (NoCfCheck ? NoCfCheckMask : 0) |
4469 (cmseNSCall ? CmseNSCallMask : 0);
4485 bool getHasRegParm()
const {
return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
4488 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
4497 return Bits ==
Other.Bits;
4500 return Bits !=
Other.Bits;
4508 return ExtInfo(Bits | NoReturnMask);
4510 return ExtInfo(Bits & ~NoReturnMask);
4515 return ExtInfo(Bits | ProducesResultMask);
4517 return ExtInfo(Bits & ~ProducesResultMask);
4522 return ExtInfo(Bits | CmseNSCallMask);
4524 return ExtInfo(Bits & ~CmseNSCallMask);
4528 if (noCallerSavedRegs)
4529 return ExtInfo(Bits | NoCallerSavedRegsMask);
4531 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
4536 return ExtInfo(Bits | NoCfCheckMask);
4538 return ExtInfo(Bits & ~NoCfCheckMask);
4542 assert(RegParm < 7 &&
"Invalid regparm value");
4543 return ExtInfo((Bits & ~RegParmMask) |
4544 ((RegParm + 1) << RegParmOffset));
4548 return ExtInfo((Bits & ~CallConvMask) | (
unsigned) cc);
4552 ID.AddInteger(Bits);
4570 LLVM_PREFERRED_TYPE(
bool)
4573 LLVM_PREFERRED_TYPE(
bool)
4574 unsigned EffectsHaveConditions : 1;
4575 unsigned NumFunctionEffects : 4;
4578 : NumExceptionType(0), HasArmTypeAttributes(
false),
4579 EffectsHaveConditions(
false), NumFunctionEffects(0) {}
4586 SME_NormalFunction = 0,
4587 SME_PStateSMEnabledMask = 1 << 0,
4588 SME_PStateSMCompatibleMask = 1 << 1,
4592 SME_ZAMask = 0b111 << SME_ZAShift,
4594 SME_ZT0Mask = 0b111 << SME_ZT0Shift,
4610 return (
ArmStateValue)((AttrBits & SME_ZAMask) >> SME_ZAShift);
4614 return (
ArmStateValue)((AttrBits & SME_ZT0Mask) >> SME_ZT0Shift);
4632 FunctionTypeBits.ExtInfo = Info.Bits;
4636 if (isFunctionProtoType())
4637 return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
4657 static_assert((
~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
4658 "Const, volatile and restrict are assumed to be a subset of "
4659 "the fast qualifiers.");
4661 bool isConst()
const {
return getFastTypeQuals().hasConst(); }
4662 bool isVolatile()
const {
return getFastTypeQuals().hasVolatile(); }
4663 bool isRestrict()
const {
return getFastTypeQuals().hasRestrict(); }
4671 static StringRef getNameForCallConv(
CallingConv CC);
4686 Result->getDependence() &
4698 Profile(
ID, getReturnType(), getExtInfo());
4726 constexpr static size_t KindCount =
static_cast<size_t>(Kind::Last) + 1;
4734 FE_InferrableOnCallees = 0x1,
4737 FE_ExcludeThrow = 0x2,
4738 FE_ExcludeCatch = 0x4,
4739 FE_ExcludeObjCMessageSend = 0x8,
4740 FE_ExcludeStaticLocalVars = 0x10,
4741 FE_ExcludeThreadLocalVars = 0x20
4758 Kind oppositeKind()
const;
4769 case Kind::NonBlocking:
4770 return FE_InferrableOnCallees | FE_ExcludeThrow | FE_ExcludeCatch |
4771 FE_ExcludeObjCMessageSend | FE_ExcludeStaticLocalVars |
4772 FE_ExcludeThreadLocalVars;
4773 case Kind::NonAllocating:
4775 return FE_InferrableOnCallees | FE_ExcludeThrow | FE_ExcludeCatch |
4776 FE_ExcludeObjCMessageSend | FE_ExcludeThreadLocalVars;
4777 case Kind::Blocking:
4778 case Kind::Allocating:
4781 llvm_unreachable(
"unknown effect kind");
4785 StringRef name()
const;
4789 OS << Effect.
name();
4799 std::optional<FunctionEffect>
4800 effectProhibitingInference(
const Decl &Callee,
4807 bool shouldDiagnoseFunctionCall(
bool Direct,
4811 return LHS.FKind == RHS.FKind;
4814 return !(LHS == RHS);
4817 return LHS.FKind < RHS.FKind;
4824 Expr *Cond =
nullptr;
4833 return Cond == RHS.Cond;
4845 : Effect(
E), Cond(C) {}
4848 std::string description()
const;
4850 friend raw_ostream &operator<<(raw_ostream &OS,
4859 const Container *Outer =
nullptr;
4866 return Idx ==
Other.Idx;
4869 return Idx !=
Other.Idx;
4878 assert(Outer !=
nullptr &&
"invalid FunctionEffectIterator");
4879 bool HasConds = !Outer->Conditions.empty();
4881 HasConds ? Outer->Conditions[Idx]
4920 : Effects(FX), Conditions(Conds) {}
4933 bool empty()
const {
return Effects.empty(); }
4934 size_t size()
const {
return Effects.size(); }
4946 return LHS.Effects == RHS.Effects && LHS.Conditions == RHS.Conditions;
4950 return !(LHS == RHS);
4953 void dump(llvm::raw_ostream &OS)
const;
4959 constexpr static size_t EndBitPos = FunctionEffect::KindCount;
4960 using KindBitsT = std::bitset<EndBitPos>;
4962 KindBitsT KindBits{};
4970 return static_cast<size_t>(K);
4984 void advanceToNextSetBit() {
4985 while (Idx < EndBitPos && !Outer->KindBits.test(Idx))
4992 advanceToNextSetBit();
4995 bool operator!=(
const iterator &
Other)
const {
return Idx !=
Other.Idx; }
4997 iterator operator++() {
4999 advanceToNextSetBit();
5004 assert(Idx < EndBitPos &&
"Dereference of end iterator");
5013 iterator
begin()
const {
return iterator(*
this, 0); }
5014 iterator
end()
const {
return iterator(*
this, EndBitPos); }
5023 bool empty()
const {
return KindBits.none(); }
5025 return KindBits.test(kindToPos(EK));
5027 void dump(llvm::raw_ostream &OS)
const;
5047 : Effects(FX.effects()), Conditions(FX.conditions()) {}
5049 bool empty()
const {
return Effects.empty(); }
5050 size_t size()
const {
return Effects.size(); }
5059 void dump(llvm::raw_ostream &OS)
const;
5096 public llvm::FoldingSetNode,
5097 private llvm::TrailingObjects<
5098 FunctionProtoType, QualType, SourceLocation,
5099 FunctionType::FunctionTypeExtraBitfields,
5100 FunctionType::FunctionTypeArmAttributes, FunctionType::ExceptionType,
5101 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers,
5102 FunctionEffect, EffectConditionExpr> {
5104 friend TrailingObjects;
5201 AArch64SMEAttributes(SME_NormalFunction) {}
5205 AArch64SMEAttributes(SME_NormalFunction) {}
5209 Result.ExceptionSpec = ESI;
5215 requiresFunctionProtoTypeArmAttributes() ||
5216 !FunctionEffects.
empty();
5220 return AArch64SMEAttributes != SME_NormalFunction;
5225 AArch64SMEAttributes |=
Kind;
5227 AArch64SMEAttributes &= ~Kind;
5232 unsigned numTrailingObjects(OverloadToken<QualType>)
const {
5233 return getNumParams();
5236 unsigned numTrailingObjects(OverloadToken<SourceLocation>)
const {
5237 return isVariadic();
5240 unsigned numTrailingObjects(OverloadToken<FunctionTypeArmAttributes>)
const {
5241 return hasArmTypeAttributes();
5244 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>)
const {
5245 return hasExtraBitfields();
5248 unsigned numTrailingObjects(OverloadToken<ExceptionType>)
const {
5249 return getExceptionSpecSize().NumExceptionType;
5252 unsigned numTrailingObjects(OverloadToken<Expr *>)
const {
5253 return getExceptionSpecSize().NumExprPtr;
5256 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>)
const {
5257 return getExceptionSpecSize().NumFunctionDeclPtr;
5260 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>)
const {
5261 return hasExtParameterInfos() ? getNumParams() : 0;
5264 unsigned numTrailingObjects(OverloadToken<Qualifiers>)
const {
5265 return hasExtQualifiers() ? 1 : 0;
5268 unsigned numTrailingObjects(OverloadToken<FunctionEffect>)
const {
5269 return getNumFunctionEffects();
5272 unsigned numTrailingObjects(OverloadToken<EffectConditionExpr>)
const {
5273 return getNumFunctionEffectConditions();
5278 static bool containsAnyUnexpandedParameterPack(
const QualType *ArgArray,
5280 for (
unsigned Idx = 0; Idx < numArgs; ++Idx)
5281 if (ArgArray[Idx]->containsUnexpandedParameterPack())
5287 FunctionProtoType(QualType result, ArrayRef<QualType> params,
5288 QualType canonical,
const ExtProtoInfo &epi);
5293 struct ExceptionSpecSizeHolder {
5294 unsigned NumExceptionType;
5295 unsigned NumExprPtr;
5296 unsigned NumFunctionDeclPtr;
5301 static ExceptionSpecSizeHolder
5302 getExceptionSpecSize(ExceptionSpecificationType EST,
unsigned NumExceptions) {
5313 return {NumExceptions, 0, 0};
5326 llvm_unreachable(
"bad exception specification kind");
5331 ExceptionSpecSizeHolder getExceptionSpecSize()
const {
5332 return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
5336 bool hasExtraBitfields()
const {
5337 assert((getExceptionSpecType() != EST_Dynamic ||
5338 FunctionTypeBits.HasExtraBitfields) &&
5339 "ExtraBitfields are required for given ExceptionSpecType");
5340 return FunctionTypeBits.HasExtraBitfields;
5344 bool hasArmTypeAttributes()
const {
5345 return FunctionTypeBits.HasExtraBitfields &&
5346 getTrailingObjects<FunctionTypeExtraBitfields>()
5347 ->HasArmTypeAttributes;
5350 bool hasExtQualifiers()
const {
5351 return FunctionTypeBits.HasExtQuals;
5358 assert(i < getNumParams() &&
"invalid parameter index");
5359 return param_type_begin()[i];
5384 FunctionTypeBits.ExceptionSpecType);
5401 bool hasDependentExceptionSpec()
const;
5405 bool hasInstantiationDependentExceptionSpec()
const;
5410 Result.Type = getExceptionSpecType();
5412 Result.Exceptions = exceptions();
5414 Result.NoexceptExpr = getNoexceptExpr();
5416 Result.SourceDecl = getExceptionSpecDecl();
5417 Result.SourceTemplate = getExceptionSpecTemplate();
5419 Result.SourceDecl = getExceptionSpecDecl();
5427 ? getTrailingObjects<FunctionTypeExtraBitfields>()
5434 assert(i < getNumExceptions() &&
"Invalid exception number!");
5435 return exception_begin()[i];
5443 return *getTrailingObjects<Expr *>();
5454 return getTrailingObjects<FunctionDecl *>()[0];
5464 return getTrailingObjects<FunctionDecl *>()[1];
5475 return ResultIfDependent ? canThrow() !=
CT_Can : canThrow() ==
CT_Cannot;
5482 return isVariadic() ? *getTrailingObjects<SourceLocation>()
5492 bool isTemplateVariadic()
const;
5498 if (hasExtQualifiers())
5499 return *getTrailingObjects<Qualifiers>();
5501 return getFastTypeQuals();
5516 return getTrailingObjects<QualType>();
5520 return param_type_begin() + getNumParams();
5531 getTrailingObjects<ExceptionType>());
5535 return exception_begin() + getNumExceptions();
5541 return FunctionTypeBits.HasExtParameterInfos;
5545 assert(hasExtParameterInfos());
5554 if (!hasExtParameterInfos())
5556 return getTrailingObjects<ExtParameterInfo>();
5562 if (!hasArmTypeAttributes())
5563 return SME_NormalFunction;
5564 return getTrailingObjects<FunctionTypeArmAttributes>()
5565 ->AArch64SMEAttributes;
5569 assert(I < getNumParams() &&
"parameter index out of range");
5570 if (hasExtParameterInfos())
5571 return getTrailingObjects<ExtParameterInfo>()[I];
5576 assert(I < getNumParams() &&
"parameter index out of range");
5577 if (hasExtParameterInfos())
5578 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
5579 return ParameterABI::Ordinary;
5583 assert(I < getNumParams() &&
"parameter index out of range");
5584 if (hasExtParameterInfos())
5585 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
5590 return hasExtraBitfields()
5591 ? getTrailingObjects<FunctionTypeExtraBitfields>()
5592 ->NumFunctionEffects
5598 if (hasExtraBitfields()) {
5599 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5600 if (Bitfields->NumFunctionEffects > 0)
5601 return {getTrailingObjects<FunctionEffect>(),
5602 Bitfields->NumFunctionEffects};
5608 if (hasExtraBitfields()) {
5609 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5610 if (Bitfields->EffectsHaveConditions)
5611 return Bitfields->NumFunctionEffects;
5618 if (hasExtraBitfields()) {
5619 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5620 if (Bitfields->EffectsHaveConditions)
5621 return {getTrailingObjects<EffectConditionExpr>(),
5622 Bitfields->NumFunctionEffects};
5629 if (hasExtraBitfields()) {
5630 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5631 if (Bitfields->NumFunctionEffects > 0) {
5632 const size_t NumConds = Bitfields->EffectsHaveConditions
5633 ? Bitfields->NumFunctionEffects
5636 {getTrailingObjects<FunctionEffect>(),
5637 Bitfields->NumFunctionEffects},
5638 {NumConds ? getTrailingObjects<EffectConditionExpr>() :
nullptr,
5648 void printExceptionSpecification(raw_ostream &OS,
5655 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx);
5688 return Profile(
ID,
Decl);
5698 public llvm::FoldingSetNode,
5699 private llvm::TrailingObjects<UsingType, QualType> {
5702 friend TrailingObjects;
5730 public llvm::FoldingSetNode,
5731 private llvm::TrailingObjects<TypedefType, QualType> {
5734 friend TrailingObjects;
5756 if (!Underlying.
isNull())
5773 :
Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
5774 UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
5775 assert(isa<AttributedType>(UnderlyingTy) &&
5776 "Expected a macro qualified type to only wrap attributed types.");
5812 return static_cast<TypeOfKind>(TypeOfBits.Kind);
5819 bool isSugared()
const;
5831 public llvm::FoldingSetNode {
5837 Profile(
ID, Context, getUnderlyingExpr(),
5838 getKind() == TypeOfKind::Unqualified);
5841 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5842 Expr *
E,
bool IsUnqual);
5867 return static_cast<TypeOfKind>(TypeOfBits.Kind);
5891 bool isSugared()
const;
5907 Profile(
ID, Context, getUnderlyingExpr());
5910 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5916 public llvm::FoldingSetNode,
5917 private llvm::TrailingObjects<PackIndexingType, QualType> {
5918 friend TrailingObjects;
5926 LLVM_PREFERRED_TYPE(
bool)
5927 unsigned FullySubstituted : 1;
5932 QualType Pattern,
Expr *IndexExpr,
bool FullySubstituted,
5942 if (hasSelectedType())
5943 return getSelectedType();
5948 assert(hasSelectedType() &&
"Type is dependant");
5949 return *(getExpansionsPtr() + *getSelectedIndex());
5952 std::optional<unsigned> getSelectedIndex()
const;
5961 return {getExpansionsPtr(), Size};
5969 if (hasSelectedType())
5970 getSelectedType().Profile(
ID);
5972 Profile(
ID, Context, getPattern(), getIndexExpr(), isFullySubstituted());
5974 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
5978 const QualType *getExpansionsPtr()
const {
5979 return getTrailingObjects<QualType>();
5982 static TypeDependence computeDependence(QualType Pattern, Expr *IndexExpr,
5983 ArrayRef<QualType> Expansions = {});
5985 unsigned numTrailingObjects(OverloadToken<QualType>)
const {
return Size; }
5992#define TRANSFORM_TYPE_TRAIT_DEF(Enum, _) Enum,
5993#include "clang/Basic/TransformTypeTraits.def"
6001 QualType UnderlyingType;
6032 public llvm::FoldingSetNode {
6038 Profile(
ID, getBaseType(), getUTTKind());
6044 ID.AddInteger((
unsigned)UKind);
6063 bool isBeingDefined()
const;
6083 return reinterpret_cast<RecordDecl*
>(TagType::getDecl());
6088 bool hasConstFields()
const;
6106 return reinterpret_cast<EnumDecl*
>(TagType::getDecl());
6134 const Attr *Attribute;
6141 :
AttributedType(canon, attrKind, nullptr, modified, equivalent) {}
6152 return static_cast<Kind>(AttributedTypeBits.AttrKind);
6178 bool isQualifier()
const;
6180 bool isMSTypeSpec()
const;
6182 bool isWebAssemblyFuncrefSpec()
const;
6184 bool isCallingConv()
const;
6186 std::optional<NullabilityKind> getImmediateNullability()
const;
6197 static std::optional<NullabilityKind> stripOuterNullability(
QualType &T);
6200 Profile(
ID, getAttrKind(), ModifiedType, EquivalentType, Attribute);
6206 ID.AddInteger(attrKind);
6222 const BTFTypeTagAttr *BTFAttr;
6225 const BTFTypeTagAttr *BTFAttr)
6226 :
Type(BTFTagAttributed, Canon, Wrapped->getDependence()),
6227 WrappedType(Wrapped), BTFAttr(BTFAttr) {}
6231 const BTFTypeTagAttr *
getAttr()
const {
return BTFAttr; }
6237 Profile(
ID, WrappedType, BTFAttr);
6241 const BTFTypeTagAttr *BTFAttr) {
6243 ID.AddPointer(BTFAttr);
6257 LLVM_PREFERRED_TYPE(
bool)
6260 LLVM_PREFERRED_TYPE(
bool)
6261 uint8_t RawBuffer : 1;
6265 : ResourceClass(ResourceClass), IsROV(IsROV), RawBuffer(RawBuffer) {}
6274 return !(LHS == RHS);
6289 : Contained->getDependence()),
6290 WrappedType(Wrapped), ContainedType(Contained), Attrs(Attrs) {}
6302 Profile(
ID, WrappedType, ContainedType, Attrs);
6320 findHandleTypeOnResource(
const Type *RT);
6331 :
Type(TemplateTypeParm, Canon,
6335 assert(!TTPDecl == Canon.
isNull());
6336 TemplateTypeParmTypeBits.Depth =
D;
6337 TemplateTypeParmTypeBits.Index = I;
6338 TemplateTypeParmTypeBits.ParameterPack = PP;
6342 unsigned getDepth()
const {
return TemplateTypeParmTypeBits.Depth; }
6343 unsigned getIndex()
const {
return TemplateTypeParmTypeBits.Index; }
6345 return TemplateTypeParmTypeBits.ParameterPack;
6359 static void Profile(llvm::FoldingSetNodeID &
ID,
unsigned Depth,
6360 unsigned Index,
bool ParameterPack,
6362 ID.AddInteger(Depth);
6363 ID.AddInteger(Index);
6364 ID.AddBoolean(ParameterPack);
6365 ID.AddPointer(TTPDecl);
6382 public llvm::FoldingSetNode,
6383 private llvm::TrailingObjects<SubstTemplateTypeParmType, QualType> {
6387 Decl *AssociatedDecl;
6390 unsigned Index, std::optional<unsigned> PackIndex,
6397 return SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType
6398 ? *getTrailingObjects<QualType>()
6399 : getCanonicalTypeInternal();
6412 unsigned getIndex()
const {
return SubstTemplateTypeParmTypeBits.Index; }
6415 if (SubstTemplateTypeParmTypeBits.PackIndex == 0)
6416 return std::nullopt;
6417 return SubstTemplateTypeParmTypeBits.PackIndex - 1;
6422 SubstTemplateTypeParmTypeBits.SubstitutionFlag);
6429 Profile(
ID, getReplacementType(), getAssociatedDecl(),
getIndex(),
6430 getPackIndex(), getSubstitutionFlag());
6434 const Decl *AssociatedDecl,
unsigned Index,
6435 std::optional<unsigned> PackIndex,
6437 Replacement.Profile(
ID);
6438 ID.AddPointer(AssociatedDecl);
6439 ID.AddInteger(Index);
6440 ID.AddInteger(PackIndex ? *PackIndex - 1 : 0);
6441 ID.AddInteger(llvm::to_underlying(Flag));
6442 assert((Flag != SubstTemplateTypeParmTypeFlag::ExpandPacksInPlace ||
6444 "ExpandPacksInPlace needs a valid PackIndex");
6471 llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
6474 unsigned Index,
bool Final,
6483 Decl *getAssociatedDecl()
const;
6490 unsigned getIndex()
const {
return SubstTemplateTypeParmPackTypeBits.Index; }
6493 bool getFinal()
const;
6496 return SubstTemplateTypeParmPackTypeBits.NumArgs;
6504 void Profile(llvm::FoldingSetNodeID &
ID);
6505 static void Profile(llvm::FoldingSetNodeID &
ID,
const Decl *AssociatedDecl,
6506 unsigned Index,
bool Final,
6529 ExtraDependence | (DeducedAsType.isNull()
6531 : DeducedAsType->getDependence() &
6533 DeducedAsType(DeducedAsType) {}
6538 return isSugared() ? DeducedAsType :
QualType(
this, 0);
6545 return !DeducedAsType.
isNull() || isDependentType();
6568 AutoTypeBits.NumArgs};
6572 return TypeConstraintConcept;
6576 return TypeConstraintConcept !=
nullptr;
6580 return getKeyword() == AutoTypeKeyword::DecltypeAuto;
6584 return getKeyword() == AutoTypeKeyword::GNUAutoType;
6591 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context);
6592 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
6604 public llvm::FoldingSetNode {
6612 bool IsDeducedAsDependent,
QualType Canon)
6613 :
DeducedType(DeducedTemplateSpecialization, DeducedAsType,
6615 (IsDeducedAsDependent
6619 Template(Template) {}
6626 Profile(
ID, getTemplateName(), getDeducedType(), isDependentType());
6630 QualType Deduced,
bool IsDependent) {
6696 static bool anyInstantiationDependentTemplateArguments(
6702 return isa<InjectedClassNameType>(getCanonicalTypeInternal());
6720 bool isTypeAlias()
const {
return TemplateSpecializationTypeBits.TypeAlias; }
6731 TemplateSpecializationTypeBits.NumArgs};
6735 return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
6739 return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
6742 void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Ctx);
6754void printTemplateArgumentList(raw_ostream &OS,
6755 ArrayRef<TemplateArgument> Args,
6756 const PrintingPolicy &Policy,
6757 const TemplateParameterList *TPL =
nullptr);
6759void printTemplateArgumentList(raw_ostream &OS,
6760 ArrayRef<TemplateArgumentLoc> Args,
6761 const PrintingPolicy &Policy,
6762 const TemplateParameterList *TPL =
nullptr);
6764void printTemplateArgumentList(raw_ostream &OS,
6765 const TemplateArgumentListInfo &Args,
6766 const PrintingPolicy &Policy,
6767 const TemplateParameterList *TPL =
nullptr);
6771bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg,
6772 const NamedDecl *Param,
6773 ArrayRef<TemplateArgument> Args,
6817 Decl(
D), InjectedType(TST) {
6818 assert(isa<TemplateSpecializationType>(TST));
6827 return cast<TemplateSpecializationType>(InjectedType.
getTypePtr());
6831 return getInjectedTST()->getTemplateName();
6897 TypeWithKeywordBits.Keyword = llvm::to_underlying(Keyword);
6910 static TagTypeKind getTagTypeKindForTypeSpec(
unsigned TypeSpec);
6925 return getKeywordName(getKeywordForTagTypeKind(
Kind));
6942 public llvm::FoldingSetNode,
6943 private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
6945 friend TrailingObjects;
6964 NamedType->getDependence() |
6968 NNS(NNS), NamedType(NamedType) {
6969 ElaboratedTypeBits.HasOwnedTagDecl =
false;
6971 ElaboratedTypeBits.HasOwnedTagDecl =
true;
6972 *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
6992 return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
6997 Profile(
ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
7003 ID.AddInteger(llvm::to_underlying(Keyword));
7006 ID.AddPointer(OwnedTagDecl);
7038 NNS(NNS), Name(Name) {}
7057 Profile(
ID, getKeyword(), NNS, Name);
7062 ID.AddInteger(llvm::to_underlying(Keyword));
7064 ID.AddPointer(Name);
7076 public llvm::FoldingSetNode {
7097 DependentTemplateSpecializationTypeBits.NumArgs};
7104 Profile(
ID, Context, getKeyword(), NNS, Name, template_arguments());
7107 static void Profile(llvm::FoldingSetNodeID &
ID,
7115 return T->
getTypeClass() == DependentTemplateSpecialization;
7148 std::optional<unsigned> NumExpansions)
7149 :
Type(PackExpansion, Canon,
7154 PackExpansionTypeBits.NumExpansions =
7155 NumExpansions ? *NumExpansions + 1 : 0;
7167 if (PackExpansionTypeBits.NumExpansions)
7168 return PackExpansionTypeBits.NumExpansions - 1;
7169 return std::nullopt;
7176 Profile(
ID, getPattern(), getNumExpansions());
7180 std::optional<unsigned> NumExpansions) {
7182 ID.AddBoolean(NumExpansions.has_value());
7184 ID.AddInteger(*NumExpansions);
7204 return static_cast<T*
>(
this)->getProtocolStorageImpl();
7208 static_cast<T*
>(
this)->setNumProtocolsImpl(N);
7212 setNumProtocols(protocols.size());
7213 assert(getNumProtocols() == protocols.size() &&
7214 "bitfield overflow in protocol count");
7215 if (!protocols.empty())
7216 memcpy(getProtocolStorage(), protocols.data(),
7233 return static_cast<const T*
>(
this)->getNumProtocolsImpl();
7238 assert(I < getNumProtocols() &&
"Out-of-range protocol access");
7239 return qual_begin()[I];
7252 public llvm::FoldingSetNode {
7257 unsigned NumProtocols : 6;
7268 unsigned getNumProtocolsImpl()
const {
7269 return NumProtocols;
7272 void setNumProtocolsImpl(
unsigned N) {
7276 ObjCTypeParamType(
const ObjCTypeParamDecl *
D,
7278 ArrayRef<ObjCProtocolDecl *> protocols);
7288 void Profile(llvm::FoldingSetNodeID &
ID);
7289 static void Profile(llvm::FoldingSetNodeID &
ID,
7345 mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
7346 CachedSuperClassType;
7349 const QualType *getTypeArgStorage()
const {
7356 unsigned getNumProtocolsImpl()
const {
7357 return ObjCObjectTypeBits.NumProtocols;
7359 void setNumProtocolsImpl(
unsigned N) {
7360 ObjCObjectTypeBits.NumProtocols = N;
7374 ObjCObjectTypeBits.NumProtocols = 0;
7375 ObjCObjectTypeBits.NumTypeArgs = 0;
7376 ObjCObjectTypeBits.IsKindOf = 0;
7379 void computeSuperClassTypeSlow()
const;
7391 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
7395 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
7401 if (!qual_empty())
return false;
7402 if (
const BuiltinType *
T = getBaseType()->getAs<BuiltinType>())
7403 return T->getKind() == BuiltinType::ObjCId ||
7404 T->getKind() == BuiltinType::ObjCClass;
7416 bool isSpecialized()
const;
7420 return ObjCObjectTypeBits.NumTypeArgs > 0;
7437 return llvm::ArrayRef(getTypeArgStorage(), ObjCObjectTypeBits.NumTypeArgs);
7444 bool isKindOfType()
const;
7453 if (!CachedSuperClassType.getInt())
7454 computeSuperClassTypeSlow();
7456 assert(CachedSuperClassType.getInt() &&
"Superclass not set?");
7457 return QualType(CachedSuperClassType.getPointer(), 0);
7490 void Profile(llvm::FoldingSetNodeID &
ID);
7491 static void Profile(llvm::FoldingSetNodeID &
ID,
7498inline QualType *ObjCObjectType::getTypeArgStorage() {
7499 return reinterpret_cast<QualType *
>(
static_cast<ObjCObjectTypeImpl*
>(
this)+1);
7502inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
7503 return reinterpret_cast<ObjCProtocolDecl**
>(
7504 getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
7507inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
7508 return reinterpret_cast<ObjCProtocolDecl**
>(
7509 static_cast<ObjCTypeParamType*
>(
this)+1);
7562 if (
const auto *
T = dyn_cast<ObjCInterfaceType>(ObjT))
7563 return T->getDecl();
7565 baseType = ObjT->getBaseType();
7586 :
Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
7587 PointeeType(Pointee) {}
7730 QualType getSuperClassType()
const;
7742 ID.AddPointer(
T.getAsOpaquePtr());
7756 :
Type(
Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}
7767 Profile(
ID, getValueType());
7771 ID.AddPointer(
T.getAsOpaquePtr());
7787 :
Type(
Pipe, CanonicalPtr, elemType->getDependence()),
7798 Profile(
ID, getElementType(), isReadOnly());
7802 ID.AddPointer(
T.getAsOpaquePtr());
7816 LLVM_PREFERRED_TYPE(
bool)
7817 unsigned IsUnsigned : 1;
7818 unsigned NumBits : 24;
7835 static void Profile(llvm::FoldingSetNodeID &
ID,
bool IsUnsigned,
7837 ID.AddBoolean(IsUnsigned);
7838 ID.AddInteger(NumBits);
7846 llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;
7854 Expr *getNumBitsExpr()
const;
7862 static void Profile(llvm::FoldingSetNodeID &
ID,
const ASTContext &Context,
7863 bool IsUnsigned,
Expr *NumBitsExpr);
7879 addFastQualifiers(
type.getLocalFastQualifiers());
7880 if (!
type.hasLocalNonFastQualifiers())
7881 return type.getTypePtrUnsafe();
7926 Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
7931inline const Type *QualType::getTypePtr()
const {
7932 return getCommonPtr()->BaseType;
7935inline const Type *QualType::getTypePtrOrNull()
const {
7936 return (isNull() ?
nullptr : getCommonPtr()->BaseType);
7939inline bool QualType::isReferenceable()
const {
7943 const Type &Self = **
this;
7944 if (Self.isObjectType() || Self.isReferenceType())
7947 return F->getMethodQuals().empty() && F->getRefQualifier() ==
RQ_None;
7953 if (!hasLocalNonFastQualifiers())
7955 Qualifiers::fromFastMask(getLocalFastQualifiers()));
7957 const ExtQuals *eq = getExtQualsUnsafe();
7965 if (hasLocalNonFastQualifiers())
7966 Quals = getExtQualsUnsafe()->getQualifiers();
7972 Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
7977inline unsigned QualType::getCVRQualifiers()
const {
7978 unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
7979 cvr |= getLocalCVRQualifiers();
7984 QualType canon = getCommonPtr()->CanonicalType;
7988inline bool QualType::isCanonical()
const {
7992inline bool QualType::isCanonicalAsParam()
const {
7993 if (!isCanonical())
return false;
7994 if (hasLocalQualifiers())
return false;
7996 const Type *
T = getTypePtr();
8000 return !isa<FunctionType>(
T) &&
8001 (!isa<ArrayType>(
T) || isa<ArrayParameterType>(
T));
8004inline bool QualType::isConstQualified()
const {
8005 return isLocalConstQualified() ||
8006 getCommonPtr()->CanonicalType.isLocalConstQualified();
8009inline bool QualType::isRestrictQualified()
const {
8010 return isLocalRestrictQualified() ||
8011 getCommonPtr()->CanonicalType.isLocalRestrictQualified();
8015inline bool QualType::isVolatileQualified()
const {
8016 return isLocalVolatileQualified() ||
8017 getCommonPtr()->CanonicalType.isLocalVolatileQualified();
8020inline bool QualType::hasQualifiers()
const {
8021 return hasLocalQualifiers() ||
8022 getCommonPtr()->CanonicalType.hasLocalQualifiers();
8026 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
8029 return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
8033 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
8036 return getSplitUnqualifiedTypeImpl(*
this);
8039inline void QualType::removeLocalConst() {
8040 removeLocalFastQualifiers(Qualifiers::Const);
8043inline void QualType::removeLocalRestrict() {
8044 removeLocalFastQualifiers(Qualifiers::Restrict);
8047inline void QualType::removeLocalVolatile() {
8048 removeLocalFastQualifiers(Qualifiers::Volatile);
8052inline bool QualType::hasAddressSpace()
const {
8053 return getQualifiers().hasAddressSpace();
8057inline LangAS QualType::getAddressSpace()
const {
8058 return getQualifiers().getAddressSpace();
8063 return getQualifiers().getObjCGCAttr();
8066inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion()
const {
8067 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
8068 return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
8072inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion()
const {
8073 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
8074 return hasNonTrivialToPrimitiveDestructCUnion(RD);
8078inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion()
const {
8079 if (
auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->
getAsRecordDecl())
8080 return hasNonTrivialToPrimitiveCopyCUnion(RD);
8086 if (
const auto *FT = PT->getPointeeType()->getAs<
FunctionType>())
8087 return FT->getExtInfo();
8089 return FT->getExtInfo();
8103inline bool QualType::isMoreQualifiedThan(
QualType other,
8114inline bool QualType::isAtLeastAsQualifiedAs(
QualType other,
8119 if (getUnqualifiedType()->isVoidType())
8122 return getQualifiers().compatiblyIncludes(OtherQuals, Ctx);
8141inline bool QualType::isCForbiddenLValueType()
const {
8142 return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
8143 getTypePtr()->isFunctionType());
8149inline bool Type::isFundamentalType()
const {
8150 return isVoidType() ||
8154 (isArithmeticType() && !isEnumeralType());
8160inline bool Type::isCompoundType()
const {
8164 return isArrayType() ||
8170 isReferenceType() ||
8179 isMemberPointerType();
8182inline bool Type::isFunctionType()
const {
8183 return isa<FunctionType>(CanonicalType);
8186inline bool Type::isPointerType()
const {
8187 return isa<PointerType>(CanonicalType);
8190inline bool Type::isPointerOrReferenceType()
const {
8191 return isPointerType() || isReferenceType();
8194inline bool Type::isAnyPointerType()
const {
8195 return isPointerType() || isObjCObjectPointerType();
8198inline bool Type::isSignableType()
const {
return isPointerType(); }
8200inline bool Type::isBlockPointerType()
const {
8201 return isa<BlockPointerType>(CanonicalType);
8204inline bool Type::isReferenceType()
const {
8205 return isa<ReferenceType>(CanonicalType);
8208inline bool Type::isLValueReferenceType()
const {
8209 return isa<LValueReferenceType>(CanonicalType);
8212inline bool Type::isRValueReferenceType()
const {
8213 return isa<RValueReferenceType>(CanonicalType);
8216inline bool Type::isObjectPointerType()
const {
8220 if (
const auto *
T = getAs<PointerType>())
8226inline bool Type::isFunctionPointerType()
const {
8227 if (
const auto *
T = getAs<PointerType>())
8233inline bool Type::isFunctionReferenceType()
const {
8234 if (
const auto *
T = getAs<ReferenceType>())
8240inline bool Type::isMemberPointerType()
const {
8241 return isa<MemberPointerType>(CanonicalType);
8244inline bool Type::isMemberFunctionPointerType()
const {
8245 if (
const auto *
T = getAs<MemberPointerType>())
8246 return T->isMemberFunctionPointer();
8251inline bool Type::isMemberDataPointerType()
const {
8252 if (
const auto *
T = getAs<MemberPointerType>())
8253 return T->isMemberDataPointer();
8258inline bool Type::isArrayType()
const {
8259 return isa<ArrayType>(CanonicalType);
8262inline bool Type::isConstantArrayType()
const {
8263 return isa<ConstantArrayType>(CanonicalType);
8266inline bool Type::isIncompleteArrayType()
const {
8267 return isa<IncompleteArrayType>(CanonicalType);
8270inline bool Type::isVariableArrayType()
const {
8271 return isa<VariableArrayType>(CanonicalType);
8274inline bool Type::isArrayParameterType()
const {
8275 return isa<ArrayParameterType>(CanonicalType);
8278inline bool Type::isDependentSizedArrayType()
const {
8279 return isa<DependentSizedArrayType>(CanonicalType);
8282inline bool Type::isBuiltinType()
const {
8283 return isa<BuiltinType>(CanonicalType);
8286inline bool Type::isRecordType()
const {
8287 return isa<RecordType>(CanonicalType);
8290inline bool Type::isEnumeralType()
const {
8291 return isa<EnumType>(CanonicalType);
8294inline bool Type::isAnyComplexType()
const {
8295 return isa<ComplexType>(CanonicalType);
8298inline bool Type::isVectorType()
const {
8299 return isa<VectorType>(CanonicalType);
8302inline bool Type::isExtVectorType()
const {
8303 return isa<ExtVectorType>(CanonicalType);
8306inline bool Type::isExtVectorBoolType()
const {
8307 if (!isExtVectorType())
8309 return cast<ExtVectorType>(CanonicalType)->getElementType()->isBooleanType();
8312inline bool Type::isSubscriptableVectorType()
const {
8313 return isVectorType() || isSveVLSBuiltinType();
8316inline bool Type::isMatrixType()
const {
8317 return isa<MatrixType>(CanonicalType);
8320inline bool Type::isConstantMatrixType()
const {
8321 return isa<ConstantMatrixType>(CanonicalType);
8324inline bool Type::isDependentAddressSpaceType()
const {
8325 return isa<DependentAddressSpaceType>(CanonicalType);
8328inline bool Type::isObjCObjectPointerType()
const {
8329 return isa<ObjCObjectPointerType>(CanonicalType);
8332inline bool Type::isObjCObjectType()
const {
8333 return isa<ObjCObjectType>(CanonicalType);
8336inline bool Type::isObjCObjectOrInterfaceType()
const {
8337 return isa<ObjCInterfaceType>(CanonicalType) ||
8338 isa<ObjCObjectType>(CanonicalType);
8341inline bool Type::isAtomicType()
const {
8342 return isa<AtomicType>(CanonicalType);
8345inline bool Type::isUndeducedAutoType()
const {
8346 return isa<AutoType>(CanonicalType);
8349inline bool Type::isObjCQualifiedIdType()
const {
8350 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
8351 return OPT->isObjCQualifiedIdType();
8355inline bool Type::isObjCQualifiedClassType()
const {
8356 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
8357 return OPT->isObjCQualifiedClassType();
8361inline bool Type::isObjCIdType()
const {
8362 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
8363 return OPT->isObjCIdType();
8367inline bool Type::isObjCClassType()
const {
8368 if (
const auto *OPT = getAs<ObjCObjectPointerType>())
8369 return OPT->isObjCClassType();
8373inline bool Type::isObjCSelType()
const {
8374 if (
const auto *OPT = getAs<PointerType>())
8375 return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
8379inline bool Type::isObjCBuiltinType()
const {
8380 return isObjCIdType() || isObjCClassType() || isObjCSelType();
8383inline bool Type::isDecltypeType()
const {
8384 return isa<DecltypeType>(
this);
8387#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8388 inline bool Type::is##Id##Type() const { \
8389 return isSpecificBuiltinType(BuiltinType::Id); \
8391#include "clang/Basic/OpenCLImageTypes.def"
8393inline bool Type::isSamplerT()
const {
8394 return isSpecificBuiltinType(BuiltinType::OCLSampler);
8397inline bool Type::isEventT()
const {
8398 return isSpecificBuiltinType(BuiltinType::OCLEvent);
8401inline bool Type::isClkEventT()
const {
8402 return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
8405inline bool Type::isQueueT()
const {
8406 return isSpecificBuiltinType(BuiltinType::OCLQueue);
8409inline bool Type::isReserveIDT()
const {
8410 return isSpecificBuiltinType(BuiltinType::OCLReserveID);
8413inline bool Type::isImageType()
const {
8414#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
8416#include "clang/Basic/OpenCLImageTypes.def"
8420inline bool Type::isPipeType()
const {
8421 return isa<PipeType>(CanonicalType);
8424inline bool Type::isBitIntType()
const {
8425 return isa<BitIntType>(CanonicalType);
8428#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
8429 inline bool Type::is##Id##Type() const { \
8430 return isSpecificBuiltinType(BuiltinType::Id); \
8432#include "clang/Basic/OpenCLExtensionTypes.def"
8434inline bool Type::isOCLIntelSubgroupAVCType()
const {
8435#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
8436 isOCLIntelSubgroupAVC##Id##Type() ||
8438#include "clang/Basic/OpenCLExtensionTypes.def"
8442inline bool Type::isOCLExtOpaqueType()
const {
8443#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
8445#include "clang/Basic/OpenCLExtensionTypes.def"
8449inline bool Type::isOpenCLSpecificType()
const {
8450 return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
8451 isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
8454#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
8455 inline bool Type::is##Id##Type() const { \
8456 return isSpecificBuiltinType(BuiltinType::Id); \
8458#include "clang/Basic/HLSLIntangibleTypes.def"
8460inline bool Type::isHLSLBuiltinIntangibleType()
const {
8461#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) is##Id##Type() ||
8463#include "clang/Basic/HLSLIntangibleTypes.def"
8467inline bool Type::isHLSLSpecificType()
const {
8468 return isHLSLBuiltinIntangibleType() || isHLSLAttributedResourceType();
8471inline bool Type::isHLSLAttributedResourceType()
const {
8472 return isa<HLSLAttributedResourceType>(
this);
8475inline bool Type::isTemplateTypeParmType()
const {
8476 return isa<TemplateTypeParmType>(CanonicalType);
8479inline bool Type::isSpecificBuiltinType(
unsigned K)
const {
8480 if (
const BuiltinType *BT = getAs<BuiltinType>()) {
8486inline bool Type::isPlaceholderType()
const {
8487 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
8488 return BT->isPlaceholderType();
8493 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
8494 if (BT->isPlaceholderType())
8499inline bool Type::isSpecificPlaceholderType(
unsigned K)
const {
8501 return isSpecificBuiltinType(K);
8504inline bool Type::isNonOverloadPlaceholderType()
const {
8505 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
8506 return BT->isNonOverloadPlaceholderType();
8510inline bool Type::isVoidType()
const {
8511 return isSpecificBuiltinType(BuiltinType::Void);
8514inline bool Type::isHalfType()
const {
8516 return isSpecificBuiltinType(BuiltinType::Half);
8519inline bool Type::isFloat16Type()
const {
8520 return isSpecificBuiltinType(BuiltinType::Float16);
8523inline bool Type::isFloat32Type()
const {
8524 return isSpecificBuiltinType(BuiltinType::Float);
8527inline bool Type::isDoubleType()
const {
8528 return isSpecificBuiltinType(BuiltinType::Double);
8531inline bool Type::isBFloat16Type()
const {
8532 return isSpecificBuiltinType(BuiltinType::BFloat16);
8535inline bool Type::isFloat128Type()
const {
8536 return isSpecificBuiltinType(BuiltinType::Float128);
8539inline bool Type::isIbm128Type()
const {
8540 return isSpecificBuiltinType(BuiltinType::Ibm128);
8543inline bool Type::isNullPtrType()
const {
8544 return isSpecificBuiltinType(BuiltinType::NullPtr);
8550inline bool Type::isIntegerType()
const {
8551 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8552 return BT->getKind() >= BuiltinType::Bool &&
8553 BT->getKind() <= BuiltinType::Int128;
8554 if (
const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
8560 return isBitIntType();
8563inline bool Type::isFixedPointType()
const {
8564 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8565 return BT->getKind() >= BuiltinType::ShortAccum &&
8566 BT->getKind() <= BuiltinType::SatULongFract;
8571inline bool Type::isFixedPointOrIntegerType()
const {
8572 return isFixedPointType() || isIntegerType();
8575inline bool Type::isConvertibleToFixedPointType()
const {
8576 return isRealFloatingType() || isFixedPointOrIntegerType();
8579inline bool Type::isSaturatedFixedPointType()
const {
8580 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8581 return BT->getKind() >= BuiltinType::SatShortAccum &&
8582 BT->getKind() <= BuiltinType::SatULongFract;
8587inline bool Type::isUnsaturatedFixedPointType()
const {
8588 return isFixedPointType() && !isSaturatedFixedPointType();
8591inline bool Type::isSignedFixedPointType()
const {
8592 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8593 return ((BT->getKind() >= BuiltinType::ShortAccum &&
8594 BT->getKind() <= BuiltinType::LongAccum) ||
8595 (BT->getKind() >= BuiltinType::ShortFract &&
8596 BT->getKind() <= BuiltinType::LongFract) ||
8597 (BT->getKind() >= BuiltinType::SatShortAccum &&
8598 BT->getKind() <= BuiltinType::SatLongAccum) ||
8599 (BT->getKind() >= BuiltinType::SatShortFract &&
8600 BT->getKind() <= BuiltinType::SatLongFract));
8605inline bool Type::isUnsignedFixedPointType()
const {
8606 return isFixedPointType() && !isSignedFixedPointType();
8609inline bool Type::isScalarType()
const {
8610 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8611 return BT->getKind() > BuiltinType::Void &&
8612 BT->getKind() <= BuiltinType::NullPtr;
8613 if (
const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
8617 return isa<PointerType>(CanonicalType) ||
8618 isa<BlockPointerType>(CanonicalType) ||
8619 isa<MemberPointerType>(CanonicalType) ||
8620 isa<ComplexType>(CanonicalType) ||
8621 isa<ObjCObjectPointerType>(CanonicalType) ||
8625inline bool Type::isIntegralOrEnumerationType()
const {
8626 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8627 return BT->getKind() >= BuiltinType::Bool &&
8628 BT->getKind() <= BuiltinType::Int128;
8632 if (
const auto *ET = dyn_cast<EnumType>(CanonicalType))
8635 return isBitIntType();
8638inline bool Type::isBooleanType()
const {
8639 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8640 return BT->getKind() == BuiltinType::Bool;
8644inline bool Type::isUndeducedType()
const {
8645 auto *DT = getContainedDeducedType();
8646 return DT && !DT->isDeduced();
8651inline bool Type::isOverloadableType()
const {
8652 if (!isDependentType())
8654 return !isArrayType() && !isFunctionType() && !isAnyPointerType() &&
8655 !isMemberPointerType();
8659inline bool Type::isTypedefNameType()
const {
8660 if (getAs<TypedefType>())
8662 if (
auto *TST = getAs<TemplateSpecializationType>())
8663 return TST->isTypeAlias();
8668inline bool Type::canDecayToPointerType()
const {
8669 return isFunctionType() || (isArrayType() && !isArrayParameterType());
8672inline bool Type::hasPointerRepresentation()
const {
8673 return (isPointerType() || isReferenceType() || isBlockPointerType() ||
8674 isObjCObjectPointerType() || isNullPtrType());
8677inline bool Type::hasObjCPointerRepresentation()
const {
8678 return isObjCObjectPointerType();
8681inline const Type *Type::getBaseElementTypeUnsafe()
const {
8688inline const Type *Type::getPointeeOrArrayElementType()
const {
8690 if (
type->isAnyPointerType())
8691 return type->getPointeeType().getTypePtr();
8692 else if (
type->isArrayType())
8693 return type->getBaseElementTypeUnsafe();
8701 DiagnosticsEngine::ArgumentKind::ak_addrspace);
8710 DiagnosticsEngine::ArgumentKind::ak_qual);
8718 PD.
AddTaggedVal(
reinterpret_cast<uint64_t
>(
T.getAsOpaquePtr()),
8719 DiagnosticsEngine::ak_qualtype);
8725template <
typename T>
8727 std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
8728 std::is_base_of<ArrayType, T>::value>;
8731template <
typename T>
const T *Type::getAs()
const {
8733 "ArrayType cannot be used with getAs!");
8736 if (
const auto *Ty = dyn_cast<T>(
this))
8740 if (!isa<T>(CanonicalType))
8745 return cast<T>(getUnqualifiedDesugaredType());
8748template <
typename T>
const T *Type::getAsAdjusted()
const {
8752 if (
const auto *Ty = dyn_cast<T>(
this))
8756 if (!isa<T>(CanonicalType))
8761 const Type *Ty =
this;
8763 if (
const auto *A = dyn_cast<AttributedType>(Ty))
8764 Ty = A->getModifiedType().getTypePtr();
8765 else if (
const auto *A = dyn_cast<BTFTagAttributedType>(Ty))
8766 Ty = A->getWrappedType().getTypePtr();
8767 else if (
const auto *A = dyn_cast<HLSLAttributedResourceType>(Ty))
8768 Ty = A->getWrappedType().getTypePtr();
8769 else if (
const auto *
E = dyn_cast<ElaboratedType>(Ty))
8770 Ty =
E->desugar().getTypePtr();
8771 else if (
const auto *
P = dyn_cast<ParenType>(Ty))
8772 Ty =
P->desugar().getTypePtr();
8773 else if (
const auto *A = dyn_cast<AdjustedType>(Ty))
8774 Ty = A->desugar().getTypePtr();
8775 else if (
const auto *M = dyn_cast<MacroQualifiedType>(Ty))
8776 Ty = M->desugar().getTypePtr();
8783 return dyn_cast<T>(Ty);
8788 if (
const auto *arr = dyn_cast<ArrayType>(
this))
8792 if (!isa<ArrayType>(CanonicalType))
8797 return cast<ArrayType>(getUnqualifiedDesugaredType());
8800template <
typename T>
const T *Type::castAs()
const {
8802 "ArrayType cannot be used with castAs!");
8804 if (
const auto *ty = dyn_cast<T>(
this))
return ty;
8805 assert(isa<T>(CanonicalType));
8806 return cast<T>(getUnqualifiedDesugaredType());
8809inline const ArrayType *Type::castAsArrayTypeUnsafe()
const {
8810 assert(isa<ArrayType>(CanonicalType));
8811 if (
const auto *arr = dyn_cast<ArrayType>(
this))
return arr;
8812 return cast<ArrayType>(getUnqualifiedDesugaredType());
8817 :
AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
8819 QualType Adjusted = getAdjustedType();
8821 assert(isa<PointerType>(Adjusted));
8828 return cast<PointerType>(Decayed)->getPointeeType();
8846 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)
clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)
enum clang::sema::@1712::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)
Attr - This represents one attribute.
An attributed type is a type to which a type attribute has been applied.
QualType getModifiedType() const
static bool classof(const Type *T)
const Attr * getAttr() const
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, const Attr *attr)
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 FunctionEffect::Kind.
static FunctionEffectKindSet difference(FunctionEffectKindSet LHS, FunctionEffectKindSet RHS)
bool contains(const FunctionEffect::Kind EK) const
FunctionEffectKindSet()=default
FunctionEffectKindSet(FunctionEffectsRef FX)
void insert(FunctionEffectKindSet Set)
void insert(FunctionEffectsRef FX)
void insert(FunctionEffect Effect)
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<(FunctionEffect LHS, FunctionEffect RHS)
friend bool operator==(FunctionEffect LHS, FunctionEffect RHS)
uint32_t toOpaqueInt32() const
For serialization.
friend bool operator!=(FunctionEffect LHS, FunctionEffect RHS)
Kind
Identifies the particular effect.
Flags flags() const
Flags describing some behaviors of the effect.
StringRef name() const
The description printed in diagnostics, e.g. 'nonblocking'.
static FunctionEffect fromOpaqueInt32(uint32_t Value)
friend raw_ostream & operator<<(raw_ostream &OS, const FunctionEffect &Effect)
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...
QualType getWrappedType() const
bool hasContainedType() const
const Attributes & getAttrs() const
static bool classof(const Type *T)
static void Profile(llvm::FoldingSetNodeID &ID, QualType Wrapped, QualType Contained, const Attributes &Attrs)
QualType getContainedType() const
void Profile(llvm::FoldingSetNodeID &ID)
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
bool isFullySubstituted() const
ArrayRef< QualType > getExpansions() const
Expr * getIndexExpr() const
static bool classof(const Type *T)
bool expandsToEmptyPack() const
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
bool isAddressSpaceOverlapping(QualType T, const ASTContext &Ctx) const
Returns true if address space qualifiers overlap with T address space qualifiers.
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 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 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 isMoreQualifiedThan(QualType Other, const ASTContext &Ctx) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
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.
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 isAtLeastAsQualifiedAs(QualType Other, const ASTContext &Ctx) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
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 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)
static bool isTargetAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
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 compatiblyIncludes(Qualifiers other, const ASTContext &Ctx) const
Determines if these qualifiers compatibly include another set.
bool hasUnaligned() const
unsigned getAddressSpaceAttributePrintValue() const
Get the address space attribute value to be printed by diagnostics.
bool hasAddressSpace() const
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
Returns true if address space A is equal to or a superset of B.
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)
@ FastWidth
The width of the "fast" qualifier mask.
@ MaxAddressSpace
The maximum supported address space number.
@ FastMask
The fast qualifier mask.
unsigned getCVRUQualifiers() const
bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const
PointerAuthQualifier getPointerAuth() const
void setObjCGCAttr(GC type)
Qualifiers withConst() const
bool hasObjCGCAttr() const
uint64_t getAsOpaqueValue() const
void setCVRQualifiers(unsigned mask)
bool hasObjCLifetime() const
ObjCLifetime getObjCLifetime() const
Qualifiers withoutObjCLifetime() const
Qualifiers withoutObjCGCAttr() const
static Qualifiers fromCVRUMask(unsigned CVRU)
friend Qualifiers operator+(Qualifiers L, Qualifiers R)
void setUnaligned(bool flag)
void addFastQualifiers(unsigned mask)
std::string getAsString() const
Qualifiers withRestrict() const
void addPointerAuth(PointerAuthQualifier Q)
void addObjCGCAttr(GC type)
bool hasPointerAuth() const
bool operator==(Qualifiers Other) const
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
bool isAddressSpaceSupersetOf(Qualifiers other, const ASTContext &Ctx) const
Returns true if the address space in these qualifiers is equal to or a superset of the address space ...
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.
SubstTemplateTypeParmTypeFlag getSubstitutionFlag() const
static void Profile(llvm::FoldingSetNodeID &ID, QualType Replacement, const Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex, SubstTemplateTypeParmTypeFlag Flag)
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)
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
TemplateTypeParmTypeBitfields TemplateTypeParmTypeBits
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< Attr > attr
Matches attributes.
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.
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)
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.
@ Create
'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
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)
SubstTemplateTypeParmTypeFlag
@ ExpandPacksInPlace
Whether to expand the pack using the stored PackIndex in place.
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
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(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...
friend bool operator==(const Attributes &LHS, const Attributes &RHS)
llvm::dxil::ResourceClass ResourceClass
friend bool operator!=(const Attributes &LHS, const Attributes &RHS)
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)