17#ifndef LLVM_CLANG_AST_TYPE_BASE_H
18#define LLVM_CLANG_AST_TYPE_BASE_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"
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 ClassTemplateDecl;
137class TemplateArgument;
138class TemplateArgumentListInfo;
139class TemplateArgumentLoc;
140class TemplateTypeParmDecl;
141class TypedefNameDecl;
142class UnresolvedUsingTypenameDecl;
143class UsingShadowDecl;
148#define TYPE(Class, Base) class Class##Type;
149#include "clang/AST/TypeNodes.inc"
152class PointerAuthQualifier {
156 EnabledMask = 1 << EnabledShift,
157 AddressDiscriminatedShift = EnabledShift + EnabledBits,
158 AddressDiscriminatedBits = 1,
159 AddressDiscriminatedMask = 1 << AddressDiscriminatedShift,
160 AuthenticationModeShift =
161 AddressDiscriminatedShift + AddressDiscriminatedBits,
162 AuthenticationModeBits = 2,
163 AuthenticationModeMask = ((1 << AuthenticationModeBits) - 1)
164 << AuthenticationModeShift,
165 IsaPointerShift = AuthenticationModeShift + AuthenticationModeBits,
167 IsaPointerMask = ((1 << IsaPointerBits) - 1) << IsaPointerShift,
168 AuthenticatesNullValuesShift = IsaPointerShift + IsaPointerBits,
169 AuthenticatesNullValuesBits = 1,
170 AuthenticatesNullValuesMask = ((1 << AuthenticatesNullValuesBits) - 1)
171 << AuthenticatesNullValuesShift,
172 KeyShift = AuthenticatesNullValuesShift + AuthenticatesNullValuesBits,
174 KeyMask = ((1 << KeyBits) - 1) << KeyShift,
175 DiscriminatorShift = KeyShift + KeyBits,
176 DiscriminatorBits = 16,
177 DiscriminatorMask = ((1u << DiscriminatorBits) - 1) << DiscriminatorShift,
188 static_assert((EnabledBits + AddressDiscriminatedBits +
189 AuthenticationModeBits + IsaPointerBits +
190 AuthenticatesNullValuesBits + KeyBits + DiscriminatorBits) ==
192 "PointerAuthQualifier should be exactly 32 bits");
193 static_assert((EnabledMask + AddressDiscriminatedMask +
194 AuthenticationModeMask + IsaPointerMask +
195 AuthenticatesNullValuesMask + KeyMask + DiscriminatorMask) ==
197 "All masks should cover the entire bits");
198 static_assert((EnabledMask ^ AddressDiscriminatedMask ^
199 AuthenticationModeMask ^ IsaPointerMask ^
200 AuthenticatesNullValuesMask ^ KeyMask ^ DiscriminatorMask) ==
202 "All masks should cover the entire bits");
205 unsigned ExtraDiscriminator,
207 bool IsIsaPointer,
bool AuthenticatesNullValues)
209 (IsAddressDiscriminated
210 ? llvm::to_underlying(AddressDiscriminatedMask)
213 (llvm::to_underlying(AuthenticationMode)
214 << AuthenticationModeShift) |
215 (ExtraDiscriminator << DiscriminatorShift) |
216 (IsIsaPointer << IsaPointerShift) |
217 (AuthenticatesNullValues << AuthenticatesNullValuesShift)) {
220 assert((Data == 0) ==
238 static PointerAuthQualifier
239 Create(
unsigned Key,
bool IsAddressDiscriminated,
unsigned ExtraDiscriminator,
241 bool AuthenticatesNullValues) {
246 AuthenticationMode, IsIsaPointer,
247 AuthenticatesNullValues);
251 assert((Data == 0) ==
260 return (Data & KeyMask) >> KeyShift;
267 return (Data & AddressDiscriminatedMask) >> AddressDiscriminatedShift;
272 return (Data >> DiscriminatorShift);
277 AuthenticationModeShift);
282 return (Data & IsaPointerMask) >> IsaPointerShift;
287 return (Data & AuthenticatesNullValuesMask) >> AuthenticatesNullValuesShift;
294 friend bool operator==(PointerAuthQualifier Lhs, PointerAuthQualifier Rhs) {
295 return Lhs.Data == Rhs.Data;
297 friend bool operator!=(PointerAuthQualifier Lhs, PointerAuthQualifier Rhs) {
298 return Lhs.Data != Rhs.Data;
309 PointerAuthQualifier
Result;
311 assert((
Result.Data == 0) ==
322 void Profile(llvm::FoldingSetNodeID &ID)
const { ID.AddInteger(Data); }
398 Q.Mask = L.Mask & R.Mask;
492 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
496 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
497 Mask &= ~static_cast<uint64_t>(mask);
503 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
507 assert(!(mask & ~
CVRMask & ~UMask) &&
"bitmask contains non-CVRU bits");
513 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
521 Mask = (Mask & ~GCAttrMask) | (
type << GCAttrShift);
546 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
549 Mask = (Mask & ~LifetimeMask) | (
type << LifetimeShift);
555 Mask |= (
type << LifetimeShift);
572 return static_cast<LangAS>((Mask & AddressSpaceMask) >> AddressSpaceShift);
593 Mask = (Mask & ~AddressSpaceMask)
594 | (((uint32_t) space) << AddressSpaceShift);
607 Mask = (Mask & ~PtrAuthMask) |
621 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
625 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
626 Mask &= ~static_cast<uint64_t>(mask);
632 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
647 bool empty()
const {
return !Mask; }
802 bool appendSpaceIfNonEmpty =
false)
const;
804 void Profile(llvm::FoldingSetNodeID &ID)
const { ID.AddInteger(Mask); }
811 "PointerAuthQualifier must be 32 bits");
813 static constexpr uint64_t PtrAuthShift = 32;
814 static constexpr uint64_t PtrAuthMask = UINT64_C(0xffffffff) << PtrAuthShift;
816 static constexpr uint64_t UMask = 0x8;
817 static constexpr uint64_t UShift = 3;
818 static constexpr uint64_t GCAttrMask = 0x30;
819 static constexpr uint64_t GCAttrShift = 4;
820 static constexpr uint64_t LifetimeMask = 0x1C0;
821 static constexpr uint64_t LifetimeShift = 6;
822 static constexpr uint64_t AddressSpaceMask =
823 ~(
CVRMask | UMask | GCAttrMask | LifetimeMask | PtrAuthMask);
824 static constexpr uint64_t AddressSpaceShift = 9;
834 : Quals(Quals), HasAtomic(HasAtomic) {}
854 return {Quals.withVolatile(), HasAtomic};
858 return {Quals.withRestrict(), HasAtomic};
883 std::pair<const Type *,Qualifiers>
asPair()
const {
884 return std::pair<const Type *, Qualifiers>(
Ty,
Quals);
888 return a.
Ty ==
b.Ty && a.
Quals ==
b.Quals;
891 return a.
Ty !=
b.Ty || a.
Quals !=
b.Quals;
941 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
944 const ExtQuals *getExtQualsUnsafe()
const {
948 const Type *getTypePtrUnsafe()
const {
952 const ExtQualsTypeCommonBase *getCommonPtr()
const {
953 assert(!
isNull() &&
"Cannot retrieve a NULL type pointer");
954 auto CommonPtrVal =
reinterpret_cast<uintptr_t>(
Value.getOpaqueValue());
956 return reinterpret_cast<ExtQualsTypeCommonBase*
>(CommonPtrVal);
988 T.Value.setFromOpaqueValue(
const_cast<void*
>(Ptr));
1005 return Value.getPointer().isNull();
1032 std::optional<NonConstantStorageReason>
1185 &&
"non-fast qualifier bits set in mask!");
1186 Value.setInt(Value.getInt() | TQs);
1196 Value.setInt(Value.getInt() & ~Mask);
1203 T.addFastQualifiers(TQs);
1216 T.removeLocalFastQualifiers();
1310 return getSingleStepDesugaredTypeImpl(*
this, Context);
1323 return LHS.Value == RHS.Value;
1326 return LHS.Value != RHS.Value;
1329 return LHS.Value < RHS.Value;
1343 const Twine &PlaceHolder = Twine(),
1344 unsigned Indentation = 0)
const;
1348 unsigned Indentation = 0) {
1349 return print(
split.Ty,
split.Quals, OS, policy, PlaceHolder, Indentation);
1354 const Twine &PlaceHolder,
1355 unsigned Indentation = 0);
1372 const Twine &PlaceHolder;
1373 unsigned Indentation;
1377 const Twine &PlaceHolder,
unsigned Indentation)
1378 : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
1379 Indentation(Indentation) {}
1383 SQT.T.
print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1389 const Twine &PlaceHolder = Twine(),
1390 unsigned Indentation = 0)
const {
1394 void dump(
const char *
s)
const;
1396 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
1459 return PtrAuth.isAddressDiscriminated();
1546 return isDestructedTypeImpl(*
this);
1648raw_ostream &
operator<<(raw_ostream &OS, QualType QT);
1686class ExtQualsTypeCommonBase {
1697 const Type *
const BaseType;
1702 ExtQualsTypeCommonBase(
const Type *baseType,
QualType canon)
1703 : BaseType(baseType), CanonicalType(canon) {}
1716class alignas(TypeAlignment)
ExtQuals :
public ExtQualsTypeCommonBase,
1717 public llvm::FoldingSetNode {
1739 : ExtQualsTypeCommonBase(baseType,
1740 canon.isNull() ?
QualType(this_(), 0) : canon),
1742 assert(Quals.hasNonFastQualifiers()
1743 &&
"ExtQuals created with no fast qualifiers");
1744 assert(!Quals.hasFastQualifiers()
1745 &&
"ExtQuals created with fast qualifiers");
1755 return Quals.getObjCLifetime();
1769 const Type *BaseType,
1771 assert(!Quals.hasFastQualifiers() &&
"fast qualifiers in ExtQuals hash!");
1772 ID.AddPointer(BaseType);
1803enum class ArraySizeModifier;
1804enum class ElaboratedTypeKeyword;
1805enum class VectorKind;
1833class alignas(TypeAlignment)
Type :
public ExtQualsTypeCommonBase {
1836#define TYPE(Class, Base) Class,
1837#define LAST_TYPE(Class) TypeLast = Class
1838#define ABSTRACT_TYPE(Class, Base)
1839#include "clang/AST/TypeNodes.inc"
1844 class TypeBitfields {
1846 template <
class T>
friend class TypePropertyCache;
1849 LLVM_PREFERRED_TYPE(TypeClass)
1854 unsigned Dependence : llvm::BitWidth<TypeDependence>;
1858 LLVM_PREFERRED_TYPE(
bool)
1859 mutable unsigned CacheValid : 1;
1863 mutable unsigned CachedLinkage : 3;
1866 LLVM_PREFERRED_TYPE(
bool)
1867 mutable unsigned CachedLocalOrUnnamed : 1;
1870 LLVM_PREFERRED_TYPE(
bool)
1871 mutable unsigned FromAST : 1;
1873 bool isCacheValid()
const {
1878 assert(isCacheValid() &&
"getting linkage from invalid cache");
1879 return static_cast<Linkage>(CachedLinkage);
1882 bool hasLocalOrUnnamedType()
const {
1883 assert(isCacheValid() &&
"getting linkage from invalid cache");
1884 return CachedLocalOrUnnamed;
1887 enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
1896 LLVM_PREFERRED_TYPE(TypeBitfields)
1902 unsigned IndexTypeQuals : 3;
1907 unsigned SizeModifier : 3;
1918 LLVM_PREFERRED_TYPE(
bool)
1919 unsigned HasExternalSize : 1;
1921 LLVM_PREFERRED_TYPE(
unsigned)
1922 unsigned SizeWidth : 5;
1928 LLVM_PREFERRED_TYPE(TypeBitfields)
1932 static constexpr unsigned NumOfBuiltinTypeBits = 9;
1933 unsigned Kind : NumOfBuiltinTypeBits;
1948 LLVM_PREFERRED_TYPE(TypeBitfields)
1955 unsigned RefQualifier : 2;
1966 LLVM_PREFERRED_TYPE(
bool)
1967 unsigned HasExtQuals : 1;
1971 unsigned ExceptionSpecType : 4;
1974 LLVM_PREFERRED_TYPE(
bool)
1975 unsigned HasExtParameterInfos : 1;
1978 LLVM_PREFERRED_TYPE(
bool)
1979 unsigned HasExtraBitfields : 1;
1982 LLVM_PREFERRED_TYPE(
bool)
1983 unsigned Variadic : 1;
1986 LLVM_PREFERRED_TYPE(
bool)
1987 unsigned HasTrailingReturn : 1;
1990 LLVM_PREFERRED_TYPE(
bool)
1991 unsigned CFIUncheckedCallee : 1;
1996 unsigned ExtInfo : 14;
2008 LLVM_PREFERRED_TYPE(TypeBitfields)
2012 unsigned NumTypeArgs : 7;
2015 unsigned NumProtocols : 6;
2018 LLVM_PREFERRED_TYPE(
bool)
2019 unsigned IsKindOf : 1;
2025 LLVM_PREFERRED_TYPE(TypeBitfields)
2039 LLVM_PREFERRED_TYPE(
bool)
2040 unsigned SpelledAsLValue : 1;
2044 LLVM_PREFERRED_TYPE(
bool)
2045 unsigned InnerRef : 1;
2051 LLVM_PREFERRED_TYPE(TypeBitfields)
2056 unsigned Keyword : 8;
2068 LLVM_PREFERRED_TYPE(
bool)
2069 unsigned HasQualifier : 1;
2072 LLVM_PREFERRED_TYPE(
bool)
2073 unsigned OwnsTag : 1;
2076 LLVM_PREFERRED_TYPE(
bool)
2077 unsigned IsInjected : 1;
2084 LLVM_PREFERRED_TYPE(TypeBitfields)
2090 unsigned VecKind : 4;
2092 uint32_t NumElements;
2098 LLVM_PREFERRED_TYPE(TypeBitfields)
2102 unsigned AttrKind : 32 - NumTypeBits;
2108 LLVM_PREFERRED_TYPE(TypeBitfields)
2114 unsigned Keyword : 2;
2130 LLVM_PREFERRED_TYPE(TypeBitfields)
2143 LLVM_PREFERRED_TYPE(
bool)
2144 unsigned hasQualifier : 1;
2154 LLVM_PREFERRED_TYPE(
bool)
2155 unsigned hasQualifier : 1;
2165 LLVM_PREFERRED_TYPE(
bool)
2166 unsigned hasQualifier : 1;
2169 LLVM_PREFERRED_TYPE(
bool)
2170 unsigned hasTypeDifferentFromDecl : 1;
2176 LLVM_PREFERRED_TYPE(TypeBitfields)
2180 unsigned Depth : 15;
2183 LLVM_PREFERRED_TYPE(
bool)
2184 unsigned ParameterPack : 1;
2187 unsigned Index : 16;
2193 LLVM_PREFERRED_TYPE(TypeBitfields)
2196 LLVM_PREFERRED_TYPE(
bool)
2197 unsigned HasNonCanonicalUnderlyingType : 1;
2200 unsigned Index : 15;
2202 LLVM_PREFERRED_TYPE(
bool)
2210 unsigned PackIndex : 15;
2217 LLVM_PREFERRED_TYPE(TypeBitfields)
2224 unsigned NumArgs : 16;
2230 unsigned SubstTemplTypeParmPackIndex : 16;
2240 LLVM_PREFERRED_TYPE(
bool)
2241 unsigned TypeAlias : 1;
2256 LLVM_PREFERRED_TYPE(TypeBitfields)
2270 unsigned NumExpansions;
2290 LLVM_PREFERRED_TYPE(TypeBitfields)
2300 LLVM_PREFERRED_TYPE(TypeBitfields)
2303 static constexpr unsigned NumCoupledDeclsBits = 4;
2304 unsigned NumCoupledDecls : NumCoupledDeclsBits;
2305 LLVM_PREFERRED_TYPE(
bool)
2306 unsigned CountInBytes : 1;
2307 LLVM_PREFERRED_TYPE(
bool)
2308 unsigned OrNull : 1;
2342 void setFromAST(
bool V =
true)
const {
2350 : ExtQualsTypeCommonBase(this,
2352 static_assert(
sizeof(*this) <=
2353 alignof(
decltype(*this)) +
sizeof(ExtQualsTypeCommonBase),
2354 "changing bitfields changed sizeof(Type)!");
2355 static_assert(
alignof(
decltype(*this)) %
TypeAlignment == 0,
2356 "Insufficient alignment!");
2360 TypeBits.CachedLocalOrUnnamed =
false;
2369 TypeBits.Dependence =
static_cast<unsigned>(D);
2412 return CanonicalType ==
QualType(
this, 0);
2418 QualType getLocallyUnqualifiedSingleStepDesugaredType()
const;
2426 bool isSizelessType()
const;
2427 bool isSizelessBuiltinType()
const;
2430 bool isSizelessVectorType()
const;
2433 bool isSVESizelessBuiltinType()
const;
2436 bool isRVVSizelessBuiltinType()
const;
2439 bool isWebAssemblyExternrefType()
const;
2444 bool isWebAssemblyTableType()
const;
2449 bool isSveVLSBuiltinType()
const;
2459 bool isRVVVLSBuiltinType()
const;
2481 bool isIncompleteType(
NamedDecl **Def =
nullptr)
const;
2507 bool isAlwaysIncompleteType()
const;
2519 bool isLiteralType(
const ASTContext &Ctx)
const;
2522 bool isStructuralType()
const;
2526 bool isStandardLayoutType()
const;
2532 bool isBuiltinType()
const;
2535 bool isSpecificBuiltinType(
unsigned K)
const;
2540 bool isPlaceholderType()
const;
2544 bool isSpecificPlaceholderType(
unsigned K)
const;
2548 bool isNonOverloadPlaceholderType()
const;
2552 bool isIntegerType()
const;
2553 bool isEnumeralType()
const;
2556 bool isScopedEnumeralType()
const;
2558 bool isCharType()
const;
2559 bool isWideCharType()
const;
2560 bool isChar8Type()
const;
2561 bool isChar16Type()
const;
2562 bool isChar32Type()
const;
2563 bool isAnyCharacterType()
const;
2564 bool isUnicodeCharacterType()
const;
2565 bool isIntegralType(
const ASTContext &Ctx)
const;
2568 bool isIntegralOrEnumerationType()
const;
2571 bool isIntegralOrUnscopedEnumerationType()
const;
2572 bool isUnscopedEnumerationType()
const;
2575 bool isRealFloatingType()
const;
2578 bool isComplexType()
const;
2579 bool isAnyComplexType()
const;
2580 bool isFloatingType()
const;
2581 bool isHalfType()
const;
2582 bool isFloat16Type()
const;
2583 bool isFloat32Type()
const;
2584 bool isDoubleType()
const;
2585 bool isBFloat16Type()
const;
2586 bool isMFloat8Type()
const;
2587 bool isFloat128Type()
const;
2588 bool isIbm128Type()
const;
2589 bool isRealType()
const;
2590 bool isArithmeticType()
const;
2591 bool isVoidType()
const;
2592 bool isScalarType()
const;
2593 bool isAggregateType()
const;
2594 bool isFundamentalType()
const;
2595 bool isCompoundType()
const;
2599 bool isFunctionType()
const;
2602 bool isPointerType()
const;
2603 bool isPointerOrReferenceType()
const;
2604 bool isSignableType(
const ASTContext &Ctx)
const;
2605 bool isSignablePointerType()
const;
2606 bool isSignableIntegerType(
const ASTContext &Ctx)
const;
2607 bool isAnyPointerType()
const;
2608 bool isCountAttributedType()
const;
2609 bool isCFIUncheckedCalleeFunctionType()
const;
2610 bool hasPointeeToToCFIUncheckedCalleeFunctionType()
const;
2611 bool isBlockPointerType()
const;
2612 bool isVoidPointerType()
const;
2613 bool isReferenceType()
const;
2614 bool isLValueReferenceType()
const;
2615 bool isRValueReferenceType()
const;
2616 bool isObjectPointerType()
const;
2617 bool isFunctionPointerType()
const;
2618 bool isFunctionReferenceType()
const;
2619 bool isMemberPointerType()
const;
2620 bool isMemberFunctionPointerType()
const;
2621 bool isMemberDataPointerType()
const;
2622 bool isArrayType()
const;
2623 bool isConstantArrayType()
const;
2624 bool isIncompleteArrayType()
const;
2625 bool isVariableArrayType()
const;
2626 bool isArrayParameterType()
const;
2627 bool isDependentSizedArrayType()
const;
2629 bool isClassType()
const;
2630 bool isStructureType()
const;
2631 bool isStructureTypeWithFlexibleArrayMember()
const;
2632 bool isObjCBoxableRecordType()
const;
2633 bool isInterfaceType()
const;
2634 bool isStructureOrClassType()
const;
2635 bool isUnionType()
const;
2636 bool isComplexIntegerType()
const;
2637 bool isVectorType()
const;
2638 bool isExtVectorType()
const;
2639 bool isExtVectorBoolType()
const;
2642 bool isPackedVectorBoolType(
const ASTContext &ctx)
const;
2643 bool isSubscriptableVectorType()
const;
2644 bool isMatrixType()
const;
2645 bool isConstantMatrixType()
const;
2646 bool isDependentAddressSpaceType()
const;
2647 bool isObjCObjectPointerType()
const;
2648 bool isObjCRetainableType()
const;
2649 bool isObjCLifetimeType()
const;
2650 bool isObjCIndirectLifetimeType()
const;
2651 bool isObjCNSObjectType()
const;
2652 bool isObjCIndependentClassType()
const;
2655 bool isObjCObjectType()
const;
2656 bool isObjCQualifiedInterfaceType()
const;
2657 bool isObjCQualifiedIdType()
const;
2658 bool isObjCQualifiedClassType()
const;
2659 bool isObjCObjectOrInterfaceType()
const;
2660 bool isObjCIdType()
const;
2661 bool isDecltypeType()
const;
2669 return hasAttr(attr::ObjCInertUnsafeUnretained);
2679 bool isObjCIdOrObjectKindOfType(
const ASTContext &ctx,
2682 bool isObjCClassType()
const;
2690 bool isObjCClassOrClassKindOfType()
const;
2692 bool isBlockCompatibleObjCPointerType(
ASTContext &ctx)
const;
2693 bool isObjCSelType()
const;
2694 bool isObjCBuiltinType()
const;
2695 bool isObjCARCBridgableType()
const;
2696 bool isCARCBridgableType()
const;
2697 bool isTemplateTypeParmType()
const;
2698 bool isNullPtrType()
const;
2700 bool isNothrowT()
const;
2701 bool isAlignValT()
const;
2702 bool isStdByteType()
const;
2703 bool isAtomicType()
const;
2704 bool isUndeducedAutoType()
const;
2706 bool isTypedefNameType()
const;
2708#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2709 bool is##Id##Type() const;
2710#include "clang/Basic/OpenCLImageTypes.def"
2712 bool isImageType()
const;
2714 bool isSamplerT()
const;
2715 bool isEventT()
const;
2716 bool isClkEventT()
const;
2717 bool isQueueT()
const;
2718 bool isReserveIDT()
const;
2720#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2721 bool is##Id##Type() const;
2722#include "clang/Basic/OpenCLExtensionTypes.def"
2724 bool isOCLIntelSubgroupAVCType()
const;
2725 bool isOCLExtOpaqueType()
const;
2727 bool isPipeType()
const;
2728 bool isBitIntType()
const;
2729 bool isOpenCLSpecificType()
const;
2731#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) bool is##Id##Type() const;
2732#include "clang/Basic/HLSLIntangibleTypes.def"
2733 bool isHLSLSpecificType()
const;
2734 bool isHLSLBuiltinIntangibleType()
const;
2735 bool isHLSLAttributedResourceType()
const;
2736 bool isHLSLInlineSpirvType()
const;
2737 bool isHLSLResourceRecord()
const;
2738 bool isHLSLResourceRecordArray()
const;
2739 bool isHLSLIntangibleType()
2745 bool isObjCARCImplicitlyUnretainedType()
const;
2748 bool isCUDADeviceBuiltinSurfaceType()
const;
2750 bool isCUDADeviceBuiltinTextureType()
const;
2753 Qualifiers::ObjCLifetime getObjCARCImplicitLifetime()
const;
2769 ScalarTypeKind getScalarTypeKind()
const;
2797 bool isUndeducedType()
const;
2806 bool hasSizedVLAType()
const;
2809 bool hasUnnamedOrLocalType()
const;
2811 bool isOverloadableType()
const;
2814 bool isElaboratedTypeSpecifier()
const;
2816 bool canDecayToPointerType()
const;
2821 bool hasPointerRepresentation()
const;
2825 bool hasObjCPointerRepresentation()
const;
2829 bool hasIntegerRepresentation()
const;
2833 bool hasSignedIntegerRepresentation()
const;
2837 bool hasUnsignedIntegerRepresentation()
const;
2841 bool hasFloatingRepresentation()
const;
2846 bool hasBooleanRepresentation()
const;
2851 const RecordType *getAsStructureType()
const;
2853 const RecordType *getAsUnionType()
const;
2854 const ComplexType *getAsComplexIntegerType()
const;
2875 inline EnumDecl *getAsEnumDecl()
const;
2876 inline EnumDecl *castAsEnumDecl()
const;
2881 inline TagDecl *getAsTagDecl()
const;
2882 inline TagDecl *castAsTagDecl()
const;
2894 DeducedType *getContainedDeducedType()
const;
2906 bool hasAutoForTrailingReturnType()
const;
2917 template <
typename T>
const T *getAs()
const;
2922 return dyn_cast<T>(CanonicalType);
2929 return cast<T>(CanonicalType);
2933#define TYPE(Class, Base)
2934#define NEVER_CANONICAL_TYPE(Class) \
2935 template <> inline const Class##Type *Type::getAsCanonical() const = delete; \
2936 template <> inline const Class##Type *Type::castAsCanonical() const = delete;
2937#include "clang/AST/TypeNodes.inc"
2943 const TemplateSpecializationType *
2944 getAsNonAliasTemplateSpecializationType()
const;
2946 const TemplateSpecializationType *
2949 assert(TST &&
"not a TemplateSpecializationType");
2958 template <
typename T>
const T *getAsAdjusted()
const;
2962 const ArrayType *getAsArrayTypeUnsafe()
const;
2970 template <
typename T>
const T *castAs()
const;
2974 const ArrayType *castAsArrayTypeUnsafe()
const;
2988 const Type *getBaseElementTypeUnsafe()
const;
2993 const Type *getArrayElementTypeNoTypeQual()
const;
2998 const Type *getPointeeOrArrayElementType()
const;
3006 const Type *getUnqualifiedDesugaredType()
const;
3011 bool isSignedIntegerType()
const;
3016 bool isUnsignedIntegerType()
const;
3020 bool isSignedIntegerOrEnumerationType()
const;
3024 bool isUnsignedIntegerOrEnumerationType()
const;
3028 bool isFixedPointType()
const;
3031 bool isFixedPointOrIntegerType()
const;
3034 bool isConvertibleToFixedPointType()
const;
3038 bool isSaturatedFixedPointType()
const;
3042 bool isUnsaturatedFixedPointType()
const;
3046 bool isSignedFixedPointType()
const;
3050 bool isUnsignedFixedPointType()
const;
3055 bool isConstantSizeType()
const;
3059 bool isSpecifierType()
const;
3079 bool isLinkageValid()
const;
3086 std::optional<NullabilityKind> getNullability()
const;
3093 bool canHaveNullability(
bool ResultIfUnknown =
true)
const;
3110 std::optional<ArrayRef<QualType>>
3111 getObjCSubstitutions(
const DeclContext *dc)
const;
3115 bool acceptsObjCTypeParams()
const;
3117 const char *getTypeClassName()
const;
3120 return CanonicalType;
3125 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
3152#define TYPE(Class, Base)
3153#define ALWAYS_CANONICAL_TYPE(Class) \
3154 template <> inline const Class##Type *Type::getAs() const { \
3155 return dyn_cast<Class##Type>(CanonicalType); \
3157 template <> inline const Class##Type *Type::castAs() const { \
3158 return cast<Class##Type>(CanonicalType); \
3160#include "clang/AST/TypeNodes.inc"
3168#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
3169#include "clang/Basic/OpenCLImageTypes.def"
3171#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
3172#include "clang/Basic/OpenCLExtensionTypes.def"
3174#define SVE_TYPE(Name, Id, SingletonId) Id,
3175#include "clang/Basic/AArch64ACLETypes.def"
3177#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
3178#include "clang/Basic/PPCTypes.def"
3180#define RVV_TYPE(Name, Id, SingletonId) Id,
3181#include "clang/Basic/RISCVVTypes.def"
3183#define WASM_TYPE(Name, Id, SingletonId) Id,
3184#include "clang/Basic/WebAssemblyReferenceTypes.def"
3186#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) Id,
3187#include "clang/Basic/AMDGPUTypes.def"
3189#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) Id,
3190#include "clang/Basic/HLSLIntangibleTypes.def"
3192#define BUILTIN_TYPE(Id, SingletonId) Id,
3193#define LAST_BUILTIN_TYPE(Id) LastKind = Id
3194#include "clang/AST/BuiltinTypes.def"
3204 static_assert(Kind::LastKind <
3205 (1 << BuiltinTypeBitfields::NumOfBuiltinTypeBits) &&
3206 "Defined builtin type exceeds the allocated space for serial "
3217 StringRef str =
getName(Policy);
3218 assert(!str.empty() && str.data()[str.size()] ==
'\0');
3275class ComplexType :
public Type,
public llvm::FoldingSetNode {
3282 ElementType(Element) {}
3302class ParenType :
public Type,
public llvm::FoldingSetNode {
3328class PointerType :
public Type,
public llvm::FoldingSetNode {
3335 PointeeType(Pointee) {}
3358 using BaseTy = llvm::PointerIntPair<ValueDecl *, 1, unsigned>;
3373 bool isDeref()
const;
3375 unsigned getInt()
const;
3376 void *getOpaqueValue()
const;
3378 void setFromOpaqueValue(
void *
V);
3416 bool referencesFieldDecls()
const;
3422 switch (
T->getTypeClass()) {
3423 case CountAttributed:
3433class CountAttributedType final
3435 public llvm::TrailingObjects<CountAttributedType,
3436 TypeCoupledDeclRefInfo> {
3447 bool CountInBytes,
bool OrNull,
3450 unsigned numTrailingObjects(OverloadToken<TypeCoupledDeclRefInfo>)
const {
3476 static void Profile(llvm::FoldingSetNodeID &ID,
QualType WrappedTy,
3480 return T->getTypeClass() == CountAttributed;
3483 StringRef getAttributeName(
bool WithMacroPrefix)
const;
3498 :
Type(TC, CanonicalPtr,
3501 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
3511 Profile(ID, OriginalTy, AdjustedTy);
3516 ID.AddPointer(
New.getAsOpaquePtr());
3520 return T->getTypeClass() == Adjusted ||
T->getTypeClass() == Decayed;
3542class BlockPointerType :
public Type,
public llvm::FoldingSetNode {
3550 PointeeType(Pointee) {}
3568 return T->getTypeClass() == BlockPointer;
3578 bool SpelledAsLValue)
3580 PointeeType(Referencee) {
3594 while (
T->isInnerRef())
3596 return T->PointeeType;
3605 bool SpelledAsLValue) {
3607 ID.AddBoolean(SpelledAsLValue);
3611 return T->getTypeClass() == LValueReference ||
3612 T->getTypeClass() == RValueReference;
3621 bool SpelledAsLValue)
3630 return T->getTypeClass() == LValueReference;
3646 return T->getTypeClass() == RValueReference;
3653class MemberPointerType :
public Type,
public llvm::FoldingSetNode {
3664 :
Type(MemberPointer, CanonicalPtr,
3668 PointeeType(Pointee), Qualifier(Qualifier) {}
3676 return PointeeType->isFunctionProtoType();
3682 return !PointeeType->isFunctionProtoType();
3691 bool isSugared()
const;
3703 static void Profile(llvm::FoldingSetNodeID &ID,
QualType Pointee,
3708 return T->getTypeClass() == MemberPointer;
3731 unsigned tq,
const Expr *sz =
nullptr);
3749 return T->getTypeClass() == ConstantArray ||
3750 T->getTypeClass() == VariableArray ||
3751 T->getTypeClass() == IncompleteArray ||
3752 T->getTypeClass() == DependentSizedArray ||
3753 T->getTypeClass() == ArrayParameter;
3763 struct ExternalSize {
3764 ExternalSize(
const llvm::APInt &Sz,
const Expr *SE)
3765 :
Size(Sz), SizeExpr(SE) {}
3767 const Expr *SizeExpr;
3778 ConstantArrayTypeBits.HasExternalSize =
false;
3779 ConstantArrayTypeBits.SizeWidth = Width / 8;
3782 assert(Width < 0xFF &&
"Type width in bits must be less than 8 bits");
3785 ConstantArrayType(QualType Et, QualType Can, ExternalSize *SzPtr,
3786 ArraySizeModifier
SM,
unsigned TQ)
3787 : ArrayType(ConstantArray, Et, Can,
SM, TQ, SzPtr->SizeExpr),
3789 ConstantArrayTypeBits.HasExternalSize =
true;
3790 ConstantArrayTypeBits.SizeWidth = 0;
3792 assert((SzPtr->SizeExpr ==
nullptr || !Can.isNull()) &&
3793 "canonical constant array should not have size expression");
3796 static ConstantArrayType *
Create(
const ASTContext &Ctx, QualType ET,
3797 QualType Can,
const llvm::APInt &Sz,
3798 const Expr *SzExpr, ArraySizeModifier SzMod,
3808 ConstantArrayTypeBits.SizeWidth = ATy->ConstantArrayTypeBits.SizeWidth;
3844 :
static_cast<int64_t
>(
Size);
3851 ?
SizePtr->Size.getLimitedValue()
3865 static unsigned getNumAddressingBits(
const ASTContext &Context,
3867 const llvm::APInt &NumElements);
3869 unsigned getNumAddressingBits(
const ASTContext &Context)
const;
3873 static unsigned getMaxSizeBits(
const ASTContext &Context);
3880 static void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Ctx,
3885 return T->getTypeClass() == ConstantArray ||
3886 T->getTypeClass() == ArrayParameter;
3892class ArrayParameterType :
public ConstantArrayType {
3895 ArrayParameterType(
const ConstantArrayType *ATy,
QualType CanTy)
3896 : ConstantArrayType(ArrayParameter, ATy, CanTy) {}
3900 return T->getTypeClass() == ArrayParameter;
3914 :
ArrayType(IncompleteArray, et, can, sm, tq) {}
3923 return T->getTypeClass() == IncompleteArray;
3934 ID.AddInteger(llvm::to_underlying(SizeMod));
3935 ID.AddInteger(TypeQuals);
3975 :
ArrayType(VariableArray, et, can, sm, tq, e), SizeExpr((
Stmt *)e) {}
3983 return (
Expr*) SizeExpr;
3990 return T->getTypeClass() == VariableArray;
3994 llvm_unreachable(
"Cannot unique VariableArrayTypes.");
4030 return (
Expr*) SizeExpr;
4037 return T->getTypeClass() == DependentSizedArray;
4045 static void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
4047 unsigned TypeQuals,
Expr *E);
4061class DependentAddressSpaceType :
public Type,
public llvm::FoldingSetNode {
4064 Expr *AddrSpaceExpr;
4080 return T->getTypeClass() == DependentAddressSpace;
4087 static void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
4101class DependentSizedExtVectorType :
public Type,
public llvm::FoldingSetNode {
4123 return T->getTypeClass() == DependentSizedExtVector;
4130 static void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
4208 ID.AddInteger(NumElements);
4210 ID.AddInteger(llvm::to_underlying(VecKind));
4214 return T->getTypeClass() ==
Vector ||
T->getTypeClass() == ExtVector;
4227class DependentVectorType :
public Type,
public llvm::FoldingSetNode {
4249 return T->getTypeClass() == DependentVector;
4256 static void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
4271 :
VectorType(ExtVector, vecType, nElements, canonType,
4278 case 'x':
case 'r':
return 0;
4279 case 'y':
case 'g':
return 1;
4280 case 'z':
case 'b':
return 2;
4281 case 'w':
case 'a':
return 3;
4299 case 'a':
return 10;
4301 case 'b':
return 11;
4303 case 'c':
return 12;
4305 case 'd':
return 13;
4307 case 'e':
return 14;
4309 case 'f':
return 15;
4314 if (isNumericAccessor)
4330 return T->getTypeClass() == ExtVector;
4347 const Expr *RowExpr =
nullptr,
const Expr *ColumnExpr =
nullptr);
4359 return T->isDependentType() ||
4360 (
T->isRealType() && !
T->isBooleanType() && !
T->isEnumeralType());
4367 return T->getTypeClass() == ConstantMatrix ||
4368 T->getTypeClass() == DependentSizedMatrix;
4384 unsigned NColumns,
QualType CanonElementType);
4387 unsigned NColumns,
QualType CanonElementType);
4426 return T->getTypeClass() == ConstantMatrix;
4449 return T->getTypeClass() == DependentSizedMatrix;
4456 static void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
4492 HasPassObjSize = 0x20,
4495 unsigned char Data = 0;
4504 copy.Data = (copy.Data & ~ABIMask) |
unsigned(kind);
4514 copy.Data |= IsConsumed;
4516 copy.Data &= ~IsConsumed;
4523 Copy.Data |= HasPassObjSize;
4531 Copy.Data |= IsNoEscape;
4533 Copy.Data &= ~IsNoEscape;
4545 return lhs.Data == rhs.Data;
4549 return lhs.Data != rhs.Data;
4584 enum { CallConvMask = 0x3F };
4585 enum { NoReturnMask = 0x40 };
4586 enum { ProducesResultMask = 0x80 };
4587 enum { NoCallerSavedRegsMask = 0x100 };
4588 enum { RegParmMask = 0xe00, RegParmOffset = 9 };
4589 enum { NoCfCheckMask = 0x1000 };
4590 enum { CmseNSCallMask = 0x2000 };
4591 uint16_t Bits =
CC_C;
4593 ExtInfo(
unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
4599 bool producesResult,
bool noCallerSavedRegs,
bool NoCfCheck,
4601 assert((!hasRegParm || regParm < 7) &&
"Invalid regparm value");
4602 Bits = ((
unsigned)cc) | (noReturn ? NoReturnMask : 0) |
4603 (producesResult ? ProducesResultMask : 0) |
4604 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
4605 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
4606 (NoCfCheck ? NoCfCheckMask : 0) |
4607 (cmseNSCall ? CmseNSCallMask : 0);
4623 bool getHasRegParm()
const {
return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
4626 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
4635 return Bits ==
Other.Bits;
4638 return Bits !=
Other.Bits;
4646 return ExtInfo(Bits | NoReturnMask);
4648 return ExtInfo(Bits & ~NoReturnMask);
4653 return ExtInfo(Bits | ProducesResultMask);
4655 return ExtInfo(Bits & ~ProducesResultMask);
4660 return ExtInfo(Bits | CmseNSCallMask);
4662 return ExtInfo(Bits & ~CmseNSCallMask);
4666 if (noCallerSavedRegs)
4667 return ExtInfo(Bits | NoCallerSavedRegsMask);
4669 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
4674 return ExtInfo(Bits | NoCfCheckMask);
4676 return ExtInfo(Bits & ~NoCfCheckMask);
4680 assert(RegParm < 7 &&
"Invalid regparm value");
4681 return ExtInfo((Bits & ~RegParmMask) |
4682 ((RegParm + 1) << RegParmOffset));
4686 return ExtInfo((Bits & ~CallConvMask) | (
unsigned) cc);
4690 ID.AddInteger(Bits);
4708 LLVM_PREFERRED_TYPE(
bool)
4711 LLVM_PREFERRED_TYPE(
bool)
4714 LLVM_PREFERRED_TYPE(
bool)
4814 bool getCFIUncheckedCalleeAttr()
const;
4821 "Const, volatile and restrict are assumed to be a subset of "
4822 "the fast qualifiers.");
4834 static StringRef getNameForCallConv(
CallingConv CC);
4837 return T->getTypeClass() == FunctionNoProto ||
4838 T->getTypeClass() == FunctionProto;
4844class FunctionNoProtoType :
public FunctionType,
public llvm::FoldingSetNode {
4867 ID.AddPointer(ResultType.getAsOpaquePtr());
4871 return T->getTypeClass() == FunctionNoProto;
4921 Kind oppositeKind()
const;
4944 llvm_unreachable(
"unknown effect kind");
4948 StringRef name()
const;
4952 OS << Effect.
name();
4962 std::optional<FunctionEffect>
4963 effectProhibitingInference(
const Decl &Callee,
4970 bool shouldDiagnoseFunctionCall(
bool Direct,
4974 return LHS.FKind == RHS.FKind;
4977 return !(LHS == RHS);
4980 return LHS.FKind < RHS.FKind;
4987 Expr *Cond =
nullptr;
4996 return Cond == RHS.Cond;
5011 std::string description()
const;
5013 friend raw_ostream &
operator<<(raw_ostream &OS,
5022 const Container *Outer =
nullptr;
5029 return Idx ==
Other.Idx;
5032 return Idx !=
Other.Idx;
5041 assert(Outer !=
nullptr &&
"invalid FunctionEffectIterator");
5042 bool HasConds = !Outer->Conditions.empty();
5044 HasConds ? Outer->Conditions[Idx]
5066class FunctionEffectsRef {
5071 friend FunctionProtoType;
5072 friend FunctionEffectSet;
5083 : Effects(FX), Conditions(Conds) {}
5096 bool empty()
const {
return Effects.empty(); }
5097 size_t size()
const {
return Effects.size(); }
5108 const FunctionEffectsRef &RHS) {
5109 return LHS.Effects == RHS.Effects && LHS.Conditions == RHS.Conditions;
5112 const FunctionEffectsRef &RHS) {
5113 return !(LHS == RHS);
5116 void dump(llvm::raw_ostream &OS)
const;
5120class FunctionEffectKindSet {
5123 using KindBitsT = std::bitset<EndBitPos>;
5125 KindBitsT KindBits{};
5127 explicit FunctionEffectKindSet(KindBitsT KB) : KindBits(KB) {}
5133 return static_cast<size_t>(K);
5142 const FunctionEffectKindSet *Outer =
nullptr;
5147 void advanceToNextSetBit() {
5148 while (Idx < EndBitPos && !Outer->KindBits.test(Idx))
5154 iterator(
const FunctionEffectKindSet &O,
size_t I) : Outer(&O), Idx(I) {
5155 advanceToNextSetBit();
5160 iterator operator++() {
5162 advanceToNextSetBit();
5167 assert(Idx < EndBitPos &&
"Dereference of end iterator");
5176 iterator
begin()
const {
return iterator(*
this, 0); }
5177 iterator
end()
const {
return iterator(*
this, EndBitPos); }
5186 bool empty()
const {
return KindBits.none(); }
5188 return KindBits.test(kindToPos(EK));
5190 void dump(llvm::raw_ostream &OS)
const;
5192 static FunctionEffectKindSet
difference(FunctionEffectKindSet LHS,
5193 FunctionEffectKindSet RHS) {
5194 return FunctionEffectKindSet(LHS.KindBits & ~RHS.KindBits);
5210 : Effects(FX.effects()), Conditions(FX.conditions()) {}
5212 bool empty()
const {
return Effects.empty(); }
5213 size_t size()
const {
return Effects.size(); }
5222 void dump(llvm::raw_ostream &OS)
const;
5257class FunctionProtoType final
5259 public llvm::FoldingSetNode,
5260 private llvm::TrailingObjects<
5261 FunctionProtoType, QualType, SourceLocation,
5262 FunctionType::FunctionTypeExtraBitfields,
5263 FunctionType::FunctionTypeExtraAttributeInfo,
5264 FunctionType::FunctionTypeArmAttributes, FunctionType::ExceptionType,
5265 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers,
5266 FunctionEffect, EffectConditionExpr> {
5268 friend TrailingObjects;
5361 LLVM_PREFERRED_TYPE(
bool)
5363 LLVM_PREFERRED_TYPE(
bool)
5365 LLVM_PREFERRED_TYPE(
bool)
5380 Result.ExceptionSpec = ESI;
5414 unsigned numTrailingObjects(OverloadToken<QualType>)
const {
5415 return getNumParams();
5418 unsigned numTrailingObjects(OverloadToken<SourceLocation>)
const {
5419 return isVariadic();
5422 unsigned numTrailingObjects(OverloadToken<FunctionTypeArmAttributes>)
const {
5423 return hasArmTypeAttributes();
5426 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>)
const {
5427 return hasExtraBitfields();
5431 numTrailingObjects(OverloadToken<FunctionTypeExtraAttributeInfo>)
const {
5432 return hasExtraAttributeInfo();
5435 unsigned numTrailingObjects(OverloadToken<ExceptionType>)
const {
5436 return getExceptionSpecSize().NumExceptionType;
5439 unsigned numTrailingObjects(OverloadToken<Expr *>)
const {
5440 return getExceptionSpecSize().NumExprPtr;
5443 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>)
const {
5444 return getExceptionSpecSize().NumFunctionDeclPtr;
5447 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>)
const {
5448 return hasExtParameterInfos() ? getNumParams() : 0;
5451 unsigned numTrailingObjects(OverloadToken<Qualifiers>)
const {
5452 return hasExtQualifiers() ? 1 : 0;
5455 unsigned numTrailingObjects(OverloadToken<FunctionEffect>)
const {
5456 return getNumFunctionEffects();
5461 static bool containsAnyUnexpandedParameterPack(
const QualType *ArgArray,
5463 for (
unsigned Idx = 0; Idx < numArgs; ++Idx)
5464 if (ArgArray[Idx]->containsUnexpandedParameterPack())
5470 FunctionProtoType(QualType result, ArrayRef<QualType> params,
5471 QualType canonical,
const ExtProtoInfo &epi);
5476 struct ExceptionSpecSizeHolder {
5477 unsigned NumExceptionType;
5478 unsigned NumExprPtr;
5479 unsigned NumFunctionDeclPtr;
5484 static ExceptionSpecSizeHolder
5485 getExceptionSpecSize(ExceptionSpecificationType EST,
unsigned NumExceptions) {
5496 return {NumExceptions, 0, 0};
5509 llvm_unreachable(
"bad exception specification kind");
5514 ExceptionSpecSizeHolder getExceptionSpecSize()
const {
5515 return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
5519 bool hasExtraBitfields()
const {
5520 assert((getExceptionSpecType() != EST_Dynamic ||
5521 FunctionTypeBits.HasExtraBitfields) &&
5522 "ExtraBitfields are required for given ExceptionSpecType");
5523 return FunctionTypeBits.HasExtraBitfields;
5527 bool hasExtraAttributeInfo()
const {
5528 return FunctionTypeBits.HasExtraBitfields &&
5529 getTrailingObjects<FunctionTypeExtraBitfields>()
5530 ->HasExtraAttributeInfo;
5533 bool hasArmTypeAttributes()
const {
5534 return FunctionTypeBits.HasExtraBitfields &&
5535 getTrailingObjects<FunctionTypeExtraBitfields>()
5536 ->HasArmTypeAttributes;
5539 bool hasExtQualifiers()
const {
5540 return FunctionTypeBits.HasExtQuals;
5547 assert(i <
getNumParams() &&
"invalid parameter index");
5592 bool hasDependentExceptionSpec()
const;
5596 bool hasInstantiationDependentExceptionSpec()
const;
5618 ? getTrailingObjects<FunctionTypeExtraBitfields>()
5634 return *getTrailingObjects<Expr *>();
5645 return getTrailingObjects<FunctionDecl *>()[0];
5655 return getTrailingObjects<FunctionDecl *>()[1];
5673 return isVariadic() ? *getTrailingObjects<SourceLocation>()
5683 bool isTemplateVariadic()
const;
5693 if (hasExtQualifiers())
5694 return *getTrailingObjects<Qualifiers>();
5711 return getTrailingObjects<QualType>();
5726 getTrailingObjects<ExceptionType>());
5751 return getTrailingObjects<ExtParameterInfo>();
5756 if (hasExtraAttributeInfo())
5757 return *getTrailingObjects<FunctionTypeExtraAttributeInfo>();
5764 if (!hasArmTypeAttributes())
5766 return getTrailingObjects<FunctionTypeArmAttributes>()
5767 ->AArch64SMEAttributes;
5771 assert(I <
getNumParams() &&
"parameter index out of range");
5773 return getTrailingObjects<ExtParameterInfo>()[I];
5778 assert(I <
getNumParams() &&
"parameter index out of range");
5780 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
5785 assert(I <
getNumParams() &&
"parameter index out of range");
5787 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
5792 return hasExtraBitfields()
5793 ? getTrailingObjects<FunctionTypeExtraBitfields>()
5794 ->NumFunctionEffects
5800 if (hasExtraBitfields()) {
5801 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5802 if (Bitfields->NumFunctionEffects > 0)
5803 return getTrailingObjects<FunctionEffect>(
5804 Bitfields->NumFunctionEffects);
5810 if (hasExtraBitfields()) {
5811 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5812 if (Bitfields->EffectsHaveConditions)
5813 return Bitfields->NumFunctionEffects;
5820 if (hasExtraBitfields()) {
5821 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5822 if (Bitfields->EffectsHaveConditions)
5823 return getTrailingObjects<EffectConditionExpr>(
5824 Bitfields->NumFunctionEffects);
5831 if (hasExtraBitfields()) {
5832 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5833 if (Bitfields->NumFunctionEffects > 0) {
5834 const size_t NumConds = Bitfields->EffectsHaveConditions
5835 ? Bitfields->NumFunctionEffects
5838 getTrailingObjects<FunctionEffect>(Bitfields->NumFunctionEffects),
5839 {NumConds ? getTrailingObjects<EffectConditionExpr>() : nullptr,
5849 void printExceptionSpecification(raw_ostream &OS,
5853 return T->getTypeClass() == FunctionProto;
5856 void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Ctx);
5936 template <
class... As>
5939 this->KeywordWrapperBits.Keyword = llvm::to_underlying(
Keyword);
5964 constexpr unsigned long Offset =
5966 const auto *
Addr =
reinterpret_cast<const T *
>(
5967 reinterpret_cast<const char *
>(
this) - Offset);
5968 assert(llvm::isAddrAligned(llvm::Align(
alignof(
T)),
Addr));
5978class UnresolvedUsingType final
5980 private llvm::TrailingObjects<UnresolvedUsingType,
5981 FoldingSetPlaceholder<UnresolvedUsingType>,
5982 NestedNameSpecifier> {
5984 friend TrailingObjects;
5988 unsigned numTrailingObjects(
5996 assert(numTrailingObjects(
5999 return getTrailingObjects<FoldingSetPlaceholder<UnresolvedUsingType>>();
6002 UnresolvedUsingType(ElaboratedTypeKeyword Keyword,
6003 NestedNameSpecifier Qualifier,
6004 const UnresolvedUsingTypenameDecl *D,
6005 const Type *CanonicalType);
6010 ? *getTrailingObjects<NestedNameSpecifier>()
6025 Qualifier.Profile(ID);
6033 return T->getTypeClass() == UnresolvedUsing;
6038 public llvm::FoldingSetNode,
6039 llvm::TrailingObjects<UsingType, NestedNameSpecifier> {
6044 friend TrailingObjects;
6051 return UsingBits.hasQualifier ? *getTrailingObjects() : std::nullopt;
6064 UnderlyingType.Profile(ID);
6066 Qualifier.Profile(ID);
6075class TypedefType final
6077 private llvm::TrailingObjects<TypedefType,
6078 FoldingSetPlaceholder<TypedefType>,
6079 NestedNameSpecifier, QualType> {
6082 friend TrailingObjects;
6091 unsigned numTrailingObjects(OverloadToken<NestedNameSpecifier>)
const {
6092 return TypedefBits.hasQualifier;
6095 TypedefType(TypeClass TC, ElaboratedTypeKeyword Keyword,
6096 NestedNameSpecifier Qualifier,
const TypedefNameDecl *D,
6097 QualType UnderlyingType,
bool HasTypeDifferentFromDecl);
6099 FoldingSetPlaceholder<TypedefType> *getFoldingSetPlaceholder() {
6100 assert(numTrailingObjects(
6101 OverloadToken<FoldingSetPlaceholder<TypedefType>>{}) == 1);
6102 return getTrailingObjects<FoldingSetPlaceholder<TypedefType>>();
6107 return TypedefBits.hasQualifier ? *getTrailingObjects<NestedNameSpecifier>()
6128 ID.AddInteger(llvm::to_underlying(
Keyword));
6130 Qualifier.Profile(ID);
6131 if (!Underlying.
isNull())
6145class MacroQualifiedType :
public Type {
6154 UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
6156 "Expected a macro qualified type to only wrap attributed types.");
6171 return T->getTypeClass() == MacroQualified;
6199 bool isSugared()
const;
6211 public llvm::FoldingSetNode {
6221 static void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
6222 Expr *E,
bool IsUnqual);
6227class TypeOfType :
public Type {
6233 TypeOfType(
const ASTContext &Context, QualType T, QualType Can,
6237 QualType getUnmodifiedType()
const {
return TOType; }
6240 QualType desugar()
const;
6243 bool isSugared()
const {
return true; }
6247 return static_cast<TypeOfKind>(TypeOfBits.Kind);
6254class DecltypeType :
public Type {
6256 QualType UnderlyingType;
6259 friend class ASTContext;
6261 DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());
6264 Expr *getUnderlyingExpr()
const {
return E; }
6268 QualType desugar()
const;
6271 bool isSugared()
const;
6282class DependentDecltypeType :
public DecltypeType,
public llvm::FoldingSetNode {
6284 DependentDecltypeType(Expr *E);
6286 void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context) {
6287 Profile(ID, Context, getUnderlyingExpr());
6290 static void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
6294class PackIndexingType final
6296 public llvm::FoldingSetNode,
6297 private llvm::TrailingObjects<PackIndexingType, QualType> {
6298 friend TrailingObjects;
6305 LLVM_PREFERRED_TYPE(
bool)
6306 unsigned FullySubstituted : 1;
6309 friend class ASTContext;
6310 PackIndexingType(QualType Canonical, QualType Pattern, Expr *IndexExpr,
6311 bool FullySubstituted, ArrayRef<QualType> Expansions = {});
6314 Expr *getIndexExpr()
const {
return IndexExpr; }
6315 QualType getPattern()
const {
return Pattern; }
6317 bool isSugared()
const {
return hasSelectedType(); }
6319 QualType desugar()
const {
6320 if (hasSelectedType())
6321 return getSelectedType();
6322 return QualType(
this, 0);
6325 QualType getSelectedType()
const {
6326 assert(hasSelectedType() &&
"Type is dependant");
6327 return *(getExpansionsPtr() + *getSelectedIndex());
6330 UnsignedOrNone getSelectedIndex()
const;
6332 bool hasSelectedType()
const {
return getSelectedIndex() != std::nullopt; }
6334 bool isFullySubstituted()
const {
return FullySubstituted; }
6336 bool expandsToEmptyPack()
const {
return isFullySubstituted() &&
Size == 0; }
6338 ArrayRef<QualType> getExpansions()
const {
6339 return {getExpansionsPtr(),
Size};
6342 static bool classof(
const Type *T) {
6346 void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context);
6347 static void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
6348 QualType Pattern, Expr *E,
bool FullySubstituted,
6349 ArrayRef<QualType> Expansions);
6352 const QualType *getExpansionsPtr()
const {
return getTrailingObjects(); }
6355 ArrayRef<QualType> Expansions = {});
6359class UnaryTransformType :
public Type,
public llvm::FoldingSetNode {
6362#define TRANSFORM_TYPE_TRAIT_DEF(Enum, _) Enum,
6363#include "clang/Basic/TransformTypeTraits.def"
6371 QualType UnderlyingType;
6376 friend class ASTContext;
6378 UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
6379 QualType CanonicalTy);
6382 bool isSugared()
const {
return !isDependentType(); }
6383 QualType desugar()
const {
return UnderlyingType; }
6388 UTTKind getUTTKind()
const {
return UKind; }
6390 static bool classof(
const Type *T) {
6394 void Profile(llvm::FoldingSetNodeID &ID) {
6398 static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
6399 QualType UnderlyingType, UTTKind UKind) {
6400 BaseType.Profile(ID);
6401 UnderlyingType.Profile(ID);
6402 ID.AddInteger(UKind);
6406class TagType :
public TypeWithKeyword {
6407 friend class ASTContext;
6413 void *getTrailingPointer()
const;
6414 NestedNameSpecifier &getTrailingQualifier()
const;
6417 TagType(TypeClass TC, ElaboratedTypeKeyword Keyword,
6418 NestedNameSpecifier Qualifier,
const TagDecl *TD,
bool OwnsTag,
6419 bool IsInjected,
const Type *CanonicalType);
6425 TagDecl *getOriginalDecl()
const {
return decl; }
6427 NestedNameSpecifier getQualifier()
const;
6430 bool isTagOwned()
const {
return TagTypeBits.OwnsTag; }
6432 bool isInjected()
const {
return TagTypeBits.IsInjected; }
6434 ClassTemplateDecl *getTemplateDecl()
const;
6435 TemplateName getTemplateName(
const ASTContext &Ctx)
const;
6436 ArrayRef<TemplateArgument> getTemplateArgs(
const ASTContext &Ctx)
const;
6438 bool isSugared()
const {
return false; }
6439 QualType desugar()
const {
return getCanonicalTypeInternal(); }
6441 static bool classof(
const Type *T) {
6447struct TagTypeFoldingSetPlaceholder :
public llvm::FoldingSetNode {
6448 static constexpr size_t getOffset() {
6449 return alignof(TagType) -
6450 (
sizeof(TagTypeFoldingSetPlaceholder) %
alignof(TagType));
6453 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
6454 NestedNameSpecifier Qualifier,
const TagDecl *Tag,
6455 bool OwnsTag,
bool IsInjected) {
6456 ID.AddInteger(
uintptr_t(Tag) | OwnsTag | (IsInjected << 1) |
6457 ((Keyword != ElaboratedTypeKeyword::None) << 2));
6458 if (Keyword != ElaboratedTypeKeyword::None)
6459 ID.AddInteger(llvm::to_underlying(Keyword));
6464 void Profile(llvm::FoldingSetNodeID &ID)
const {
6465 const TagType *
T = getTagType();
6466 Profile(ID,
T->getKeyword(),
T->getQualifier(),
T->getOriginalDecl(),
6467 T->isTagOwned(),
T->isInjected());
6470 TagType *getTagType() {
6471 return reinterpret_cast<TagType *
>(
reinterpret_cast<char *
>(
this + 1) +
6474 const TagType *getTagType()
const {
6475 return const_cast<TagTypeFoldingSetPlaceholder *
>(
this)->getTagType();
6477 static TagTypeFoldingSetPlaceholder *fromTagType(TagType *T) {
6478 return reinterpret_cast<TagTypeFoldingSetPlaceholder *
>(
6479 reinterpret_cast<char *
>(
T) - getOffset()) -
6486class RecordType final :
public TagType {
6487 using TagType::TagType;
6493 RecordDecl *getOriginalDecl()
const {
6494 return reinterpret_cast<RecordDecl *
>(TagType::getOriginalDecl());
6499 bool hasConstFields()
const;
6506class EnumType final :
public TagType {
6507 using TagType::TagType;
6513 EnumDecl *getOriginalDecl()
const {
6514 return reinterpret_cast<EnumDecl *
>(TagType::getOriginalDecl());
6537class InjectedClassNameType final :
public TagType {
6538 friend class ASTContext;
6540 InjectedClassNameType(ElaboratedTypeKeyword Keyword,
6541 NestedNameSpecifier Qualifier,
const TagDecl *TD,
6542 bool IsInjected,
const Type *CanonicalType);
6548 CXXRecordDecl *getOriginalDecl()
const {
6549 return reinterpret_cast<CXXRecordDecl *
>(TagType::getOriginalDecl());
6552 static bool classof(
const Type *T) {
6571 using Kind = attr::Kind;
6574 friend class ASTContext;
6576 const Attr *Attribute;
6578 QualType ModifiedType;
6579 QualType EquivalentType;
6581 AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
6582 QualType equivalent)
6585 AttributedType(QualType canon,
const Attr *attr, QualType modified,
6586 QualType equivalent);
6589 AttributedType(QualType canon, attr::Kind attrKind,
const Attr *attr,
6590 QualType modified, QualType equivalent);
6593 Kind getAttrKind()
const {
6594 return static_cast<Kind>(AttributedTypeBits.AttrKind);
6597 const Attr *getAttr()
const {
return Attribute; }
6599 QualType getModifiedType()
const {
return ModifiedType; }
6600 QualType getEquivalentType()
const {
return EquivalentType; }
6602 bool isSugared()
const {
return true; }
6603 QualType desugar()
const {
return getEquivalentType(); }
6620 bool isQualifier()
const;
6622 bool isMSTypeSpec()
const;
6624 bool isWebAssemblyFuncrefSpec()
const;
6626 bool isCallingConv()
const;
6628 std::optional<NullabilityKind> getImmediateNullability()
const;
6639 static std::optional<NullabilityKind> stripOuterNullability(QualType &T);
6641 void Profile(llvm::FoldingSetNodeID &ID) {
6642 Profile(ID, getAttrKind(), ModifiedType, EquivalentType, Attribute);
6645 static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
6646 QualType modified, QualType equivalent,
6648 ID.AddInteger(attrKind);
6649 ID.AddPointer(modified.getAsOpaquePtr());
6650 ID.AddPointer(equivalent.getAsOpaquePtr());
6651 ID.AddPointer(attr);
6654 static bool classof(
const Type *T) {
6659class BTFTagAttributedType :
public Type,
public llvm::FoldingSetNode {
6661 friend class ASTContext;
6663 QualType WrappedType;
6664 const BTFTypeTagAttr *BTFAttr;
6666 BTFTagAttributedType(QualType Canon, QualType Wrapped,
6667 const BTFTypeTagAttr *BTFAttr)
6668 : Type(BTFTagAttributed, Canon, Wrapped->getDependence()),
6669 WrappedType(Wrapped), BTFAttr(BTFAttr) {}
6672 QualType getWrappedType()
const {
return WrappedType; }
6673 const BTFTypeTagAttr *getAttr()
const {
return BTFAttr; }
6675 bool isSugared()
const {
return true; }
6676 QualType desugar()
const {
return getWrappedType(); }
6678 void Profile(llvm::FoldingSetNodeID &ID) {
6679 Profile(ID, WrappedType, BTFAttr);
6682 static void Profile(llvm::FoldingSetNodeID &ID, QualType Wrapped,
6683 const BTFTypeTagAttr *BTFAttr) {
6684 ID.AddPointer(Wrapped.getAsOpaquePtr());
6685 ID.AddPointer(BTFAttr);
6688 static bool classof(
const Type *T) {
6693class HLSLAttributedResourceType :
public Type,
public llvm::FoldingSetNode {
6699 LLVM_PREFERRED_TYPE(
bool)
6702 LLVM_PREFERRED_TYPE(
bool)
6703 uint8_t RawBuffer : 1;
6705 Attributes(llvm::dxil::ResourceClass
ResourceClass,
bool IsROV =
false,
6706 bool RawBuffer =
false)
6711 friend bool operator==(
const Attributes &LHS,
const Attributes &RHS) {
6712 return std::tie(LHS.ResourceClass, LHS.IsROV, LHS.RawBuffer) ==
6713 std::tie(RHS.ResourceClass, RHS.IsROV, RHS.RawBuffer);
6715 friend bool operator!=(
const Attributes &LHS,
const Attributes &RHS) {
6716 return !(LHS == RHS);
6721 friend class ASTContext;
6723 QualType WrappedType;
6724 QualType ContainedType;
6725 const Attributes Attrs;
6727 HLSLAttributedResourceType(QualType Wrapped, QualType Contained,
6728 const Attributes &Attrs)
6729 : Type(HLSLAttributedResource, QualType(),
6731 : Contained->getDependence()),
6732 WrappedType(Wrapped), ContainedType(Contained), Attrs(Attrs) {}
6735 QualType getWrappedType()
const {
return WrappedType; }
6736 QualType getContainedType()
const {
return ContainedType; }
6737 bool hasContainedType()
const {
return !ContainedType.isNull(); }
6738 const Attributes &getAttrs()
const {
return Attrs; }
6740 bool isSugared()
const {
return false; }
6741 QualType desugar()
const {
return QualType(
this, 0); }
6743 void Profile(llvm::FoldingSetNodeID &ID) {
6744 Profile(ID, WrappedType, ContainedType, Attrs);
6747 static void Profile(llvm::FoldingSetNodeID &ID, QualType Wrapped,
6748 QualType Contained,
const Attributes &Attrs) {
6749 ID.AddPointer(Wrapped.getAsOpaquePtr());
6750 ID.AddPointer(Contained.getAsOpaquePtr());
6751 ID.AddInteger(
static_cast<uint32_t>(Attrs.ResourceClass));
6752 ID.AddBoolean(Attrs.IsROV);
6753 ID.AddBoolean(Attrs.RawBuffer);
6756 static bool classof(
const Type *T) {
6761 static const HLSLAttributedResourceType *
6762 findHandleTypeOnResource(
const Type *RT);
6768 enum SpirvOperandKind :
unsigned char {
6781 QualType ResultType;
6787 SpirvOperand(SpirvOperandKind Kind, QualType ResultType, llvm::APInt
Value)
6790 SpirvOperand(
const SpirvOperand &Other) { *
this =
Other; }
6793 SpirvOperand &operator=(
const SpirvOperand &Other) =
default;
6795 bool operator==(
const SpirvOperand &Other)
const {
6800 bool operator!=(
const SpirvOperand &Other)
const {
return !(*
this ==
Other); }
6805 bool isConstant()
const {
return Kind == ConstantId; }
6807 bool isType()
const {
return Kind == TypeId; }
6809 llvm::APInt getValue()
const {
6811 "This is not an operand with a value!");
6815 QualType getResultType()
const {
6816 assert((isConstant() || isType()) &&
6817 "This is not an operand with a result type!");
6821 static SpirvOperand createConstant(QualType ResultType, llvm::APInt Val) {
6822 return SpirvOperand(ConstantId, ResultType, std::move(Val));
6825 static SpirvOperand createLiteral(llvm::APInt Val) {
6826 return SpirvOperand(Literal, QualType(), std::move(Val));
6829 static SpirvOperand createType(QualType T) {
6830 return SpirvOperand(TypeId, T, llvm::APSInt());
6833 void Profile(llvm::FoldingSetNodeID &ID)
const {
6834 ID.AddInteger(Kind);
6835 ID.AddPointer(ResultType.getAsOpaquePtr());
6841class HLSLInlineSpirvType final
6843 public llvm::FoldingSetNode,
6844 private llvm::TrailingObjects<HLSLInlineSpirvType, SpirvOperand> {
6845 friend class ASTContext;
6846 friend TrailingObjects;
6854 HLSLInlineSpirvType(uint32_t Opcode, uint32_t Size, uint32_t Alignment,
6855 ArrayRef<SpirvOperand> Operands)
6857 Size(
Size), Alignment(Alignment), NumOperands(Operands.size()) {
6858 for (
size_t I = 0; I < NumOperands; I++) {
6861 auto *
Operand =
new (&getTrailingObjects()[I]) SpirvOperand();
6869 uint32_t getAlignment()
const {
return Alignment; }
6870 ArrayRef<SpirvOperand> getOperands()
const {
6871 return getTrailingObjects(NumOperands);
6874 bool isSugared()
const {
return false; }
6875 QualType desugar()
const {
return QualType(
this, 0); }
6877 void Profile(llvm::FoldingSetNodeID &ID) {
6878 Profile(ID, Opcode, Size, Alignment, getOperands());
6881 static void Profile(llvm::FoldingSetNodeID &ID, uint32_t Opcode,
6882 uint32_t Size, uint32_t Alignment,
6883 ArrayRef<SpirvOperand> Operands) {
6884 ID.AddInteger(Opcode);
6885 ID.AddInteger(Size);
6886 ID.AddInteger(Alignment);
6887 for (
auto &Operand : Operands)
6891 static bool classof(
const Type *T) {
6896class TemplateTypeParmType :
public Type,
public llvm::FoldingSetNode {
6897 friend class ASTContext;
6900 TemplateTypeParmDecl *TTPDecl;
6902 TemplateTypeParmType(
unsigned D,
unsigned I,
bool PP,
6903 TemplateTypeParmDecl *TTPDecl, QualType Canon)
6908 assert(!TTPDecl == Canon.isNull());
6909 TemplateTypeParmTypeBits.Depth = D;
6910 TemplateTypeParmTypeBits.Index = I;
6911 TemplateTypeParmTypeBits.ParameterPack = PP;
6915 unsigned getDepth()
const {
return TemplateTypeParmTypeBits.Depth; }
6916 unsigned getIndex()
const {
return TemplateTypeParmTypeBits.Index; }
6918 return TemplateTypeParmTypeBits.ParameterPack;
6921 TemplateTypeParmDecl *getDecl()
const {
return TTPDecl; }
6925 bool isSugared()
const {
return false; }
6926 QualType desugar()
const {
return QualType(
this, 0); }
6928 void Profile(llvm::FoldingSetNodeID &ID) {
6932 static void Profile(llvm::FoldingSetNodeID &ID,
unsigned Depth,
6933 unsigned Index,
bool ParameterPack,
6934 TemplateTypeParmDecl *TTPDecl) {
6935 ID.AddInteger(Depth);
6936 ID.AddInteger(Index);
6937 ID.AddBoolean(ParameterPack);
6938 ID.AddPointer(TTPDecl);
6941 static bool classof(
const Type *T) {
6953class SubstTemplateTypeParmType final
6955 public llvm::FoldingSetNode,
6956 private llvm::TrailingObjects<SubstTemplateTypeParmType, QualType> {
6957 friend class ASTContext;
6958 friend class llvm::TrailingObjects<SubstTemplateTypeParmType, QualType>;
6960 Decl *AssociatedDecl;
6962 SubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,
6963 unsigned Index, UnsignedOrNone PackIndex,
6969 QualType getReplacementType()
const {
6970 return SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType
6971 ? *getTrailingObjects()
6972 : getCanonicalTypeInternal();
6978 Decl *getAssociatedDecl()
const {
return AssociatedDecl; }
6985 unsigned getIndex()
const {
return SubstTemplateTypeParmTypeBits.Index; }
6989 unsigned getFinal()
const {
return SubstTemplateTypeParmTypeBits.Final; }
6991 UnsignedOrNone getPackIndex()
const {
6992 return UnsignedOrNone::fromInternalRepresentation(
6993 SubstTemplateTypeParmTypeBits.PackIndex);
6996 bool isSugared()
const {
return true; }
6997 QualType desugar()
const {
return getReplacementType(); }
6999 void Profile(llvm::FoldingSetNodeID &ID) {
7000 Profile(ID, getReplacementType(), getAssociatedDecl(),
getIndex(),
7001 getPackIndex(), getFinal());
7004 static void Profile(llvm::FoldingSetNodeID &ID, QualType Replacement,
7005 const Decl *AssociatedDecl,
unsigned Index,
7006 UnsignedOrNone PackIndex,
bool Final);
7008 static bool classof(
const Type *T) {
7019class SubstPackType :
public Type,
public llvm::FoldingSetNode {
7020 friend class ASTContext;
7027 SubstPackType(TypeClass Derived, QualType Canon,
7028 const TemplateArgument &ArgPack);
7031 unsigned getNumArgs()
const {
return SubstPackTypeBits.NumArgs; }
7033 TemplateArgument getArgumentPack()
const;
7035 void Profile(llvm::FoldingSetNodeID &ID);
7036 static void Profile(llvm::FoldingSetNodeID &ID,
7037 const TemplateArgument &ArgPack);
7039 static bool classof(
const Type *T) {
7046class SubstBuiltinTemplatePackType :
public SubstPackType {
7047 friend class ASTContext;
7049 SubstBuiltinTemplatePackType(QualType Canon,
const TemplateArgument &ArgPack);
7052 bool isSugared()
const {
return false; }
7053 QualType desugar()
const {
return QualType(
this, 0); }
7056 using SubstPackType::Profile;
7058 static bool classof(
const Type *T) {
7075class SubstTemplateTypeParmPackType :
public SubstPackType {
7076 friend class ASTContext;
7082 llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
7084 SubstTemplateTypeParmPackType(QualType Canon, Decl *AssociatedDecl,
7085 unsigned Index,
bool Final,
7086 const TemplateArgument &ArgPack);
7094 Decl *getAssociatedDecl()
const;
7102 return SubstPackTypeBits.SubstTemplTypeParmPackIndex;
7107 bool getFinal()
const;
7109 bool isSugared()
const {
return false; }
7110 QualType desugar()
const {
return QualType(
this, 0); }
7112 void Profile(llvm::FoldingSetNodeID &ID);
7113 static void Profile(llvm::FoldingSetNodeID &ID,
const Decl *AssociatedDecl,
7114 unsigned Index,
bool Final,
7115 const TemplateArgument &ArgPack);
7117 static bool classof(
const Type *T) {
7130class DeducedType :
public Type {
7131 QualType DeducedAsType;
7134 DeducedType(TypeClass TC, QualType DeducedAsType,
7135 TypeDependence ExtraDependence, QualType Canon)
7137 ExtraDependence | (DeducedAsType.isNull()
7139 : DeducedAsType->getDependence() &
7141 DeducedAsType(DeducedAsType) {}
7144 bool isSugared()
const {
return !DeducedAsType.isNull(); }
7145 QualType desugar()
const {
7146 return isSugared() ? DeducedAsType : QualType(
this, 0);
7151 QualType getDeducedType()
const {
return DeducedAsType; }
7152 bool isDeduced()
const {
7153 return !DeducedAsType.isNull() || isDependentType();
7156 static bool classof(
const Type *T) {
7164class AutoType :
public DeducedType {
7165 friend class ASTContext;
7167 TemplateDecl *TypeConstraintConcept;
7169 AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
7170 TypeDependence ExtraDependence, QualType Canon, TemplateDecl *CD,
7171 ArrayRef<TemplateArgument> TypeConstraintArgs);
7174 ArrayRef<TemplateArgument> getTypeConstraintArguments()
const {
7175 return {
reinterpret_cast<const TemplateArgument *
>(
this + 1),
7176 AutoTypeBits.NumArgs};
7179 TemplateDecl *getTypeConstraintConcept()
const {
7180 return TypeConstraintConcept;
7183 bool isConstrained()
const {
7184 return TypeConstraintConcept !=
nullptr;
7187 bool isDecltypeAuto()
const {
7188 return getKeyword() == AutoTypeKeyword::DecltypeAuto;
7191 bool isGNUAutoType()
const {
7192 return getKeyword() == AutoTypeKeyword::GNUAutoType;
7196 return (AutoTypeKeyword)AutoTypeBits.Keyword;
7199 void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context);
7200 static void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
7201 QualType Deduced, AutoTypeKeyword Keyword,
7202 bool IsDependent, TemplateDecl *CD,
7203 ArrayRef<TemplateArgument> Arguments);
7205 static bool classof(
const Type *T) {
7211class DeducedTemplateSpecializationType :
public KeywordWrapper<DeducedType>,
7212 public llvm::FoldingSetNode {
7213 friend class ASTContext;
7218 DeducedTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
7219 TemplateName Template,
7220 QualType DeducedAsType,
7221 bool IsDeducedAsDependent, QualType Canon)
7222 : KeywordWrapper(
Keyword, DeducedTemplateSpecialization, DeducedAsType,
7224 (IsDeducedAsDependent
7234 void Profile(llvm::FoldingSetNodeID &ID)
const {
7235 Profile(ID, getKeyword(), getTemplateName(), getDeducedType(),
7239 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
7240 TemplateName Template, QualType Deduced,
7242 ID.AddInteger(llvm::to_underlying(Keyword));
7244 Deduced.Profile(ID);
7245 ID.AddBoolean(IsDependent ||
Template.isDependent());
7248 static bool classof(
const Type *T) {
7273class TemplateSpecializationType :
public TypeWithKeyword,
7274 public llvm::FoldingSetNode {
7275 friend class ASTContext;
7286 TemplateSpecializationType(ElaboratedTypeKeyword Keyword, TemplateName T,
7287 bool IsAlias, ArrayRef<TemplateArgument> Args,
7288 QualType Underlying);
7303 anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
7304 ArrayRef<TemplateArgument> Converted);
7306 anyDependentTemplateArguments(
const TemplateArgumentListInfo &,
7307 ArrayRef<TemplateArgument> Converted);
7308 static bool anyInstantiationDependentTemplateArguments(
7309 ArrayRef<TemplateArgumentLoc> Args);
7313 bool isCurrentInstantiation()
const {
7314 return isa<InjectedClassNameType>(getCanonicalTypeInternal());
7332 bool isTypeAlias()
const {
return TemplateSpecializationTypeBits.TypeAlias; }
7336 QualType getAliasedType()
const;
7341 ArrayRef<TemplateArgument> template_arguments()
const {
7342 return {
reinterpret_cast<const TemplateArgument *
>(
this + 1),
7343 TemplateSpecializationTypeBits.NumArgs};
7346 bool isSugared()
const;
7348 QualType desugar()
const {
7349 return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
7352 void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Ctx);
7353 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
7354 TemplateName T, ArrayRef<TemplateArgument> Args,
7355 QualType Underlying,
const ASTContext &Context);
7357 static bool classof(
const Type *T) {
7364void printTemplateArgumentList(raw_ostream &OS,
7365 ArrayRef<TemplateArgument> Args,
7366 const PrintingPolicy &Policy,
7367 const TemplateParameterList *TPL =
nullptr);
7369void printTemplateArgumentList(raw_ostream &OS,
7370 ArrayRef<TemplateArgumentLoc> Args,
7371 const PrintingPolicy &Policy,
7372 const TemplateParameterList *TPL =
nullptr);
7374void printTemplateArgumentList(raw_ostream &OS,
7375 const TemplateArgumentListInfo &Args,
7376 const PrintingPolicy &Policy,
7377 const TemplateParameterList *TPL =
nullptr);
7381bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg,
7382 const NamedDecl *Param,
7383 ArrayRef<TemplateArgument> Args,
7398class DependentNameType :
public TypeWithKeyword,
public llvm::FoldingSetNode {
7399 friend class ASTContext;
7402 NestedNameSpecifier NNS;
7405 const IdentifierInfo *Name;
7407 DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier NNS,
7408 const IdentifierInfo *Name, QualType CanonType)
7409 : TypeWithKeyword(
Keyword, DependentName, CanonType,
7413 NNS(NNS), Name(Name) {
7419 NestedNameSpecifier getQualifier()
const {
return NNS; }
7427 bool isSugared()
const {
return false; }
7428 QualType desugar()
const {
return QualType(
this, 0); }
7430 void Profile(llvm::FoldingSetNodeID &ID) {
7431 Profile(ID, getKeyword(), NNS, Name);
7434 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
7435 NestedNameSpecifier NNS,
const IdentifierInfo *Name) {
7436 ID.AddInteger(llvm::to_underlying(Keyword));
7438 ID.AddPointer(Name);
7441 static bool classof(
const Type *T) {
7468class PackExpansionType :
public Type,
public llvm::FoldingSetNode {
7469 friend class ASTContext;
7474 PackExpansionType(QualType Pattern, QualType Canon,
7475 UnsignedOrNone NumExpansions)
7476 : Type(PackExpansion, Canon,
7481 PackExpansionTypeBits.NumExpansions =
7482 NumExpansions ? *NumExpansions + 1 : 0;
7489 QualType getPattern()
const {
return Pattern; }
7493 UnsignedOrNone getNumExpansions()
const {
7494 if (PackExpansionTypeBits.NumExpansions)
7495 return PackExpansionTypeBits.NumExpansions - 1;
7496 return std::nullopt;
7499 bool isSugared()
const {
return false; }
7500 QualType desugar()
const {
return QualType(
this, 0); }
7502 void Profile(llvm::FoldingSetNodeID &ID) {
7503 Profile(ID, getPattern(), getNumExpansions());
7506 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
7507 UnsignedOrNone NumExpansions) {
7508 ID.AddPointer(Pattern.getAsOpaquePtr());
7509 ID.AddInteger(NumExpansions.toInternalRepresentation());
7512 static bool classof(
const Type *T) {
7520class ObjCProtocolQualifiers {
7522 ObjCProtocolQualifiers() =
default;
7524 ObjCProtocolDecl *
const *getProtocolStorage()
const {
7525 return const_cast<ObjCProtocolQualifiers*
>(
this)->getProtocolStorage();
7528 ObjCProtocolDecl **getProtocolStorage() {
7529 return static_cast<T*
>(
this)->getProtocolStorageImpl();
7532 void setNumProtocols(
unsigned N) {
7533 static_cast<T*
>(
this)->setNumProtocolsImpl(N);
7536 void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
7537 setNumProtocols(protocols.size());
7538 assert(getNumProtocols() == protocols.size() &&
7539 "bitfield overflow in protocol count");
7540 if (!protocols.empty())
7541 memcpy(getProtocolStorage(), protocols.data(),
7542 protocols.size() *
sizeof(ObjCProtocolDecl*));
7546 using qual_iterator = ObjCProtocolDecl *
const *;
7547 using qual_range = llvm::iterator_range<qual_iterator>;
7549 qual_range quals()
const {
return qual_range(qual_begin(), qual_end()); }
7550 qual_iterator qual_begin()
const {
return getProtocolStorage(); }
7551 qual_iterator qual_end()
const {
return qual_begin() + getNumProtocols(); }
7553 bool qual_empty()
const {
return getNumProtocols() == 0; }
7557 unsigned getNumProtocols()
const {
7558 return static_cast<const T*
>(
this)->getNumProtocolsImpl();
7562 ObjCProtocolDecl *getProtocol(
unsigned I)
const {
7563 assert(I < getNumProtocols() &&
"Out-of-range protocol access");
7564 return qual_begin()[I];
7568 ArrayRef<ObjCProtocolDecl *> getProtocols()
const {
7569 return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
7575class ObjCTypeParamType :
public Type,
7576 public ObjCProtocolQualifiers<ObjCTypeParamType>,
7577 public llvm::FoldingSetNode {
7578 friend class ASTContext;
7579 friend class ObjCProtocolQualifiers<ObjCTypeParamType>;
7582 unsigned NumProtocols : 6;
7584 ObjCTypeParamDecl *OTPDecl;
7589 ObjCProtocolDecl **getProtocolStorageImpl();
7593 unsigned getNumProtocolsImpl()
const {
7594 return NumProtocols;
7597 void setNumProtocolsImpl(
unsigned N) {
7601 ObjCTypeParamType(
const ObjCTypeParamDecl *D,
7603 ArrayRef<ObjCProtocolDecl *> protocols);
7606 bool isSugared()
const {
return true; }
7607 QualType desugar()
const {
return getCanonicalTypeInternal(); }
7609 static bool classof(
const Type *T) {
7613 void Profile(llvm::FoldingSetNodeID &ID);
7614 static void Profile(llvm::FoldingSetNodeID &ID,
7615 const ObjCTypeParamDecl *OTPDecl,
7616 QualType CanonicalType,
7617 ArrayRef<ObjCProtocolDecl *> protocols);
7619 ObjCTypeParamDecl *getDecl()
const {
return OTPDecl; }
7650class ObjCObjectType :
public Type,
7651 public ObjCProtocolQualifiers<ObjCObjectType> {
7652 friend class ObjCProtocolQualifiers<ObjCObjectType>;
7670 mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
7671 CachedSuperClassType;
7673 QualType *getTypeArgStorage();
7674 const QualType *getTypeArgStorage()
const {
7675 return const_cast<ObjCObjectType *
>(
this)->getTypeArgStorage();
7678 ObjCProtocolDecl **getProtocolStorageImpl();
7681 unsigned getNumProtocolsImpl()
const {
7682 return ObjCObjectTypeBits.NumProtocols;
7684 void setNumProtocolsImpl(
unsigned N) {
7685 ObjCObjectTypeBits.NumProtocols = N;
7689 enum Nonce_ObjCInterface { Nonce_ObjCInterface };
7691 ObjCObjectType(QualType Canonical, QualType Base,
7692 ArrayRef<QualType> typeArgs,
7693 ArrayRef<ObjCProtocolDecl *> protocols,
7696 ObjCObjectType(
enum Nonce_ObjCInterface)
7698 BaseType(QualType(this_(), 0)) {
7699 ObjCObjectTypeBits.NumProtocols = 0;
7700 ObjCObjectTypeBits.NumTypeArgs = 0;
7701 ObjCObjectTypeBits.IsKindOf = 0;
7704 void computeSuperClassTypeSlow()
const;
7715 bool isObjCId()
const {
7716 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
7719 bool isObjCClass()
const {
7720 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
7723 bool isObjCUnqualifiedId()
const {
return qual_empty() && isObjCId(); }
7724 bool isObjCUnqualifiedClass()
const {
return qual_empty() && isObjCClass(); }
7725 bool isObjCUnqualifiedIdOrClass()
const {
7726 if (!qual_empty())
return false;
7727 if (
const BuiltinType *T =
getBaseType()->getAs<BuiltinType>())
7728 return T->getKind() == BuiltinType::ObjCId ||
7729 T->getKind() == BuiltinType::ObjCClass;
7732 bool isObjCQualifiedId()
const {
return !qual_empty() && isObjCId(); }
7733 bool isObjCQualifiedClass()
const {
return !qual_empty() && isObjCClass(); }
7737 ObjCInterfaceDecl *getInterface()
const;
7741 bool isSpecialized()
const;
7744 bool isSpecializedAsWritten()
const {
7745 return ObjCObjectTypeBits.NumTypeArgs > 0;
7750 bool isUnspecialized()
const {
return !isSpecialized(); }
7754 bool isUnspecializedAsWritten()
const {
return !isSpecializedAsWritten(); }
7757 ArrayRef<QualType> getTypeArgs()
const;
7761 ArrayRef<QualType> getTypeArgsAsWritten()
const {
7762 return {getTypeArgStorage(), ObjCObjectTypeBits.NumTypeArgs};
7766 bool isKindOfTypeAsWritten()
const {
return ObjCObjectTypeBits.IsKindOf; }
7769 bool isKindOfType()
const;
7777 QualType getSuperClassType()
const {
7778 if (!CachedSuperClassType.getInt())
7779 computeSuperClassTypeSlow();
7781 assert(CachedSuperClassType.getInt() &&
"Superclass not set?");
7782 return QualType(CachedSuperClassType.getPointer(), 0);
7787 QualType stripObjCKindOfTypeAndQuals(
const ASTContext &ctx)
const;
7789 bool isSugared()
const {
return false; }
7790 QualType desugar()
const {
return QualType(
this, 0); }
7792 static bool classof(
const Type *T) {
7802class ObjCObjectTypeImpl :
public ObjCObjectType,
public llvm::FoldingSetNode {
7803 friend class ASTContext;
7808 ObjCObjectTypeImpl(QualType Canonical, QualType Base,
7809 ArrayRef<QualType> typeArgs,
7810 ArrayRef<ObjCProtocolDecl *> protocols,
7812 : ObjCObjectType(Canonical,
Base, typeArgs, protocols, isKindOf) {}
7815 void Profile(llvm::FoldingSetNodeID &ID);
7816 static void Profile(llvm::FoldingSetNodeID &ID,
7818 ArrayRef<QualType> typeArgs,
7819 ArrayRef<ObjCProtocolDecl *> protocols,
7823inline QualType *ObjCObjectType::getTypeArgStorage() {
7824 return reinterpret_cast<QualType *
>(
static_cast<ObjCObjectTypeImpl*
>(
this)+1);
7827inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
7828 return reinterpret_cast<ObjCProtocolDecl**
>(
7829 getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
7832inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
7833 return reinterpret_cast<ObjCProtocolDecl**
>(
7834 static_cast<ObjCTypeParamType*
>(
this)+1);
7868 return T->getTypeClass() == ObjCInterface;
7884inline ObjCInterfaceDecl *ObjCObjectType::getInterface()
const {
7885 QualType baseType = getBaseType();
7887 if (
const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
7888 return T->getDecl();
7890 baseType = ObjT->getBaseType();
7905class ObjCObjectPointerType :
public Type,
public llvm::FoldingSetNode {
7912 PointeeType(Pointee) {}
8055 QualType getSuperClassType()
const;
8067 ID.AddPointer(
T.getAsOpaquePtr());
8071 return T->getTypeClass() == ObjCObjectPointer;
8075class AtomicType :
public Type,
public llvm::FoldingSetNode {
8096 ID.AddPointer(
T.getAsOpaquePtr());
8100 return T->getTypeClass() ==
Atomic;
8105class PipeType :
public Type,
public llvm::FoldingSetNode {
8113 ElementType(elemType), isRead(isRead) {}
8127 ID.AddPointer(
T.getAsOpaquePtr());
8128 ID.AddBoolean(isRead);
8132 return T->getTypeClass() ==
Pipe;
8141 LLVM_PREFERRED_TYPE(
bool)
8142 unsigned IsUnsigned : 1;
8143 unsigned NumBits : 24;
8160 static void Profile(llvm::FoldingSetNodeID &ID,
bool IsUnsigned,
8162 ID.AddBoolean(IsUnsigned);
8163 ID.AddInteger(NumBits);
8171 llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;
8179 Expr *getNumBitsExpr()
const;
8187 static void Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
8188 bool IsUnsigned,
Expr *NumBitsExpr);
8191 return T->getTypeClass() == DependentBitInt;
8195class PredefinedSugarType final :
public Type {
8208 static StringRef getName(Kind KD);
8222 return T->getTypeClass() == PredefinedSugar;
8236 if (!
type.hasLocalNonFastQualifiers())
8237 return type.getTypePtrUnsafe();
8258class alignas(8) TypeSourceInfo {
8265 TypeSourceInfo(
QualType ty,
size_t DataSize);
8282 Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
8288 return getCommonPtr()->BaseType;
8292 return (
isNull() ?
nullptr : getCommonPtr()->BaseType);
8300 if (
Self.isObjectType() ||
Self.isReferenceType())
8303 return F->getMethodQuals().empty() && F->getRefQualifier() ==
RQ_None;
8313 const ExtQuals *eq = getExtQualsUnsafe();
8322 Quals = getExtQualsUnsafe()->getQualifiers();
8328 Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
8334 unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
8340 QualType canon = getCommonPtr()->CanonicalType;
8345 return getTypePtr()->isCanonicalUnqualified();
8353 if (
T->isVariablyModifiedType() &&
T->hasSizedVLAType())
8362 getCommonPtr()->CanonicalType.isLocalConstQualified();
8367 getCommonPtr()->CanonicalType.isLocalRestrictQualified();
8373 getCommonPtr()->CanonicalType.isLocalVolatileQualified();
8378 getCommonPtr()->CanonicalType.hasLocalQualifiers();
8385 return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
8392 return getSplitUnqualifiedTypeImpl(*
this);
8424 if (
const auto *FT = PT->getPointeeType()->getAs<
FunctionType>())
8425 return FT->getExtInfo();
8427 return FT->getExtInfo();
8474 return RefType->getPointeeType();
8565 return !
T->getPointeeType()->isFunctionType();
8572 return Fn->hasCFIUncheckedCallee();
8593 return T->getPointeeType()->isFunctionType();
8600 return T->getPointeeType()->isFunctionType();
8611 return T->isMemberFunctionPointer();
8618 return T->isMemberDataPointer();
8716 return OPT->isObjCQualifiedIdType();
8722 return OPT->isObjCQualifiedClassType();
8728 return OPT->isObjCIdType();
8734 return OPT->isObjCClassType();
8740 return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
8752#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8753 inline bool Type::is##Id##Type() const { \
8754 return isSpecificBuiltinType(BuiltinType::Id); \
8756#include "clang/Basic/OpenCLImageTypes.def"
8779#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
8781#include "clang/Basic/OpenCLImageTypes.def"
8793#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
8794 inline bool Type::is##Id##Type() const { \
8795 return isSpecificBuiltinType(BuiltinType::Id); \
8797#include "clang/Basic/OpenCLExtensionTypes.def"
8800#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
8801 isOCLIntelSubgroupAVC##Id##Type() ||
8803#include "clang/Basic/OpenCLExtensionTypes.def"
8808#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
8810#include "clang/Basic/OpenCLExtensionTypes.def"
8819#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
8820 inline bool Type::is##Id##Type() const { \
8821 return isSpecificBuiltinType(BuiltinType::Id); \
8823#include "clang/Basic/HLSLIntangibleTypes.def"
8826#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) is##Id##Type() ||
8828#include "clang/Basic/HLSLIntangibleTypes.def"
8857 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
8858 return BT->isPlaceholderType();
8863 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
8864 if (BT->isPlaceholderType())
8875 if (
const auto *BT = dyn_cast<BuiltinType>(
this))
8876 return BT->isNonOverloadPlaceholderType();
8925 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8926 return BT->isInteger();
8927 if (
const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
8937 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8938 return BT->getKind() >= BuiltinType::ShortAccum &&
8939 BT->getKind() <= BuiltinType::SatULongFract;
8953 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8954 return BT->getKind() >= BuiltinType::SatShortAccum &&
8955 BT->getKind() <= BuiltinType::SatULongFract;
8965 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8966 return ((BT->getKind() >= BuiltinType::ShortAccum &&
8967 BT->getKind() <= BuiltinType::LongAccum) ||
8968 (BT->getKind() >= BuiltinType::ShortFract &&
8969 BT->getKind() <= BuiltinType::LongFract) ||
8970 (BT->getKind() >= BuiltinType::SatShortAccum &&
8971 BT->getKind() <= BuiltinType::SatLongAccum) ||
8972 (BT->getKind() >= BuiltinType::SatShortFract &&
8973 BT->getKind() <= BuiltinType::SatLongFract));
8983 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8984 return BT->getKind() > BuiltinType::Void &&
8985 BT->getKind() <= BuiltinType::NullPtr;
8986 if (
const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
8999 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
9000 return BT->isInteger();
9004 if (
const auto *ET = dyn_cast<EnumType>(CanonicalType))
9011 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
9012 return BT->getKind() == BuiltinType::Bool;
9018 return DT && !DT->isDeduced();
9035 return TST->isTypeAlias();
9062 if (
type->isAnyPointerType())
9063 return type->getPointeeType().getTypePtr();
9064 else if (
type->isArrayType())
9065 return type->getBaseElementTypeUnsafe();
9090 PD.
AddTaggedVal(
reinterpret_cast<uint64_t
>(
T.getAsOpaquePtr()),
9102 "ArrayType cannot be used with getAs!");
9105 if (
const auto *Ty = dyn_cast<T>(
this))
9109 if (!
isa<T>(CanonicalType))
9121 if (
const auto *Ty = dyn_cast<T>(
this))
9125 if (!
isa<T>(CanonicalType))
9130 const Type *Ty =
this;
9132 if (
const auto *A = dyn_cast<AttributedType>(Ty))
9133 Ty = A->getModifiedType().getTypePtr();
9134 else if (
const auto *A = dyn_cast<BTFTagAttributedType>(Ty))
9135 Ty = A->getWrappedType().getTypePtr();
9136 else if (
const auto *A = dyn_cast<HLSLAttributedResourceType>(Ty))
9137 Ty = A->getWrappedType().getTypePtr();
9138 else if (
const auto *P = dyn_cast<ParenType>(Ty))
9139 Ty = P->desugar().getTypePtr();
9140 else if (
const auto *A = dyn_cast<AdjustedType>(Ty))
9141 Ty = A->desugar().getTypePtr();
9142 else if (
const auto *M = dyn_cast<MacroQualifiedType>(Ty))
9143 Ty = M->desugar().getTypePtr();
9150 return dyn_cast<T>(Ty);
9155 if (
const auto *arr = dyn_cast<ArrayType>(
this))
9169 "ArrayType cannot be used with castAs!");
9171 if (
const auto *ty = dyn_cast<T>(
this))
return ty;
9172 assert(
isa<T>(CanonicalType));
9178 if (
const auto *arr = dyn_cast<ArrayType>(
this))
return arr;
9184 :
AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
9186 QualType Adjusted = getAdjustedType();
9187 (void)AttributedType::stripOuterNullability(Adjusted);
9194 (void)AttributedType::stripOuterNullability(Decayed);
9209 TypePtr = Pointee.getTypePtr();
9215 if (
const auto *FPT = TypePtr->
getAs<FunctionProtoType>())
9216 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)
llvm::dxil::ResourceClass ResourceClass
static std::optional< NonLoc > getIndex(ProgramStateRef State, const ElementRegion *ER, CharKind CK)
clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)
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 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 bool hasAttr(const Decl *D, bool IgnoreImplicitAttr)
static RecordDecl * getAsRecordDecl(QualType BaseType, HeuristicResolver &Resolver)
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 OMPAtomicDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expressions Exprs)
Creates directive with a list of Clauses and 'x', 'v' and 'expr' parts of the atomic construct (see S...
static bool classof(const Stmt *T)
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 ...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
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
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
ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm, unsigned tq, const Expr *sz=nullptr)
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.
static bool classof(const Type *T)
BitIntType(bool isUnsigned, unsigned NumBits)
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
BoundsAttributedType(TypeClass TC, QualType Wrapped, QualType Canon)
const TypeCoupledDeclRefInfo * decl_iterator
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.
StringRef getName(const PrintingPolicy &Policy) const
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.
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 unsigned MaxElementsPerDimension
ConstantMatrixType(QualType MatrixElementType, unsigned NRows, unsigned NColumns, QualType CanonElementType)
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
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.
Expr * getAddrSpaceExpr() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
QualType getPointeeType() const
static bool classof(const Type *T)
SourceLocation getAttributeLoc() const
Expr * getNumBitsExpr() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
DependentBitIntType(bool IsUnsigned, Expr *NumBits)
static bool classof(const Type *T)
friend class StmtIteratorBase
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
static bool classof(const Type *T)
Expr * getSizeExpr() const
Expr * getSizeExpr() const
static bool classof(const Type *T)
SourceLocation getAttributeLoc() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
QualType getElementType() const
Expr * getColumnExpr() const
Expr * getRowExpr() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
SourceLocation getAttributeLoc() const
static bool classof(const Type *T)
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
DependentTypeOfExprType(const ASTContext &Context, Expr *E, TypeOfKind Kind)
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)
@ ak_addrspace
address space
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
This represents one expression.
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
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)
FunctionEffectSet(const FunctionEffectsRef &FX)
FunctionEffectSet()=default
FunctionEffectIterator< FunctionEffectSet > iterator
bool insert(const FunctionEffectWithCondition &NewEC, Conflicts &Errs)
SmallVector< Conflict > Conflicts
static FunctionEffectSet getIntersection(FunctionEffectsRef LHS, FunctionEffectsRef RHS)
static FunctionEffectSet getUnion(FunctionEffectsRef LHS, FunctionEffectsRef RHS, Conflicts &Errs)
Represents an abstract function effect, using just an enumeration describing its kind.
Kind kind() const
The kind of the effect.
unsigned Flags
Flags describing some behaviors of the effect.
static constexpr size_t KindCount
friend bool operator<(FunctionEffect LHS, FunctionEffect RHS)
friend bool operator==(FunctionEffect LHS, FunctionEffect RHS)
uint32_t toOpaqueInt32() const
For serialization.
@ FE_ExcludeStaticLocalVars
@ FE_ExcludeThreadLocalVars
@ FE_ExcludeObjCMessageSend
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
static FunctionEffectsRef create(ArrayRef< FunctionEffect > FX, ArrayRef< EffectConditionExpr > Conds)
Asserts invariants.
FunctionEffectIterator< FunctionEffectsRef > iterator
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)
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.
const QualType * param_type_iterator
Qualifiers getMethodQuals() const
const QualType * exception_iterator
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
bool hasCFIUncheckedCallee() 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.
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
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...
FunctionTypeExtraAttributeInfo getExtraAttributeInfo() const
Return the extra attribute information.
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
friend class FunctionType
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?
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
AArch64SMETypeAttributes
The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number of function type attributes that...
@ SME_PStateSMEnabledMask
@ SME_PStateSMCompatibleMask
@ SME_AgnosticZAStateShift
@ SME_AgnosticZAStateMask
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.
One of these records is kept for each identifier that is lexed.
void Profile(llvm::FoldingSetNodeID &ID)
static void Profile(llvm::FoldingSetNodeID &ID, QualType ET, ArraySizeModifier SizeMod, unsigned TypeQuals)
friend class StmtIteratorBase
static bool classof(const Type *T)
KeywordWrapper(ElaboratedTypeKeyword Keyword, As &&...as)
ElaboratedTypeKeyword getKeyword() const
static CannotCastToThisType classof(const T *)
static bool classof(const Type *T)
static bool classof(const Type *T)
QualType getUnderlyingType() const
const IdentifierInfo * getMacroIdentifier() const
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)
NestedNameSpecifier getQualifier() const
void Profile(llvm::FoldingSetNodeID &ID)
QualType getPointeeType() const
bool isMemberFunctionPointer() const
Returns true if the member type (i.e.
bool isMemberDataPointer() const
Returns true if the member type (i.e.
static bool classof(const Type *T)
This represents a decl that may have a name.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Represents an ObjC class declaration.
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
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.
Represents an Objective-C protocol declaration.
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
@ MaxDiscriminator
The maximum supported pointer-authentication discriminator.
@ MaxKey
The maximum supported pointer-authentication key.
void Profile(llvm::FoldingSetNodeID &ID) const
bool isAddressDiscriminated() const
PointerAuthQualifier withoutKeyNone() const
unsigned getExtraDiscriminator() const
void print(raw_ostream &OS, const PrintingPolicy &Policy) const
PointerAuthenticationMode getAuthenticationMode() const
bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const
std::string getAsString() const
uint32_t getAsOpaqueValue() const
PointerAuthQualifier()=default
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
static bool classof(const Type *T)
void Profile(llvm::FoldingSetNodeID &ID)
static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee)
static bool classof(const Type *T)
const IdentifierInfo * getIdentifier() const
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 hasAddressDiscriminatedPointerAuth() const
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 ...
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...
friend class QualifierCollector
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_PtrAuth
The type is an address-discriminated signed pointer type.
@ 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...
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)
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)
@ FastWidth
The width of the "fast" qualifier mask.
@ MaxAddressSpace
The maximum supported address space number.
@ FastMask
The fast qualifier mask.
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)
static bool classof(const Type *T)
Represents a struct/union/class.
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.
Stmt - This represents one statement.
The streaming interface shared between DiagnosticBuilder and PartialDiagnostic.
void AddTaggedVal(uint64_t V, DiagnosticsEngine::ArgumentKind Kind) const
Represents the declaration of a struct/union/class/enum.
Stores a list of template parameters for a TemplateDecl and its derived classes.
[BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by a...
TypeCoupledDeclRefInfo(ValueDecl *D=nullptr, bool Deref=false)
D is to a declaration referenced by the argument of attribute.
llvm::PointerIntPair< ValueDecl *, 1, unsigned > BaseTy
Base wrapper for a particular "section" of type source info.
static bool classof(const Type *T)
TypeOfKind getKind() const
Returns the kind of 'typeof' type this is.
TypeOfExprType(const ASTContext &Context, Expr *E, TypeOfKind Kind, QualType Can=QualType())
Expr * getUnderlyingExpr() const
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!
TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc, QualType Canonical, TypeDependence Dependence)
friend class AttributedType
friend class ConstantArrayType
friend class CountAttributedType
FunctionTypeBitfields store various bits belonging to FunctionProtoType.
friend class FunctionProtoType
friend class FunctionType
friend class KeywordWrapper
friend class ObjCObjectType
friend class PackExpansionType
friend class PredefinedSugarType
friend class ReferenceType
friend class SubstTemplateTypeParmPackType
friend class SubstPackType
friend class SubstTemplateTypeParmType
friend class TemplateSpecializationType
friend class TemplateTypeParmType
friend class TypeOfExprType
friend class UnresolvedUsingType
friend class DependentVectorType
The base class of the type hierarchy.
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
bool isDecltypeType() const
bool isDependentSizedArrayType() const
bool isFixedPointOrIntegerType() const
Return true if this is a fixed point or integer type.
bool isBlockPointerType() const
TypedefBitfields TypedefBits
bool hasPointeeToToCFIUncheckedCalleeFunctionType() const
bool isBooleanType() const
bool isFunctionReferenceType() const
bool isSignableType(const ASTContext &Ctx) const
Type(const Type &)=delete
bool isObjCBuiltinType() const
const TemplateSpecializationType * getAsNonAliasTemplateSpecializationType() const
Look through sugar for an instance of TemplateSpecializationType which is not a type alias,...
bool isMFloat8Type() const
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
bool isIncompleteArrayType() const
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
bool isFloat16Type() const
ReferenceTypeBitfields ReferenceTypeBits
bool isSignablePointerType() const
ArrayTypeBitfields ArrayTypeBits
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
bool isDependentAddressSpaceType() const
bool isUndeducedAutoType() const
bool isRValueReferenceType() const
bool isFundamentalType() const
Tests whether the type is categorized as a fundamental type.
VectorTypeBitfields VectorTypeBits
SubstPackTypeBitfields SubstPackTypeBits
bool isConstantArrayType() const
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
bool isFunctionPointerType() const
bool isHLSLInlineSpirvType() const
bool isConvertibleToFixedPointType() const
Return true if this can be converted to (or from) a fixed point type.
bool isArithmeticType() const
bool isConstantMatrixType() const
bool isHLSLBuiltinIntangibleType() const
bool isPointerType() const
const TemplateSpecializationType * castAsNonAliasTemplateSpecializationType() const
bool isArrayParameterType() const
TypeOfBitfields TypeOfBits
static constexpr int FunctionTypeNumParamsLimit
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
bool isObjCSelType() const
const T * castAs() const
Member-template castAs<specific type>.
BuiltinTypeBitfields BuiltinTypeBits
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
bool isReferenceType() const
bool isSignedFixedPointType() const
Return true if this is a fixed point type that is signed according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isObjectPointerType() const
bool isEnumeralType() const
bool isVisibilityExplicit() const
Return true if the visibility was explicitly set is the code.
void addDependence(TypeDependence D)
ConstantArrayTypeBitfields ConstantArrayTypeBits
Type(TypeClass tc, QualType canon, TypeDependence Dependence)
bool isScalarType() const
bool isVariableArrayType() const
bool isFloat128Type() const
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
CountAttributedTypeBitfields CountAttributedTypeBits
bool isObjCQualifiedIdType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
LinkageInfo getLinkageAndVisibility() const
Determine the linkage and visibility of this type.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool isExtVectorType() const
bool isExtVectorBoolType() const
Type & operator=(const Type &)=delete
bool isObjCObjectOrInterfaceType() const
bool isNonOverloadPlaceholderType() const
Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.
bool isOCLIntelSubgroupAVCType() const
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 isMemberDataPointerType() const
bool isLValueReferenceType() const
bool isBitIntType() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isOpenCLSpecificType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isSignableIntegerType(const ASTContext &Ctx) const
bool isFloat32Type() const
bool isAnyComplexType() const
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
friend class TypePropertyCache
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
bool isSaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
const BuiltinType * getAsPlaceholderType() const
QualType getCanonicalTypeInternal() const
bool isHLSLSpecificType() const
bool isTemplateTypeParmType() const
@ PtrdiffT
The "ptrdiff_t" type.
@ SizeT
The "size_t" type.
@ SignedSizeT
The signed integer type corresponding to "size_t".
PresefinedSugarTypeBitfields PredefinedSugarTypeBits
bool isCompoundType() const
Tests whether the type is categorized as a compound type.
bool containsErrors() const
Whether this type is an error type.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isMemberPointerType() const
bool isAtomicType() const
AttributedTypeBitfields AttributedTypeBits
bool isFunctionProtoType() const
bool isIbm128Type() const
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
bool isObjCIdType() const
bool isMatrixType() const
TagTypeBitfields TagTypeBits
PackExpansionTypeBitfields PackExpansionTypeBits
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isUnsaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
UnresolvedUsingBitfields UnresolvedUsingBits
bool isObjCObjectType() const
bool isFromAST() const
Whether this type comes from an AST file.
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isObjectType() const
Determine whether this type is an object type.
bool isDoubleType() const
bool isPointerOrReferenceType() const
KeywordWrapperBitfields KeywordWrapperBits
FunctionTypeBitfields FunctionTypeBits
bool isBFloat16Type() const
void setDependence(TypeDependence D)
const T * getAsAdjusted() const
Member-template getAsAdjusted<specific type>.
bool isFunctionType() const
bool isObjCObjectPointerType() const
SubstTemplateTypeParmTypeBitfields SubstTemplateTypeParmTypeBits
TypeDependence getDependence() const
Visibility getVisibility() const
Determine the visibility of this type.
bool isMemberFunctionPointerType() const
bool isUnsignedFixedPointType() const
Return true if this is a fixed point type that is unsigned according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isVectorType() const
bool isObjCQualifiedClassType() const
bool isObjCClassType() const
bool isObjCInertUnsafeUnretainedType() const
Was this type written with the special inert-in-ARC __unsafe_unretained qualifier?
bool isRealFloatingType() const
Floating point categories.
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
bool isHLSLAttributedResourceType() const
ObjCObjectTypeBitfields ObjCObjectTypeBits
TemplateTypeParmTypeBitfields TemplateTypeParmTypeBits
bool isOCLExtOpaqueType() const
const T * castAsCanonical() const
Return this type's canonical type cast to the specified type.
bool isAnyPointerType() const
TypeClass getTypeClass() const
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
bool isSubscriptableVectorType() const
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isNullPtrType() const
bool isRecordType() const
TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits
bool isTypedefNameType() const
Determines whether this type is written as a typedef-name.
static constexpr int FunctionTypeNumParamsWidth
bool isFunctionNoProtoType() const
bool isReserveIDT() const
bool hasObjCPointerRepresentation() const
Whether this type can represent an objective pointer type for the purpose of GC'ability.
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
AutoTypeBitfields AutoTypeBits
bool isCFIUncheckedCalleeFunctionType() const
Type & operator=(Type &&)=delete
Base class for declarations which introduce a typedef-name.
TypedefNameDecl * getDecl() const
NestedNameSpecifier getQualifier() const
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TypedefNameDecl *Decl, QualType Underlying)
static bool classof(const Type *T)
bool typeMatchesDecl() const
void Profile(llvm::FoldingSetNodeID &ID) const
void Profile(llvm::FoldingSetNodeID &ID) const
NestedNameSpecifier getQualifier() const
UnresolvedUsingTypenameDecl * getDecl() const
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const UnresolvedUsingTypenameDecl *D)
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 ...
UsingShadowDecl * getDecl() const
void Profile(llvm::FoldingSetNodeID &ID) const
NestedNameSpecifier getQualifier() const
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const UsingShadowDecl *D, QualType UnderlyingType)
static bool classof(const Type *T)
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
static bool classof(const Type *T)
friend class StmtIteratorBase
void Profile(llvm::FoldingSetNodeID &ID)
Expr * getSizeExpr() const
unsigned getNumElements() const
VectorType(QualType vecType, unsigned nElements, QualType canonType, VectorKind vecKind)
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.
mlir::Type getBaseType(mlir::Value varPtr)
@ AttributedType
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
bool operator!=(const CommonEntityInfo &LHS, const CommonEntityInfo &RHS)
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
uint32_t Literal
Literals are represented as positive integers.
std::variant< struct RequiresDecl, struct HeaderDecl, struct UmbrellaDirDecl, struct ModuleDecl, struct ExcludeDecl, struct ExportDecl, struct ExportAsDecl, struct ExternModuleDecl, struct UseDecl, struct LinkDecl, struct ConfigMacrosDecl, struct ConflictDecl > Decl
All declarations that can appear in a module declaration.
bool isLiteral(TokenKind K)
Return true if this is a "literal" kind, like a numeric constant, string, etc.
The JSON file list parser is used to communicate input to InstallAPI.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
@ Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
bool isa(CodeGen::Address addr)
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)
TypeDependenceScope::TypeDependence TypeDependence
void initialize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
@ Nullable
Values of this type can be null.
RefQualifierKind
The kind of C++11 ref-qualifier associated with a function type.
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
@ TemplateName
The identifier is a template name. FIXME: Add an annotation for that.
bool IsEnumDeclComplete(EnumDecl *ED)
Check if the given decl is complete.
ExprDependence computeDependence(FullExpr *E)
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
TypeOfKind
The kind of 'typeof' expression we're after.
bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
TypeDependence toTypeDependence(ExprDependence D)
@ Dependent
Parse the block as a dependent block, which may be used in some template instantiations but not other...
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.
@ Ordinary
This parameter uses ordinary ABI rules for its type.
const FunctionProtoType * T
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
@ Template
We are parsing a template declaration.
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.
std::is_base_of< ArrayType, T > TypeIsArrayType
@ Keyword
The name has been typo-corrected to a keyword.
LangAS
Defines the address space values used by the address space qualifier of QualType.
void FixedPointValueToString(SmallVectorImpl< char > &Str, llvm::APSInt Val, unsigned Scale)
bool operator!=(CanQual< T > x, CanQual< U > y)
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
U cast(CodeGen::Address addr)
@ None
The alignment was not explicit in code.
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.
@ None
No keyword precedes the qualified type name.
@ Struct
The "struct" keyword introduces the elaborated-type-specifier.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Union
The "union" keyword introduces the elaborated-type-specifier.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
@ 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...
void Profile(llvm::FoldingSetNodeID &ID)
const T * getType() const
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.
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
ExceptionSpecInfo(ExceptionSpecificationType EST)
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
ExceptionSpecificationType Type
The kind of exception specification this is.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
ExceptionSpecInfo()=default
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
FunctionTypeExtraAttributeInfo ExtraAttributeInfo
bool requiresFunctionProtoTypeArmAttributes() const
unsigned AArch64SMEAttributes
SourceLocation EllipsisLoc
FunctionEffectsRef FunctionEffects
unsigned CFIUncheckedCallee
const ExtParameterInfo * ExtParameterInfos
RefQualifierKind RefQualifier
bool requiresFunctionProtoTypeExtraAttributeInfo() const
ExtProtoInfo withCFIUncheckedCallee(bool CFIUncheckedCallee)
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.
FunctionTypeArmAttributes()
unsigned AArch64SMEAttributes
Any AArch64 SME ACLE type attributes that need to be propagated on declarations and function pointers...
Provides a few static helpers for converting and printing elaborated type keyword and tag type kind e...
static StringRef getTagTypeKindName(TagTypeKind Kind)
static StringRef getKeywordName(ElaboratedTypeKeyword Keyword)
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword)
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
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 constexpr int NumLowBitsAvailable
static void * getAsVoidPointer(::clang::Type *P)
static constexpr int NumLowBitsAvailable
static inline ::clang::Type * getFromVoidPointer(void *P)
static void * getAsVoidPointer(clang::QualType P)
static clang::QualType getFromVoidPointer(void *P)
static constexpr int NumLowBitsAvailable
static SimpleType getSimplifiedValue(::clang::QualType Val)
const ::clang::Type * SimpleType