41#include "llvm/ADT/APInt.h"
42#include "llvm/ADT/APSInt.h"
43#include "llvm/ADT/ArrayRef.h"
44#include "llvm/ADT/FoldingSet.h"
45#include "llvm/ADT/STLExtras.h"
46#include "llvm/ADT/SmallVector.h"
47#include "llvm/Support/ErrorHandling.h"
48#include "llvm/Support/MathExtras.h"
58 return (*
this !=
Other) &&
112 if (
const auto *DNT = ty->
getAs<DependentNameType>())
116 if (
const auto *TT = ty->
getAs<TagType>())
117 ND = TT->getOriginalDecl();
141 if (
T.isConstQualified())
145 return AT->getElementType().isConstant(Ctx);
150std::optional<QualType::NonConstantStorageReason>
153 if (!
isConstant(Ctx) && !(*this)->isReferenceType())
161 if (
Record->hasMutableFields())
163 if (!
Record->hasTrivialDestructor() && !ExcludeDtor)
189 (tc == DependentSizedArray
199 const llvm::APInt &Sz,
const Expr *SzExpr,
201 bool NeedsExternalSize = SzExpr !=
nullptr || Sz.ugt(0x0FFFFFFFFFFFFFFF) ||
202 Sz.getBitWidth() > 0xFF;
203 if (!NeedsExternalSize)
205 ET, Can, Sz.getBitWidth(), Sz.getZExtValue(), SzMod, Qual);
207 auto *SzPtr =
new (Ctx,
alignof(ConstantArrayType::ExternalSize))
208 ConstantArrayType::ExternalSize(Sz, SzExpr);
216 const llvm::APInt &NumElements) {
217 uint64_t ElementSize = Context.getTypeSizeInChars(ElementType).getQuantity();
225 if (llvm::isPowerOf2_64(ElementSize)) {
226 return NumElements.getActiveBits() + llvm::Log2_64(ElementSize);
231 if ((ElementSize >> 32) == 0 && NumElements.getBitWidth() <= 64 &&
232 (NumElements.getZExtValue() >> 32) == 0) {
233 uint64_t TotalSize = NumElements.getZExtValue() * ElementSize;
234 return llvm::bit_width(TotalSize);
238 llvm::APSInt SizeExtended(NumElements,
true);
239 unsigned SizeTypeBits = Context.getTypeSize(Context.getSizeType());
240 SizeExtended = SizeExtended.extend(
241 std::max(SizeTypeBits, SizeExtended.getBitWidth()) * 2);
243 llvm::APSInt TotalSize(llvm::APInt(SizeExtended.getBitWidth(), ElementSize));
244 TotalSize *= SizeExtended;
246 return TotalSize.getActiveBits();
255 unsigned Bits = Context.getTypeSize(Context.getSizeType());
268 uint64_t ArraySize,
const Expr *SizeExpr,
271 ID.AddInteger(ArraySize);
272 ID.AddInteger(llvm::to_underlying(SizeMod));
273 ID.AddInteger(TypeQuals);
274 ID.AddBoolean(SizeExpr !=
nullptr);
276 SizeExpr->
Profile(ID, Context,
true);
288 :
ArrayType(DependentSizedArray, et, can, sm, tq, e), SizeExpr((
Stmt *)e) {}
293 unsigned TypeQuals,
Expr *E) {
295 ID.AddInteger(llvm::to_underlying(SizeMod));
296 ID.AddInteger(TypeQuals);
301DependentVectorType::DependentVectorType(
QualType ElementType,
304 :
Type(DependentVector, CanonType,
306 ElementType->getDependence() |
309 ElementType(ElementType), SizeExpr(SizeExpr), Loc(Loc) {
317 ID.AddPointer(ElementType.getAsOpaquePtr());
318 ID.AddInteger(llvm::to_underlying(VecKind));
319 SizeExpr->Profile(ID, Context,
true);
322DependentSizedExtVectorType::DependentSizedExtVectorType(
QualType ElementType,
326 :
Type(DependentSizedExtVector, can,
328 ElementType->getDependence() |
331 SizeExpr(SizeExpr), ElementType(ElementType), loc(loc) {}
337 ID.AddPointer(ElementType.getAsOpaquePtr());
338 SizeExpr->Profile(ID, Context,
true);
341DependentAddressSpaceType::DependentAddressSpaceType(
QualType PointeeType,
345 :
Type(DependentAddressSpace, can,
347 PointeeType->getDependence() |
350 AddrSpaceExpr(AddrSpaceExpr), PointeeType(PointeeType), loc(loc) {}
355 Expr *AddrSpaceExpr) {
356 ID.AddPointer(PointeeType.getAsOpaquePtr());
357 AddrSpaceExpr->Profile(ID, Context,
true);
361 const Expr *RowExpr,
const Expr *ColumnExpr)
362 :
Type(tc, canonType,
379 unsigned nColumns,
QualType canonType)
384 unsigned nRows,
unsigned nColumns,
389DependentSizedMatrixType::DependentSizedMatrixType(
QualType ElementType,
394 :
MatrixType(DependentSizedMatrix, ElementType, CanonicalType, RowExpr,
396 RowExpr(RowExpr), ColumnExpr(ColumnExpr), loc(loc) {}
403 RowExpr->Profile(ID, CTX,
true);
404 ColumnExpr->Profile(ID, CTX,
true);
431 ExprAndUnsigned(NumBitsExpr, IsUnsigned) {}
434 return ExprAndUnsigned.getInt();
438 return ExprAndUnsigned.getPointer();
444 ID.AddBoolean(IsUnsigned);
445 NumBitsExpr->
Profile(ID, Context,
true);
457 bool CountInBytes,
bool OrNull) {
458 ID.AddPointer(WrappedTy.getAsOpaquePtr());
459 ID.AddBoolean(CountInBytes);
460 ID.AddBoolean(OrNull);
465 ID.AddPointer(CountExpr);
473 if (
const auto *ATy = dyn_cast<ArrayType>(
this))
474 return ATy->getElementType().getTypePtr();
502 return Context.getQualifiedType(desugar,
split.
Quals);
508#define TYPE(CLASS, BASE) \
509 static_assert(!std::is_polymorphic<CLASS##Type>::value, \
510 #CLASS "Type should not be polymorphic!");
511#include "clang/AST/TypeNodes.inc"
516#define TYPE(CLASS, BASE) \
517 static_assert(std::is_trivially_destructible<CLASS##Type>::value, \
518 #CLASS "Type should be trivially destructible!");
519#include "clang/AST/TypeNodes.inc"
523#define ABSTRACT_TYPE(Class, Parent)
524#define TYPE(Class, Parent) \
525 case Type::Class: { \
526 const auto *ty = cast<Class##Type>(this); \
527 if (!ty->isSugared()) \
528 return QualType(ty, 0); \
529 return ty->desugar(); \
531#include "clang/AST/TypeNodes.inc"
533 llvm_unreachable(
"bad type kind!");
543#define ABSTRACT_TYPE(Class, Parent)
544#define TYPE(Class, Parent) \
545 case Type::Class: { \
546 const auto *Ty = cast<Class##Type>(CurTy); \
547 if (!Ty->isSugared()) \
548 return SplitQualType(Ty, Qs); \
549 Cur = Ty->desugar(); \
552#include "clang/AST/TypeNodes.inc"
561 Qualifiers quals =
split.Quals;
564 const Type *lastTypeWithQuals =
split.Ty;
571 switch (
split.Ty->getTypeClass()) {
572#define ABSTRACT_TYPE(Class, Parent)
573#define TYPE(Class, Parent) \
574 case Type::Class: { \
575 const auto *ty = cast<Class##Type>(split.Ty); \
576 if (!ty->isSugared()) \
578 next = ty->desugar(); \
581#include "clang/AST/TypeNodes.inc"
587 if (!
split.Quals.empty()) {
588 lastTypeWithQuals =
split.Ty;
594 return SplitQualType(lastTypeWithQuals, quals);
599 while (
const auto *PT =
T->
getAs<ParenType>())
600 T = PT->getInnerType();
609 if (
const auto *Sugar = dyn_cast<T>(Cur))
612#define ABSTRACT_TYPE(Class, Parent)
613#define TYPE(Class, Parent) \
614 case Type::Class: { \
615 const auto *Ty = cast<Class##Type>(Cur); \
616 if (!Ty->isSugared()) \
618 Cur = Ty->desugar().getTypePtr(); \
621#include "clang/AST/TypeNodes.inc"
634template <>
const TemplateSpecializationType *
Type::getAs()
const {
654 const Type *Cur =
this;
658#define ABSTRACT_TYPE(Class, Parent)
659#define TYPE(Class, Parent) \
661 const auto *Ty = cast<Class##Type>(Cur); \
662 if (!Ty->isSugared()) \
664 Cur = Ty->desugar().getTypePtr(); \
667#include "clang/AST/TypeNodes.inc"
674 return RT->getOriginalDecl()->isClass();
680 return RT->getOriginalDecl()->isStruct();
688 const auto *
Decl = RT->getOriginalDecl();
689 if (!
Decl->isStruct())
691 return Decl->getDefinitionOrSelf()->hasFlexibleArrayMember();
696 return RD->hasAttr<ObjCBoxableAttr>();
702 return RT->getOriginalDecl()->isInterface();
708 return RT->getOriginalDecl()->isStructureOrClass();
714 return PT->getPointeeType()->isVoidType();
720 return RT->getOriginalDecl()->isUnion();
726 return CT->getElementType()->isFloatingType();
737 return ET->getOriginalDecl()->isScoped();
747 if (
Complex->getElementType()->isIntegerType())
770 if (
const auto *RT = dyn_cast<RecordType>(
this)) {
771 if (RT->getOriginalDecl()->isStruct())
776 if (
const auto *RT = dyn_cast<RecordType>(CanonicalType)) {
777 if (!RT->getOriginalDecl()->isStruct())
789 if (
const auto *RT = dyn_cast<RecordType>(
this)) {
790 if (RT->getOriginalDecl()->isUnion())
795 if (
const auto *RT = dyn_cast<RecordType>(CanonicalType)) {
796 if (!RT->getOriginalDecl()->isUnion())
816 if (OPT->isObjCIdType())
820 if (!OPT->isKindOfType())
824 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType())
828 bound = OPT->getObjectType()
829 ->stripObjCKindOfTypeAndQuals(ctx)
840 if (OPT->isObjCClassType())
844 if (!OPT->isKindOfType())
848 return OPT->isObjCClassType() || OPT->isObjCQualifiedClassType();
862 :
Type(ObjCObject, Canonical,
Base->getDependence()), BaseType(
Base) {
866 assert(getTypeArgsAsWritten().size() == typeArgs.size() &&
867 "bitfield overflow in type argument count");
868 if (!typeArgs.empty())
869 memcpy(getTypeArgStorage(), typeArgs.data(),
870 typeArgs.size() *
sizeof(
QualType));
872 for (
auto typeArg : typeArgs) {
873 addDependence(typeArg->getDependence() & ~TypeDependence::VariablyModified);
880bool ObjCObjectType::isSpecialized()
const {
882 if (ObjCObjectTypeBits.NumTypeArgs > 0)
886 if (
const auto objcObject =
getBaseType()->getAs<ObjCObjectType>()) {
891 return objcObject->isSpecialized();
900 if (isSpecializedAsWritten())
901 return getTypeArgsAsWritten();
904 if (
const auto objcObject =
getBaseType()->getAs<ObjCObjectType>()) {
909 return objcObject->getTypeArgs();
916bool ObjCObjectType::isKindOfType()
const {
917 if (isKindOfTypeAsWritten())
921 if (
const auto objcObject =
getBaseType()->getAs<ObjCObjectType>()) {
926 return objcObject->isKindOfType();
934ObjCObjectType::stripObjCKindOfTypeAndQuals(
const ASTContext &ctx)
const {
935 if (!isKindOfType() && qual_empty())
941 if (
const auto *baseObj = splitBaseType.
Ty->
getAs<ObjCObjectType>())
942 baseType = baseObj->stripObjCKindOfTypeAndQuals(ctx);
946 getTypeArgsAsWritten(),
971template <
typename Derived>
972struct SimpleTransformVisitor :
public TypeVisitor<Derived, QualType> {
980 QualType result =
static_cast<Derived *
>(
this)->Visit(splitType.
Ty);
990 explicit SimpleTransformVisitor(
ASTContext &ctx) : Ctx(ctx) {}
994#define TYPE(Class, Base)
995#define DEPENDENT_TYPE(Class, Base) \
996 QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
997#include "clang/AST/TypeNodes.inc"
999#define TRIVIAL_TYPE_CLASS(Class) \
1000 QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
1001#define SUGARED_TYPE_CLASS(Class) \
1002 QualType Visit##Class##Type(const Class##Type *T) { \
1003 if (!T->isSugared()) \
1004 return QualType(T, 0); \
1005 QualType desugaredType = recurse(T->desugar()); \
1006 if (desugaredType.isNull()) \
1008 if (desugaredType.getAsOpaquePtr() == T->desugar().getAsOpaquePtr()) \
1009 return QualType(T, 0); \
1010 return desugaredType; \
1016 QualType elementType = recurse(
T->getElementType());
1017 if (elementType.
isNull())
1020 if (elementType.
getAsOpaquePtr() ==
T->getElementType().getAsOpaquePtr())
1026 QualType VisitPointerType(
const PointerType *
T) {
1028 if (pointeeType.
isNull())
1032 return QualType(
T, 0);
1037 QualType VisitBlockPointerType(
const BlockPointerType *
T) {
1039 if (pointeeType.
isNull())
1043 return QualType(
T, 0);
1048 QualType VisitLValueReferenceType(
const LValueReferenceType *
T) {
1049 QualType pointeeType = recurse(
T->getPointeeTypeAsWritten());
1050 if (pointeeType.
isNull())
1054 T->getPointeeTypeAsWritten().getAsOpaquePtr())
1055 return QualType(
T, 0);
1060 QualType VisitRValueReferenceType(
const RValueReferenceType *
T) {
1061 QualType pointeeType = recurse(
T->getPointeeTypeAsWritten());
1062 if (pointeeType.
isNull())
1066 T->getPointeeTypeAsWritten().getAsOpaquePtr())
1067 return QualType(
T, 0);
1072 QualType VisitMemberPointerType(
const MemberPointerType *
T) {
1074 if (pointeeType.
isNull())
1078 return QualType(
T, 0);
1081 T->getMostRecentCXXRecordDecl());
1084 QualType VisitConstantArrayType(
const ConstantArrayType *
T) {
1085 QualType elementType = recurse(
T->getElementType());
1086 if (elementType.
isNull())
1089 if (elementType.
getAsOpaquePtr() ==
T->getElementType().getAsOpaquePtr())
1090 return QualType(
T, 0);
1093 T->getSizeModifier(),
1094 T->getIndexTypeCVRQualifiers());
1097 QualType VisitVariableArrayType(
const VariableArrayType *
T) {
1098 QualType elementType = recurse(
T->getElementType());
1099 if (elementType.
isNull())
1102 if (elementType.
getAsOpaquePtr() ==
T->getElementType().getAsOpaquePtr())
1103 return QualType(
T, 0);
1106 T->getSizeModifier(),
1107 T->getIndexTypeCVRQualifiers());
1110 QualType VisitIncompleteArrayType(
const IncompleteArrayType *
T) {
1111 QualType elementType = recurse(
T->getElementType());
1112 if (elementType.
isNull())
1115 if (elementType.
getAsOpaquePtr() ==
T->getElementType().getAsOpaquePtr())
1116 return QualType(
T, 0);
1119 T->getIndexTypeCVRQualifiers());
1122 QualType VisitVectorType(
const VectorType *
T) {
1123 QualType elementType = recurse(
T->getElementType());
1124 if (elementType.
isNull())
1127 if (elementType.
getAsOpaquePtr() ==
T->getElementType().getAsOpaquePtr())
1128 return QualType(
T, 0);
1131 T->getVectorKind());
1134 QualType VisitExtVectorType(
const ExtVectorType *
T) {
1135 QualType elementType = recurse(
T->getElementType());
1136 if (elementType.
isNull())
1139 if (elementType.
getAsOpaquePtr() ==
T->getElementType().getAsOpaquePtr())
1140 return QualType(
T, 0);
1145 QualType VisitConstantMatrixType(
const ConstantMatrixType *
T) {
1146 QualType elementType = recurse(
T->getElementType());
1147 if (elementType.
isNull())
1149 if (elementType.
getAsOpaquePtr() ==
T->getElementType().getAsOpaquePtr())
1150 return QualType(
T, 0);
1153 T->getNumColumns());
1156 QualType VisitFunctionNoProtoType(
const FunctionNoProtoType *
T) {
1162 return QualType(
T, 0);
1167 QualType VisitFunctionProtoType(
const FunctionProtoType *
T) {
1173 SmallVector<QualType, 4> paramTypes;
1174 bool paramChanged =
false;
1176 QualType newParamType = recurse(paramType);
1177 if (newParamType.
isNull())
1181 paramChanged =
true;
1183 paramTypes.push_back(newParamType);
1188 bool exceptionChanged =
false;
1190 SmallVector<QualType, 4> exceptionTypes;
1192 QualType newExceptionType = recurse(exceptionType);
1193 if (newExceptionType.
isNull())
1196 if (newExceptionType.
getAsOpaquePtr() != exceptionType.getAsOpaquePtr())
1197 exceptionChanged =
true;
1199 exceptionTypes.push_back(newExceptionType);
1202 if (exceptionChanged) {
1204 llvm::ArrayRef(exceptionTypes).copy(Ctx);
1209 !paramChanged && !exceptionChanged)
1210 return QualType(
T, 0);
1215 QualType VisitParenType(
const ParenType *
T) {
1216 QualType innerType = recurse(
T->getInnerType());
1221 return QualType(
T, 0);
1230 QualType VisitAdjustedType(
const AdjustedType *
T) {
1231 QualType originalType = recurse(
T->getOriginalType());
1232 if (originalType.
isNull())
1235 QualType adjustedType = recurse(
T->getAdjustedType());
1236 if (adjustedType.
isNull())
1240 T->getOriginalType().getAsOpaquePtr() &&
1241 adjustedType.
getAsOpaquePtr() ==
T->getAdjustedType().getAsOpaquePtr())
1242 return QualType(
T, 0);
1247 QualType VisitDecayedType(
const DecayedType *
T) {
1248 QualType originalType = recurse(
T->getOriginalType());
1249 if (originalType.
isNull())
1252 if (originalType.
getAsOpaquePtr() ==
T->getOriginalType().getAsOpaquePtr())
1253 return QualType(
T, 0);
1258 QualType VisitArrayParameterType(
const ArrayParameterType *
T) {
1259 QualType ArrTy = VisitConstantArrayType(
T);
1273 QualType VisitAttributedType(
const AttributedType *
T) {
1274 QualType modifiedType = recurse(
T->getModifiedType());
1275 if (modifiedType.
isNull())
1278 QualType equivalentType = recurse(
T->getEquivalentType());
1279 if (equivalentType.
isNull())
1283 T->getModifiedType().getAsOpaquePtr() &&
1285 T->getEquivalentType().getAsOpaquePtr())
1286 return QualType(
T, 0);
1292 QualType VisitSubstTemplateTypeParmType(
const SubstTemplateTypeParmType *
T) {
1293 QualType replacementType = recurse(
T->getReplacementType());
1294 if (replacementType.
isNull())
1298 T->getReplacementType().getAsOpaquePtr())
1299 return QualType(
T, 0);
1302 replacementType,
T->getAssociatedDecl(),
T->getIndex(),
1303 T->getPackIndex(),
T->getFinal());
1309 QualType VisitAutoType(
const AutoType *
T) {
1310 if (!
T->isDeduced())
1311 return QualType(
T, 0);
1313 QualType deducedType = recurse(
T->getDeducedType());
1314 if (deducedType.
isNull())
1317 if (deducedType.
getAsOpaquePtr() ==
T->getDeducedType().getAsOpaquePtr())
1318 return QualType(
T, 0);
1321 false,
T->getTypeConstraintConcept(),
1322 T->getTypeConstraintArguments());
1325 QualType VisitObjCObjectType(
const ObjCObjectType *
T) {
1326 QualType baseType = recurse(
T->getBaseType());
1331 bool typeArgChanged =
false;
1332 SmallVector<QualType, 4> typeArgs;
1333 for (
auto typeArg :
T->getTypeArgsAsWritten()) {
1334 QualType newTypeArg = recurse(typeArg);
1339 typeArgChanged =
true;
1341 typeArgs.push_back(newTypeArg);
1346 return QualType(
T, 0);
1350 llvm::ArrayRef(
T->qual_begin(),
T->getNumProtocols()),
1351 T->isKindOfTypeAsWritten());
1356 QualType VisitObjCObjectPointerType(
const ObjCObjectPointerType *
T) {
1358 if (pointeeType.
isNull())
1362 return QualType(
T, 0);
1367 QualType VisitAtomicType(
const AtomicType *
T) {
1368 QualType valueType = recurse(
T->getValueType());
1373 return QualType(
T, 0);
1378#undef TRIVIAL_TYPE_CLASS
1379#undef SUGARED_TYPE_CLASS
1382struct SubstObjCTypeArgsVisitor
1383 :
public SimpleTransformVisitor<SubstObjCTypeArgsVisitor> {
1384 using BaseType = SimpleTransformVisitor<SubstObjCTypeArgsVisitor>;
1386 ArrayRef<QualType> TypeArgs;
1389 SubstObjCTypeArgsVisitor(ASTContext &ctx, ArrayRef<QualType> typeArgs,
1391 : BaseType(ctx), TypeArgs(typeArgs), SubstContext(context) {}
1393 QualType VisitObjCTypeParamType(
const ObjCTypeParamType *OTPTy) {
1396 ObjCTypeParamDecl *typeParam = OTPTy->getDecl();
1398 if (!TypeArgs.empty()) {
1399 QualType argType = TypeArgs[typeParam->
getIndex()];
1400 if (OTPTy->qual_empty())
1405 SmallVector<ObjCProtocolDecl *, 8> protocolsVec;
1406 protocolsVec.append(OTPTy->qual_begin(), OTPTy->qual_end());
1407 ArrayRef<ObjCProtocolDecl *> protocolsToApply = protocolsVec;
1409 argType, protocolsToApply, hasError,
true );
1412 switch (SubstContext) {
1413 case ObjCSubstitutionContext::Ordinary:
1414 case ObjCSubstitutionContext::Parameter:
1415 case ObjCSubstitutionContext::Superclass:
1419 case ObjCSubstitutionContext::Result:
1420 case ObjCSubstitutionContext::Property: {
1422 const auto *objPtr =
1427 if (objPtr->isKindOfType() || objPtr->isObjCIdOrClassType())
1431 const auto *obj = objPtr->getObjectType();
1433 obj->getBaseType(), obj->getTypeArgsAsWritten(), obj->getProtocols(),
1440 llvm_unreachable(
"Unexpected ObjCSubstitutionContext!");
1443 QualType VisitFunctionType(
const FunctionType *funcType) {
1449 Ctx, TypeArgs, ObjCSubstitutionContext::Result);
1459 return BaseType::VisitFunctionType(funcType);
1468 SmallVector<QualType, 4> paramTypes;
1469 bool paramChanged =
false;
1470 for (
auto paramType : funcProtoType->getParamTypes()) {
1472 Ctx, TypeArgs, ObjCSubstitutionContext::Parameter);
1473 if (newParamType.
isNull())
1477 paramChanged =
true;
1479 paramTypes.push_back(newParamType);
1483 FunctionProtoType::ExtProtoInfo info = funcProtoType->getExtProtoInfo();
1484 bool exceptionChanged =
false;
1486 SmallVector<QualType, 4> exceptionTypes;
1489 Ctx, TypeArgs, ObjCSubstitutionContext::Ordinary);
1490 if (newExceptionType.
isNull())
1493 if (newExceptionType.
getAsOpaquePtr() != exceptionType.getAsOpaquePtr())
1494 exceptionChanged =
true;
1496 exceptionTypes.push_back(newExceptionType);
1499 if (exceptionChanged) {
1501 llvm::ArrayRef(exceptionTypes).copy(Ctx);
1506 funcProtoType->getReturnType().getAsOpaquePtr() &&
1507 !paramChanged && !exceptionChanged)
1508 return BaseType::VisitFunctionType(funcType);
1513 QualType VisitObjCObjectType(
const ObjCObjectType *objcObjectType) {
1516 if (objcObjectType->isSpecializedAsWritten()) {
1517 SmallVector<QualType, 4> newTypeArgs;
1518 bool anyChanged =
false;
1519 for (
auto typeArg : objcObjectType->getTypeArgsAsWritten()) {
1521 Ctx, TypeArgs, ObjCSubstitutionContext::Ordinary);
1528 ArrayRef<ObjCProtocolDecl *> protocols(
1529 objcObjectType->qual_begin(), objcObjectType->getNumProtocols());
1530 if (TypeArgs.empty() &&
1531 SubstContext != ObjCSubstitutionContext::Superclass) {
1533 objcObjectType->getBaseType(), {}, protocols,
1534 objcObjectType->isKindOfTypeAsWritten());
1540 newTypeArgs.push_back(newTypeArg);
1544 ArrayRef<ObjCProtocolDecl *> protocols(
1545 objcObjectType->qual_begin(), objcObjectType->getNumProtocols());
1548 objcObjectType->isKindOfTypeAsWritten());
1552 return BaseType::VisitObjCObjectType(objcObjectType);
1555 QualType VisitAttributedType(
const AttributedType *attrType) {
1556 QualType newType = BaseType::VisitAttributedType(attrType);
1560 const auto *newAttrType = dyn_cast<AttributedType>(newType.
getTypePtr());
1561 if (!newAttrType || newAttrType->getAttrKind() != attr::ObjCKindOf)
1565 QualType newEquivType = newAttrType->getEquivalentType();
1566 const ObjCObjectPointerType *ptrType =
1567 newEquivType->
getAs<ObjCObjectPointerType>();
1568 const ObjCObjectType *objType = ptrType
1570 : newEquivType->
getAs<ObjCObjectType>();
1577 objType->getBaseType(), objType->getTypeArgsAsWritten(),
1578 objType->getProtocols(),
1580 objType->isObjCUnqualifiedId() ?
false :
true);
1588 newAttrType->getModifiedType(), newEquivType,
1589 newAttrType->getAttr());
1593struct StripObjCKindOfTypeVisitor
1594 :
public SimpleTransformVisitor<StripObjCKindOfTypeVisitor> {
1595 using BaseType = SimpleTransformVisitor<StripObjCKindOfTypeVisitor>;
1597 explicit StripObjCKindOfTypeVisitor(ASTContext &ctx) : BaseType(ctx) {}
1599 QualType VisitObjCObjectType(
const ObjCObjectType *objType) {
1600 if (!objType->isKindOfType())
1601 return BaseType::VisitObjCObjectType(objType);
1603 QualType baseType = objType->getBaseType().stripObjCKindOfType(Ctx);
1605 objType->getProtocols(),
1622 case BuiltinType::Kind::Float16: {
1630 case BuiltinType::Kind::BFloat16: {
1650 SubstObjCTypeArgsVisitor visitor(ctx, typeArgs, context);
1651 return visitor.recurse(*
this);
1665 auto &ctx =
const_cast<ASTContext &
>(constCtx);
1666 StripObjCKindOfTypeVisitor visitor(ctx);
1667 return visitor.recurse(*
this);
1672 if (
const auto AT =
T.getTypePtr()->getAs<
AtomicType>())
1673 T = AT->getValueType();
1674 return T.getUnqualifiedType();
1677std::optional<ArrayRef<QualType>>
1680 if (
const auto method = dyn_cast<ObjCMethodDecl>(dc))
1681 dc = method->getDeclContext();
1685 const auto *dcClassDecl = dyn_cast<ObjCInterfaceDecl>(dc);
1691 dcTypeParams = dcClassDecl->getTypeParamList();
1693 return std::nullopt;
1697 dcCategoryDecl = dyn_cast<ObjCCategoryDecl>(dc);
1698 if (!dcCategoryDecl)
1699 return std::nullopt;
1705 return std::nullopt;
1709 return std::nullopt;
1711 assert(dcTypeParams &&
"No substitutions to perform");
1712 assert(dcClassDecl &&
"No class context");
1717 objectType = objectPointerType->getObjectType();
1728 objectType ? objectType->getInterface() :
nullptr;
1729 if (!curClassDecl) {
1737 while (curClassDecl != dcClassDecl) {
1739 QualType superType = objectType->getSuperClassType();
1740 if (superType.
isNull()) {
1741 objectType =
nullptr;
1746 curClassDecl = objectType->getInterface();
1751 if (!objectType || objectType->isUnspecialized()) {
1756 return objectType->getTypeArgs();
1761 if (
auto *ID = IfaceT->getInterface()) {
1762 if (ID->getTypeParamList())
1770void ObjCObjectType::computeSuperClassTypeSlow()
const {
1776 CachedSuperClassType.setInt(
true);
1782 if (!superClassObjTy) {
1783 CachedSuperClassType.setInt(
true);
1788 if (!superClassDecl) {
1789 CachedSuperClassType.setInt(
true);
1795 QualType superClassType(superClassObjTy, 0);
1797 if (!superClassTypeParams) {
1798 CachedSuperClassType.setPointerAndInt(
1799 superClassType->castAs<ObjCObjectType>(),
true);
1804 if (superClassObjTy->isUnspecialized()) {
1805 CachedSuperClassType.setPointerAndInt(superClassObjTy,
true);
1813 CachedSuperClassType.setPointerAndInt(
1814 superClassType->castAs<ObjCObjectType>(),
true);
1820 if (isUnspecialized()) {
1823 superClassObjTy->getInterface());
1824 CachedSuperClassType.setPointerAndInt(
1825 unspecializedSuper->
castAs<ObjCObjectType>(),
true);
1831 assert(typeArgs.size() == typeParams->
size());
1832 CachedSuperClassType.setPointerAndInt(
1836 ->castAs<ObjCObjectType>(),
1842 return interfaceDecl->getASTContext()
1843 .getObjCInterfaceType(interfaceDecl)
1852 if (superObjectType.
isNull())
1853 return superObjectType;
1864 if (
T->getNumProtocols() &&
T->getInterface())
1877 if (OPT->isObjCQualifiedIdType())
1887 if (OPT->isObjCQualifiedClassType())
1895 if (OT->getInterface())
1903 if (OPT->getInterfaceType())
1920const TemplateSpecializationType *
1923 while (TST && TST->isTypeAlias())
1924 TST = TST->desugar()->getAs<TemplateSpecializationType>();
1930 case Type::DependentName:
1932 case Type::TemplateSpecialization:
1938 case Type::InjectedClassName:
1942 case Type::UnresolvedUsing:
1947 return std::nullopt;
1952 const Type *Cur =
this;
1953 while (
const auto *AT = Cur->
getAs<AttributedType>()) {
1954 if (AT->getAttrKind() == AK)
1956 Cur = AT->getEquivalentType().getTypePtr();
1963class GetContainedDeducedTypeVisitor
1964 :
public TypeVisitor<GetContainedDeducedTypeVisitor, Type *> {
1968 GetContainedDeducedTypeVisitor(
bool Syntactic =
false)
1969 : Syntactic(Syntactic) {}
1976 return Visit(
T.getTypePtr());
1980 Type *VisitDeducedType(
const DeducedType *AT) {
1981 return const_cast<DeducedType *
>(AT);
1985 Type *VisitSubstTemplateTypeParmType(
const SubstTemplateTypeParmType *
T) {
1986 return Visit(
T->getReplacementType());
1989 Type *VisitPointerType(
const PointerType *
T) {
1993 Type *VisitBlockPointerType(
const BlockPointerType *
T) {
1997 Type *VisitReferenceType(
const ReferenceType *
T) {
1998 return Visit(
T->getPointeeTypeAsWritten());
2001 Type *VisitMemberPointerType(
const MemberPointerType *
T) {
2005 Type *VisitArrayType(
const ArrayType *
T) {
2006 return Visit(
T->getElementType());
2009 Type *VisitDependentSizedExtVectorType(
const DependentSizedExtVectorType *
T) {
2010 return Visit(
T->getElementType());
2013 Type *VisitVectorType(
const VectorType *
T) {
2014 return Visit(
T->getElementType());
2017 Type *VisitDependentSizedMatrixType(
const DependentSizedMatrixType *
T) {
2018 return Visit(
T->getElementType());
2021 Type *VisitConstantMatrixType(
const ConstantMatrixType *
T) {
2022 return Visit(
T->getElementType());
2025 Type *VisitFunctionProtoType(
const FunctionProtoType *
T) {
2027 return const_cast<FunctionProtoType *
>(
T);
2028 return VisitFunctionType(
T);
2031 Type *VisitFunctionType(
const FunctionType *
T) {
2035 Type *VisitParenType(
const ParenType *
T) {
return Visit(
T->getInnerType()); }
2037 Type *VisitAttributedType(
const AttributedType *
T) {
2038 return Visit(
T->getModifiedType());
2041 Type *VisitMacroQualifiedType(
const MacroQualifiedType *
T) {
2042 return Visit(
T->getUnderlyingType());
2045 Type *VisitAdjustedType(
const AdjustedType *
T) {
2046 return Visit(
T->getOriginalType());
2049 Type *VisitPackExpansionType(
const PackExpansionType *
T) {
2050 return Visit(
T->getPattern());
2057 return cast_or_null<DeducedType>(
2058 GetContainedDeducedTypeVisitor().Visit(
this));
2062 return isa_and_nonnull<FunctionType>(
2063 GetContainedDeducedTypeVisitor(
true).Visit(
this));
2067 if (
const auto *VT = dyn_cast<VectorType>(CanonicalType))
2068 return VT->getElementType()->isIntegerType();
2069 if (CanonicalType->isSveVLSBuiltinType()) {
2071 return VT->getKind() == BuiltinType::SveBool ||
2072 (VT->getKind() >= BuiltinType::SveInt8 &&
2073 VT->getKind() <= BuiltinType::SveUint64);
2075 if (CanonicalType->isRVVVLSBuiltinType()) {
2077 return (VT->getKind() >= BuiltinType::RvvInt8mf8 &&
2078 VT->getKind() <= BuiltinType::RvvUint64m8);
2104 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2105 return BT->isInteger();
2109 if (
const auto *ET = dyn_cast<EnumType>(CanonicalType))
2116 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2117 return BT->isInteger();
2126 if (
const auto *ET = dyn_cast<EnumType>(CanonicalType))
2127 return !ET->getOriginalDecl()->isScoped();
2133 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2134 return BT->getKind() == BuiltinType::Char_U ||
2135 BT->getKind() == BuiltinType::UChar ||
2136 BT->getKind() == BuiltinType::Char_S ||
2137 BT->getKind() == BuiltinType::SChar;
2142 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2143 return BT->getKind() == BuiltinType::WChar_S ||
2144 BT->getKind() == BuiltinType::WChar_U;
2149 if (
const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
2150 return BT->getKind() == BuiltinType::Char8;
2155 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2156 return BT->getKind() == BuiltinType::Char16;
2161 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2162 return BT->getKind() == BuiltinType::Char32;
2169 const auto *BT = dyn_cast<BuiltinType>(CanonicalType);
2172 switch (BT->getKind()) {
2175 case BuiltinType::Char_U:
2176 case BuiltinType::UChar:
2177 case BuiltinType::WChar_U:
2178 case BuiltinType::Char8:
2179 case BuiltinType::Char16:
2180 case BuiltinType::Char32:
2181 case BuiltinType::Char_S:
2182 case BuiltinType::SChar:
2183 case BuiltinType::WChar_S:
2189 const auto *BT = dyn_cast<BuiltinType>(CanonicalType);
2192 switch (BT->getKind()) {
2195 case BuiltinType::Char8:
2196 case BuiltinType::Char16:
2197 case BuiltinType::Char32:
2206 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2207 return BT->isSignedInteger();
2212 if (!ED->isComplete() || ED->isScoped())
2214 return ED->getIntegerType()->isSignedIntegerType();
2217 if (
const auto *IT = dyn_cast<BitIntType>(CanonicalType))
2218 return IT->isSigned();
2219 if (
const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType))
2220 return IT->isSigned();
2226 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2227 return BT->isSignedInteger();
2230 if (!ED->isComplete())
2232 return ED->getIntegerType()->isSignedIntegerType();
2235 if (
const auto *IT = dyn_cast<BitIntType>(CanonicalType))
2236 return IT->isSigned();
2237 if (
const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType))
2238 return IT->isSigned();
2244 if (
const auto *VT = dyn_cast<VectorType>(CanonicalType))
2245 return VT->getElementType()->isSignedIntegerOrEnumerationType();
2254 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2255 return BT->isUnsignedInteger();
2260 if (!ED->isComplete() || ED->isScoped())
2262 return ED->getIntegerType()->isUnsignedIntegerType();
2265 if (
const auto *IT = dyn_cast<BitIntType>(CanonicalType))
2266 return IT->isUnsigned();
2267 if (
const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType))
2268 return IT->isUnsigned();
2274 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2275 return BT->isUnsignedInteger();
2278 if (!ED->isComplete())
2280 return ED->getIntegerType()->isUnsignedIntegerType();
2283 if (
const auto *IT = dyn_cast<BitIntType>(CanonicalType))
2284 return IT->isUnsigned();
2285 if (
const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType))
2286 return IT->isUnsigned();
2292 if (
const auto *VT = dyn_cast<VectorType>(CanonicalType))
2293 return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
2294 if (
const auto *VT = dyn_cast<MatrixType>(CanonicalType))
2295 return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
2296 if (CanonicalType->isSveVLSBuiltinType()) {
2298 return VT->getKind() >= BuiltinType::SveUint8 &&
2299 VT->getKind() <= BuiltinType::SveUint64;
2305 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2306 return BT->isFloatingPoint();
2307 if (
const auto *CT = dyn_cast<ComplexType>(CanonicalType))
2308 return CT->getElementType()->isFloatingType();
2313 if (
const auto *VT = dyn_cast<VectorType>(CanonicalType))
2314 return VT->getElementType()->isFloatingType();
2315 if (
const auto *MT = dyn_cast<MatrixType>(CanonicalType))
2316 return MT->getElementType()->isFloatingType();
2321 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2322 return BT->isFloatingPoint();
2327 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2328 return BT->getKind() >= BuiltinType::Bool &&
2329 BT->getKind() <= BuiltinType::Ibm128;
2330 if (
const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
2331 const auto *ED = ET->getOriginalDecl();
2332 return !ED->isScoped() && ED->getDefinitionOrSelf()->isComplete();
2338 if (
const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
2339 return BT->getKind() >= BuiltinType::Bool &&
2340 BT->getKind() <= BuiltinType::Ibm128;
2341 if (
const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
2348 const auto *ED = ET->getOriginalDecl();
2349 return !ED->isScoped() && ED->getDefinitionOrSelf()->isComplete();
2355 if (
const auto *VT = dyn_cast<VectorType>(CanonicalType))
2356 return VT->getElementType()->isBooleanType();
2358 return ED->isComplete() && ED->getIntegerType()->isBooleanType();
2359 if (
const auto *IT = dyn_cast<BitIntType>(CanonicalType))
2360 return IT->getNumBits() == 1;
2367 const Type *
T = CanonicalType.getTypePtr();
2368 if (
const auto *BT = dyn_cast<BuiltinType>(
T)) {
2369 if (BT->getKind() == BuiltinType::Bool)
2371 if (BT->getKind() == BuiltinType::NullPtr)
2373 if (BT->isInteger())
2375 if (BT->isFloatingPoint())
2377 if (BT->isFixedPointType())
2379 llvm_unreachable(
"unknown scalar builtin type");
2389 assert(
T->castAsEnumDecl()->isComplete());
2391 }
else if (
const auto *CT = dyn_cast<ComplexType>(
T)) {
2392 if (CT->getElementType()->isRealFloatingType())
2399 llvm_unreachable(
"unknown scalar type");
2412 if (
const auto *
Record = dyn_cast<RecordType>(CanonicalType)) {
2413 if (
const auto *ClassDecl =
2414 dyn_cast<CXXRecordDecl>(
Record->getOriginalDecl()))
2415 return ClassDecl->isAggregate();
2427 assert(!
isIncompleteType() &&
"This doesn't make sense for incomplete types");
2428 assert(!
isDependentType() &&
"This doesn't make sense for dependent types");
2440 switch (CanonicalType->getTypeClass()) {
2451 return !EnumD->isComplete();
2459 return !Rec->isCompleteDefinition();
2461 case InjectedClassName: {
2463 if (!Rec->isBeingDefined())
2477 ->isIncompleteType(Def);
2478 case IncompleteArray:
2481 case MemberPointer: {
2494 if (!Context.getTargetInfo().getCXXABI().isMicrosoft())
2497 if (RD->
hasAttr<MSInheritanceAttr>())
2504 ->isIncompleteType(Def);
2505 case ObjCInterface: {
2537 switch (BT->getKind()) {
2539#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2540#include "clang/Basic/WebAssemblyReferenceTypes.def"
2542#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2543#include "clang/Basic/HLSLIntangibleTypes.def"
2554 return BT->getKind() == BuiltinType::WasmExternRef;
2559 if (
const auto *ATy = dyn_cast<ArrayType>(
this))
2560 return ATy->getElementType().isWebAssemblyReferenceType();
2562 if (
const auto *PTy = dyn_cast<PointerType>(
this))
2563 return PTy->getPointeeType().isWebAssemblyReferenceType();
2576 switch (BT->getKind()) {
2578#define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId) \
2579 case BuiltinType::Id: \
2581#define SVE_OPAQUE_TYPE(Name, MangledName, Id, SingletonId) \
2582 case BuiltinType::Id: \
2584#define SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId) \
2585 case BuiltinType::Id: \
2587#include "clang/Basic/AArch64ACLETypes.def"
2597 switch (BT->getKind()) {
2598#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2599#include "clang/Basic/RISCVVTypes.def"
2610 switch (BT->getKind()) {
2611 case BuiltinType::SveInt8:
2612 case BuiltinType::SveInt16:
2613 case BuiltinType::SveInt32:
2614 case BuiltinType::SveInt64:
2615 case BuiltinType::SveUint8:
2616 case BuiltinType::SveUint16:
2617 case BuiltinType::SveUint32:
2618 case BuiltinType::SveUint64:
2619 case BuiltinType::SveFloat16:
2620 case BuiltinType::SveFloat32:
2621 case BuiltinType::SveFloat64:
2622 case BuiltinType::SveBFloat16:
2623 case BuiltinType::SveBool:
2624 case BuiltinType::SveBoolx2:
2625 case BuiltinType::SveBoolx4:
2626 case BuiltinType::SveMFloat8:
2644 llvm_unreachable(
"Unhandled type");
2651 if (BTy->
getKind() == BuiltinType::SveBool)
2662 switch (BT->getKind()) {
2663#define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, \
2665 case BuiltinType::Id: \
2667#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
2668 case BuiltinType::Id: \
2670#include "clang/Basic/RISCVVTypes.def"
2684#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
2685 case BuiltinType::Id: \
2686 return Ctx.UnsignedCharTy;
2689#include "clang/Basic/RISCVVTypes.def"
2692 llvm_unreachable(
"Unhandled type");
2697 if (Context.getLangOpts().CPlusPlus11)
2710 if ((*this)->isIncompleteArrayType())
2711 return Context.getBaseElementType(*this).isCXX98PODType(Context);
2713 if ((*this)->isIncompleteType())
2722 if (Context.containsAddressDiscriminatedPointerAuth(CanonicalType))
2729 case Type::VariableArray:
2730 case Type::ConstantArray:
2732 return Context.getBaseElementType(*this).isCXX98PODType(Context);
2734 case Type::ObjCObjectPointer:
2735 case Type::BlockPointer:
2739 case Type::MemberPointer:
2741 case Type::ExtVector:
2749 if (
const auto *ClassDecl = dyn_cast<CXXRecordDecl>(
2751 return ClassDecl->isPOD();
2765 if ((*this)->isArrayType())
2766 return Context.getBaseElementType(*this).isTrivialType(Context);
2768 if ((*this)->isSizelessBuiltinType())
2773 if ((*this)->isIncompleteType())
2785 if (Context.containsAddressDiscriminatedPointerAuth(CanonicalType))
2804 return ClassDecl->hasTrivialDefaultConstructor() &&
2805 !ClassDecl->hasNonTrivialDefaultConstructor() &&
2806 ClassDecl->isTriviallyCopyable();
2818 bool IsCopyConstructible) {
2819 if (
type->isArrayType())
2821 Context, IsCopyConstructible);
2823 if (
type.hasNonTrivialObjCLifetime())
2856 if (
const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
2857 if (IsCopyConstructible)
2858 return ClassDecl->isTriviallyCopyConstructible();
2859 return ClassDecl->isTriviallyCopyable();
2861 return !RD->isNonTrivialToPrimitiveCopy();
2875 if (CanonicalType.hasNonTrivialObjCLifetime())
2877 if (CanonicalType->isArrayType())
2878 return Context.getBaseElementType(CanonicalType)
2879 .isBitwiseCloneableType(Context);
2881 if (CanonicalType->isIncompleteType())
2886 if (Context.containsAddressDiscriminatedPointerAuth(CanonicalType))
2889 const auto *RD = CanonicalType->getAsRecordDecl();
2896 if (RD->mayInsertExtraPadding())
2899 for (
auto *
const Field : RD->fields()) {
2900 if (!Field->getType().isBitwiseCloneableType(Context))
2904 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
2905 for (
auto Base : CXXRD->bases())
2906 if (!
Base.getType().isBitwiseCloneableType(Context))
2908 for (
auto VBase : CXXRD->vbases())
2909 if (!VBase.getType().isBitwiseCloneableType(Context))
2922 return !Context.getLangOpts().ObjCAutoRefCount &&
2923 Context.getLangOpts().ObjCWeak &&
2955 if (
const auto *RD =
2971 if (
const auto *RD =
3011 assert(BaseTy &&
"NULL element type");
3041 if (
const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD))
3042 return ClassDecl->isLiteral();
3049 return AT->getValueType()->isLiteralType(Ctx);
3071 return RD->isStructural();
3084 assert(BaseTy &&
"NULL element type");
3095 if (
const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD);
3096 ClassDecl && !ClassDecl->isStandardLayout())
3124 assert(BaseTy &&
"NULL element type");
3135 if (Context.containsAddressDiscriminatedPointerAuth(*
this))
3142 if (
const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
3145 if (!ClassDecl->isTrivial())
3151 if (!ClassDecl->isStandardLayout())
3182 const auto *ED = ET->getOriginalDecl();
3184 if (II && II->
isStr(
"align_val_t") && ED->isInStdNamespace())
3192 const auto *ED = ET->getOriginalDecl();
3194 if (II && II->
isStr(
"byte") && ED->isInStdNamespace())
3210 case TemplateTypeParm:
3211 case SubstTemplateTypeParm:
3212 case TemplateSpecialization:
3255 llvm_unreachable(
"Type specifier is not a tag type kind.");
3272 llvm_unreachable(
"Unknown tag type kind.");
3290 llvm_unreachable(
"Elaborated type keyword is not a tag type kind.");
3292 llvm_unreachable(
"Unknown elaborated type keyword.");
3307 llvm_unreachable(
"Unknown elaborated type keyword.");
3321 return "__interface";
3328 llvm_unreachable(
"Unknown elaborated type keyword.");
3333 if (
const auto *TST = dyn_cast<TemplateSpecializationType>(
this))
3335 else if (
const auto *DepName = dyn_cast<DependentNameType>(
this))
3336 Keyword = DepName->getKeyword();
3337 else if (
const auto *
T = dyn_cast<TagType>(
this))
3339 else if (
const auto *
T = dyn_cast<TypedefType>(
this))
3341 else if (
const auto *
T = dyn_cast<UnresolvedUsingType>(
this))
3343 else if (
const auto *
T = dyn_cast<UsingType>(
this))
3353#define ABSTRACT_TYPE(Derived, Base)
3354#define TYPE(Derived, Base) \
3357#include "clang/AST/TypeNodes.inc"
3360 llvm_unreachable(
"Invalid type class.");
3368 return Policy.
Bool ?
"bool" :
"_Bool";
3374 return "signed char";
3386 return "unsigned char";
3388 return "unsigned short";
3390 return "unsigned int";
3392 return "unsigned long";
3394 return "unsigned long long";
3396 return "unsigned __int128";
3398 return Policy.
Half ?
"half" :
"__fp16";
3406 return "long double";
3408 return "short _Accum";
3412 return "long _Accum";
3414 return "unsigned short _Accum";
3416 return "unsigned _Accum";
3418 return "unsigned long _Accum";
3419 case BuiltinType::ShortFract:
3420 return "short _Fract";
3421 case BuiltinType::Fract:
3423 case BuiltinType::LongFract:
3424 return "long _Fract";
3425 case BuiltinType::UShortFract:
3426 return "unsigned short _Fract";
3427 case BuiltinType::UFract:
3428 return "unsigned _Fract";
3429 case BuiltinType::ULongFract:
3430 return "unsigned long _Fract";
3431 case BuiltinType::SatShortAccum:
3432 return "_Sat short _Accum";
3433 case BuiltinType::SatAccum:
3434 return "_Sat _Accum";
3435 case BuiltinType::SatLongAccum:
3436 return "_Sat long _Accum";
3437 case BuiltinType::SatUShortAccum:
3438 return "_Sat unsigned short _Accum";
3439 case BuiltinType::SatUAccum:
3440 return "_Sat unsigned _Accum";
3441 case BuiltinType::SatULongAccum:
3442 return "_Sat unsigned long _Accum";
3443 case BuiltinType::SatShortFract:
3444 return "_Sat short _Fract";
3445 case BuiltinType::SatFract:
3446 return "_Sat _Fract";
3447 case BuiltinType::SatLongFract:
3448 return "_Sat long _Fract";
3449 case BuiltinType::SatUShortFract:
3450 return "_Sat unsigned short _Fract";
3451 case BuiltinType::SatUFract:
3452 return "_Sat unsigned _Fract";
3453 case BuiltinType::SatULongFract:
3454 return "_Sat unsigned long _Fract";
3458 return "__float128";
3463 return Policy.
MSWChar ?
"__wchar_t" :
"wchar_t";
3473 return "<overloaded function type>";
3475 return "<bound member function type>";
3476 case UnresolvedTemplate:
3477 return "<unresolved template type>";
3479 return "<pseudo-object type>";
3481 return "<dependent type>";
3483 return "<unknown type>";
3484 case ARCUnbridgedCast:
3485 return "<ARC unbridged cast type>";
3487 return "<builtin fn type>";
3494#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3496 return "__" #Access " " #ImgType "_t";
3497#include "clang/Basic/OpenCLImageTypes.def"
3503 return "clk_event_t";
3507 return "reserve_id_t";
3508 case IncompleteMatrixIdx:
3509 return "<incomplete matrix index type>";
3511 return "<array section type>";
3512 case OMPArrayShaping:
3513 return "<OpenMP array shaping type>";
3515 return "<OpenMP iterator type>";
3516#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
3519#include "clang/Basic/OpenCLExtensionTypes.def"
3520#define SVE_TYPE(Name, Id, SingletonId) \
3523#include "clang/Basic/AArch64ACLETypes.def"
3524#define PPC_VECTOR_TYPE(Name, Id, Size) \
3527#include "clang/Basic/PPCTypes.def"
3528#define RVV_TYPE(Name, Id, SingletonId) \
3531#include "clang/Basic/RISCVVTypes.def"
3532#define WASM_TYPE(Name, Id, SingletonId) \
3535#include "clang/Basic/WebAssemblyReferenceTypes.def"
3536#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) \
3539#include "clang/Basic/AMDGPUTypes.def"
3540#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
3543#include "clang/Basic/HLSLIntangibleTypes.def"
3546 llvm_unreachable(
"Invalid builtin type.");
3551 if (
auto *PET = dyn_cast<PackExpansionType>(
getTypePtr()))
3552 return PET->getPattern();
3557 if (
const auto *RefType =
getTypePtr()->getAs<ReferenceType>())
3565 if (!Context.getLangOpts().CPlusPlus ||
3574 return FPT->hasCFIUncheckedCallee();
3591 return "vectorcall";
3603 return "aarch64_vector_pcs";
3605 return "aarch64_sve_pcs";
3607 return "intel_ocl_bicc";
3609 return "spir_function";
3611 return "device_kernel";
3615 return "swiftasynccall";
3617 return "preserve_most";
3619 return "preserve_all";
3623 return "preserve_none";
3626#define CC_VLS_CASE(ABI_VLEN) \
3627 case CC_RISCVVLSCall_##ABI_VLEN: return "riscv_vls_cc(" #ABI_VLEN ")";
3644 llvm_unreachable(
"Invalid calling convention.");
3662 assert(
getNumParams() == params.size() &&
"NumParams overflow!");
3671 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
3679 auto &ExtraAttrInfo = *getTrailingObjects<FunctionTypeExtraAttributeInfo>();
3683 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
3684 ExtraBits.HasExtraAttributeInfo =
true;
3688 auto &ArmTypeAttrs = *getTrailingObjects<FunctionTypeArmAttributes>();
3689 ArmTypeAttrs = FunctionTypeArmAttributes();
3692 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
3693 ExtraBits.HasArmTypeAttributes =
true;
3697 auto *argSlot = getTrailingObjects<QualType>();
3700 ~TypeDependence::VariablyModified);
3701 argSlot[i] = params[i];
3706 auto &ArmTypeAttrs = *getTrailingObjects<FunctionTypeArmAttributes>();
3708 "Not enough bits to encode SME attributes");
3714 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
3716 assert(NumExceptions <= 1023 &&
"Not enough bits to encode exceptions");
3717 ExtraBits.NumExceptionType = NumExceptions;
3719 assert(hasExtraBitfields() &&
"missing trailing extra bitfields!");
3721 reinterpret_cast<QualType *
>(getTrailingObjects<ExceptionType>());
3729 (TypeDependence::Instantiation | TypeDependence::UnexpandedPack));
3731 exnSlot[I++] = ExceptionType;
3745 (TypeDependence::Instantiation | TypeDependence::UnexpandedPack));
3751 auto **slot = getTrailingObjects<FunctionDecl *>();
3759 auto **slot = getTrailingObjects<FunctionDecl *>();
3778 auto *extParamInfos = getTrailingObjects<ExtParameterInfo>();
3785 *getTrailingObjects<Qualifiers>() = epi.
TypeQuals;
3792 auto &EllipsisLoc = *getTrailingObjects<SourceLocation>();
3797 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>();
3799 ExtraBits.NumFunctionEffects = EffectsCount;
3800 assert(ExtraBits.NumFunctionEffects == EffectsCount &&
3801 "effect bitfield overflow");
3804 auto *DestFX = getTrailingObjects<FunctionEffect>();
3805 llvm::uninitialized_copy(SrcFX, DestFX);
3808 if (!SrcConds.empty()) {
3809 ExtraBits.EffectsHaveConditions =
true;
3810 auto *DestConds = getTrailingObjects<EffectConditionExpr>();
3811 llvm::uninitialized_copy(SrcConds, DestConds);
3812 assert(llvm::any_of(SrcConds,
3813 [](
const EffectConditionExpr &EC) {
3815 return E->isTypeDependent() ||
3816 E->isValueDependent();
3819 "expected a dependent expression among the conditions");
3827 return NE->isValueDependent();
3839 return NE->isInstantiationDependent();
3850 llvm_unreachable(
"should not call this with unresolved exception specs");
3876 llvm_unreachable(
"unexpected exception specification kind");
3880 for (
unsigned ArgIdx =
getNumParams(); ArgIdx; --ArgIdx)
3888 const QualType *ArgTys,
unsigned NumParams,
3889 const ExtProtoInfo &epi,
3913 ID.AddPointer(
Result.getAsOpaquePtr());
3914 for (
unsigned i = 0; i != NumParams; ++i)
3915 ID.AddPointer(ArgTys[i].getAsOpaquePtr());
3919 assert(!(
unsigned(epi.Variadic) & ~1) && !(
unsigned(epi.RefQualifier) & ~3) &&
3920 !(
unsigned(epi.ExceptionSpec.Type) & ~15) &&
3921 "Values larger than expected.");
3922 ID.AddInteger(
unsigned(epi.Variadic) + (epi.RefQualifier << 1) +
3923 (epi.ExceptionSpec.Type << 3));
3924 ID.Add(epi.TypeQuals);
3926 for (
QualType Ex : epi.ExceptionSpec.Exceptions)
3929 epi.ExceptionSpec.NoexceptExpr->Profile(ID, Context, Canonical);
3932 ID.AddPointer(epi.ExceptionSpec.SourceDecl->getCanonicalDecl());
3934 if (epi.ExtParameterInfos) {
3935 for (
unsigned i = 0; i != NumParams; ++i)
3936 ID.AddInteger(epi.ExtParameterInfos[i].getOpaqueValue());
3939 epi.ExtInfo.Profile(ID);
3940 epi.ExtraAttributeInfo.Profile(ID);
3942 unsigned EffectCount = epi.FunctionEffects.size();
3943 bool HasConds = !epi.FunctionEffects.Conditions.empty();
3945 ID.AddInteger((EffectCount << 3) | (HasConds << 2) |
3946 (epi.AArch64SMEAttributes << 1) | epi.HasTrailingReturn);
3947 ID.AddInteger(epi.CFIUncheckedCallee);
3949 for (
unsigned Idx = 0; Idx != EffectCount; ++Idx) {
3950 ID.AddInteger(epi.FunctionEffects.Effects[Idx].toOpaqueInt32());
3952 ID.AddPointer(epi.FunctionEffects.Conditions[Idx].getCondition());
3963 : Data(D, Deref << DerefShift) {}
3966 return Data.getInt() & DerefMask;
3971 return Data.getOpaqueValue();
3978 Data.setFromOpaqueValue(
V);
3985CountAttributedType::CountAttributedType(
3989 CountExpr(CountExpr) {
3993 auto *DeclSlot = getTrailingObjects();
3994 llvm::copy(CoupledDecls, DeclSlot);
4003#define ENUMERATE_ATTRS(PREFIX) \
4005 if (isCountInBytes()) { \
4007 return PREFIX "sized_by_or_null"; \
4008 return PREFIX "sized_by"; \
4011 return PREFIX "counted_by_or_null"; \
4012 return PREFIX "counted_by"; \
4015 if (WithMacroPrefix)
4020#undef ENUMERATE_ATTRS
4026 bool HasTypeDifferentFromDecl)
4028 Keyword, TC, UnderlyingType.getCanonicalType(),
4032 ~NestedNameSpecifierDependence::
Dependent)
4036 *getTrailingObjects<NestedNameSpecifier>() = Qualifier;
4037 if ((
TypedefBits.hasTypeDifferentFromDecl = HasTypeDifferentFromDecl))
4038 *getTrailingObjects<QualType>() = UnderlyingType;
4043 : *getTrailingObjects<QualType>();
4049 const Type *CanonicalType)
4055 ~NestedNameSpecifierDependence::
Dependent)
4059 *getTrailingObjects<NestedNameSpecifier>() = Qualifier;
4068 if ((
UsingBits.hasQualifier = !!Qualifier))
4069 *getTrailingObjects() = Qualifier;
4078 while (
auto *InnerMQT = dyn_cast<MacroQualifiedType>(Inner)) {
4081 Inner = InnerMQT->getModifiedType();
4092 ? Context.getUnqualifiedArrayType(Can).getAtomicUnqualifiedType()
4097 TOExpr(E), Context(Context) {
4098 TypeOfBits.Kind =
static_cast<unsigned>(Kind);
4107 ? Context.getUnqualifiedArrayType(QT).getAtomicUnqualifiedType()
4116 E->
Profile(ID, Context,
true);
4117 ID.AddBoolean(IsUnqual);
4124 ? Context.getUnqualifiedArrayType(Can).getAtomicUnqualifiedType()
4126 T->getDependence()),
4127 TOType(
T), Context(Context) {
4128 TypeOfBits.Kind =
static_cast<unsigned>(Kind);
4131QualType TypeOfType::desugar()
const {
4134 ? Context.getUnqualifiedArrayType(QT).getAtomicUnqualifiedType()
4142 :
Type(Decltype, can,
4146 (E->
getType()->getDependence() &
4148 E(E), UnderlyingType(underlyingType) {}
4150bool DecltypeType::isSugared()
const {
return !E->isInstantiationDependent(); }
4152QualType DecltypeType::desugar()
const {
4159DependentDecltypeType::DependentDecltypeType(
Expr *E)
4162void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID,
4164 E->
Profile(ID, Context,
true);
4168 Expr *IndexExpr,
bool FullySubstituted,
4170 :
Type(PackIndexing, Canonical,
4172 Pattern(Pattern), IndexExpr(IndexExpr),
Size(Expansions.size()),
4173 FullySubstituted(FullySubstituted) {
4175 llvm::uninitialized_copy(Expansions, getTrailingObjects());
4179 if (isInstantiationDependentType())
4180 return std::nullopt;
4182 ConstantExpr *CE = dyn_cast<ConstantExpr>(getIndexExpr());
4184 return std::nullopt;
4186 assert(Index.isNonNegative() &&
"Invalid index");
4187 return static_cast<unsigned>(Index.getExtValue());
4191PackIndexingType::computeDependence(
QualType Pattern,
Expr *IndexExpr,
4196 ? TypeDependence::DependentInstantiation
4197 : TypeDependence::None);
4198 if (Expansions.empty())
4199 TD |= Pattern->
getDependence() & TypeDependence::DependentInstantiation;
4202 TD |=
T->getDependence();
4204 if (!(IndexD & TypeDependence::UnexpandedPack))
4210 TD |= TypeDependence::Error | TypeDependence::DependentInstantiation;
4215void PackIndexingType::Profile(llvm::FoldingSetNodeID &ID,
4217 Profile(ID, Context, getPattern(), getIndexExpr(), isFullySubstituted(),
4221void PackIndexingType::Profile(llvm::FoldingSetNodeID &ID,
4223 Expr *E,
bool FullySubstituted,
4226 E->
Profile(ID, Context,
true);
4227 ID.AddBoolean(FullySubstituted);
4228 if (!Expansions.empty()) {
4229 ID.AddInteger(Expansions.size());
4231 T.getCanonicalType().Profile(ID);
4237UnaryTransformType::UnaryTransformType(
QualType BaseType,
4238 QualType UnderlyingType, UTTKind UKind,
4240 :
Type(UnaryTransform, CanonicalType, BaseType->getDependence()),
4241 BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind) {}
4245 bool OwnsTag,
bool ISInjected,
const Type *CanonicalType)
4252 ~NestedNameSpecifierDependence::
Dependent)
4256 getTrailingQualifier() = Qualifier;
4261void *TagType::getTrailingPointer()
const {
4262 switch (getTypeClass()) {
4267 case Type::InjectedClassName:
4268 return const_cast<InjectedClassNameType *
>(
4271 llvm_unreachable(
"unexpected type class");
4276 assert(TagTypeBits.HasQualifier);
4278 getTrailingPointer(), llvm::Align::Of<NestedNameSpecifier *>()));
4282 return TagTypeBits.HasQualifier ? getTrailingQualifier() : std::nullopt;
4286 auto *
Decl = dyn_cast<CXXRecordDecl>(
decl);
4289 if (
auto *RD = dyn_cast<ClassTemplateSpecializationDecl>(
Decl))
4290 return RD->getSpecializedTemplate();
4291 return Decl->getDescribedClassTemplate();
4295 auto *TD = getTemplateDecl();
4298 if (isCanonicalUnqualified())
4305TagType::getTemplateArgs(
const ASTContext &Ctx)
const {
4306 auto *
Decl = dyn_cast<CXXRecordDecl>(
decl);
4310 if (
auto *RD = dyn_cast<ClassTemplateSpecializationDecl>(
Decl))
4311 return RD->getTemplateArgs().asArray();
4313 return TD->getTemplateParameters()->getInjectedTemplateArgs(Ctx);
4317bool RecordType::hasConstFields()
const {
4318 std::vector<const RecordType *> RecordTypeList;
4319 RecordTypeList.push_back(
this);
4320 unsigned NextToCheckIndex = 0;
4322 while (RecordTypeList.size() > NextToCheckIndex) {
4323 for (
FieldDecl *FD : RecordTypeList[NextToCheckIndex]
4331 if (
const auto *FieldRecTy = FieldTy->
getAsCanonical<RecordType>()) {
4332 if (!llvm::is_contained(RecordTypeList, FieldRecTy))
4333 RecordTypeList.push_back(FieldRecTy);
4343 const TagDecl *TD,
bool IsInjected,
4344 const Type *CanonicalType)
4346 false, IsInjected, CanonicalType) {}
4355 :
Type(Attributed, canon, equivalent->getDependence()), Attribute(
attr),
4356 ModifiedType(modified), EquivalentType(equivalent) {
4358 assert(!attr ||
attr->getKind() == attrKind);
4361bool AttributedType::isQualifier()
const {
4363 switch (getAttrKind()) {
4368 case attr::ObjCOwnership:
4369 case attr::ObjCInertUnsafeUnretained:
4370 case attr::TypeNonNull:
4371 case attr::TypeNullable:
4372 case attr::TypeNullableResult:
4373 case attr::TypeNullUnspecified:
4374 case attr::LifetimeBound:
4375 case attr::AddressSpace:
4385bool AttributedType::isMSTypeSpec()
const {
4387 switch (getAttrKind()) {
4396 llvm_unreachable(
"invalid attr kind");
4399bool AttributedType::isWebAssemblyFuncrefSpec()
const {
4400 return getAttrKind() == attr::WebAssemblyFuncref;
4403bool AttributedType::isCallingConv()
const {
4405 switch (getAttrKind()) {
4410 case attr::FastCall:
4412 case attr::ThisCall:
4414 case attr::SwiftCall:
4415 case attr::SwiftAsyncCall:
4416 case attr::VectorCall:
4417 case attr::AArch64VectorPcs:
4418 case attr::AArch64SVEPcs:
4419 case attr::DeviceKernel:
4423 case attr::IntelOclBicc:
4424 case attr::PreserveMost:
4425 case attr::PreserveAll:
4427 case attr::PreserveNone:
4428 case attr::RISCVVectorCC:
4429 case attr::RISCVVLSCC:
4432 llvm_unreachable(
"invalid attr kind");
4436 return isCanonicalUnqualified() ?
nullptr : getDecl()->getIdentifier();
4441 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D))
4447SubstTemplateTypeParmType::SubstTemplateTypeParmType(
QualType Replacement,
4448 Decl *AssociatedDecl,
4452 :
Type(SubstTemplateTypeParm, Replacement.getCanonicalType(),
4453 Replacement->getDependence()),
4454 AssociatedDecl(AssociatedDecl) {
4455 SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType =
4456 Replacement != getCanonicalTypeInternal();
4457 if (SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType)
4458 *getTrailingObjects() = Replacement;
4460 SubstTemplateTypeParmTypeBits.Index = Index;
4461 SubstTemplateTypeParmTypeBits.Final = Final;
4462 SubstTemplateTypeParmTypeBits.PackIndex =
4464 assert(AssociatedDecl !=
nullptr);
4468SubstTemplateTypeParmType::getReplacedParameter()
const {
4469 return ::getReplacedParameter(getAssociatedDecl(),
getIndex());
4472void SubstTemplateTypeParmType::Profile(llvm::FoldingSetNodeID &ID,
4474 const Decl *AssociatedDecl,
4477 Replacement.Profile(ID);
4478 ID.AddPointer(AssociatedDecl);
4479 ID.AddInteger(Index);
4481 ID.AddBoolean(Final);
4484SubstPackType::SubstPackType(TypeClass Derived,
QualType Canon,
4486 :
Type(Derived, Canon,
4490 assert(llvm::all_of(
4492 [](
auto &P) { return P.getKind() == TemplateArgument::Type; }) &&
4493 "non-type argument to SubstPackType?");
4494 SubstPackTypeBits.NumArgs = ArgPack.
pack_size();
4501void SubstPackType::Profile(llvm::FoldingSetNodeID &ID) {
4502 Profile(ID, getArgumentPack());
4505void SubstPackType::Profile(llvm::FoldingSetNodeID &ID,
4509 ID.AddPointer(P.getAsType().getAsOpaquePtr());
4512SubstTemplateTypeParmPackType::SubstTemplateTypeParmPackType(
4513 QualType Canon,
Decl *AssociatedDecl,
unsigned Index,
bool Final,
4515 : SubstPackType(SubstTemplateTypeParmPack, Canon, ArgPack),
4516 AssociatedDeclAndFinal(AssociatedDecl, Final) {
4517 assert(AssociatedDecl !=
nullptr);
4519 SubstPackTypeBits.SubstTemplTypeParmPackIndex = Index;
4520 assert(getNumArgs() == ArgPack.
pack_size() &&
4521 "Parent bitfields in SubstPackType were overwritten."
4522 "Check NumSubstPackTypeBits.");
4525Decl *SubstTemplateTypeParmPackType::getAssociatedDecl()
const {
4526 return AssociatedDeclAndFinal.getPointer();
4529bool SubstTemplateTypeParmPackType::getFinal()
const {
4530 return AssociatedDeclAndFinal.getInt();
4534SubstTemplateTypeParmPackType::getReplacedParameter()
const {
4535 return ::getReplacedParameter(getAssociatedDecl(),
getIndex());
4538IdentifierInfo *SubstTemplateTypeParmPackType::getIdentifier()
const {
4542void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) {
4543 Profile(ID, getAssociatedDecl(),
getIndex(), getFinal(), getArgumentPack());
4546void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
4547 const Decl *AssociatedDecl,
4548 unsigned Index,
bool Final,
4550 ID.AddPointer(AssociatedDecl);
4551 ID.AddInteger(Index);
4552 ID.AddBoolean(Final);
4553 SubstPackType::Profile(ID, ArgPack);
4556SubstBuiltinTemplatePackType::SubstBuiltinTemplatePackType(
4558 : SubstPackType(SubstBuiltinTemplatePack, Canon, ArgPack) {}
4560bool TemplateSpecializationType::anyDependentTemplateArguments(
4563 return anyDependentTemplateArguments(Args.
arguments(), Converted);
4566bool TemplateSpecializationType::anyDependentTemplateArguments(
4569 if (Arg.isDependent())
4574bool TemplateSpecializationType::anyInstantiationDependentTemplateArguments(
4577 if (ArgLoc.getArgument().isInstantiationDependent())
4586 ? TypeDependence::DependentInstantiation
4591 D |= TypeDependence::UnexpandedPack;
4593 D |= (Underlying->
getDependence() & TypeDependence::UnexpandedPack);
4598TemplateSpecializationType::TemplateSpecializationType(
4602 Underlying.isNull() ?
QualType(this, 0)
4603 : Underlying.getCanonicalType(),
4606 TemplateSpecializationTypeBits.NumArgs = Args.size();
4607 TemplateSpecializationTypeBits.TypeAlias = IsAlias;
4609 auto *TemplateArgs =
4621 ~TypeDependence::Dependent);
4623 addDependence(Arg.getAsType()->getDependence() &
4624 TypeDependence::VariablyModified);
4631 *
reinterpret_cast<QualType *
>(TemplateArgs) = Underlying;
4634QualType TemplateSpecializationType::getAliasedType()
const {
4635 assert(isTypeAlias() &&
"not a type alias template specialization");
4636 return *
reinterpret_cast<const QualType *
>(template_arguments().end());
4639bool clang::TemplateSpecializationType::isSugared()
const {
4640 return !isDependentType() || isCurrentInstantiation() || isTypeAlias() ||
4645void TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
4647 Profile(ID, getKeyword(),
Template, template_arguments(),
4648 isSugared() ? desugar() :
QualType(), Ctx);
4651void TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
4657 ID.AddInteger(llvm::to_underlying(
Keyword));
4661 ID.AddInteger(Args.size());
4663 Arg.Profile(ID, Context);
4671 return Context.getQualifiedType(QT, *
this);
4675 const Type *
T)
const {
4679 return Context.getQualifiedType(
T, *
this);
4682void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID,
QualType BaseType,
4686 ID.AddPointer(BaseType.getAsOpaquePtr());
4687 ID.AddInteger(typeArgs.size());
4688 for (
auto typeArg : typeArgs)
4689 ID.AddPointer(typeArg.getAsOpaquePtr());
4690 ID.AddInteger(protocols.size());
4691 for (
auto *proto : protocols)
4692 ID.AddPointer(proto);
4693 ID.AddBoolean(isKindOf);
4696void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) {
4697 Profile(ID, getBaseType(), getTypeArgsAsWritten(),
4699 isKindOfTypeAsWritten());
4702void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID,
4706 ID.AddPointer(OTPDecl);
4708 ID.AddInteger(protocols.size());
4709 for (
auto *proto : protocols)
4710 ID.AddPointer(proto);
4713void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID) {
4714 Profile(ID, getDecl(), getCanonicalTypeInternal(),
4721class CachedProperties {
4726 CachedProperties(
Linkage L,
bool local) : L(L), local(local) {}
4728 Linkage getLinkage()
const {
return L; }
4729 bool hasLocalOrUnnamedType()
const {
return local; }
4731 friend CachedProperties merge(CachedProperties L, CachedProperties R) {
4733 return CachedProperties(MergedLinkage, L.hasLocalOrUnnamedType() ||
4734 R.hasLocalOrUnnamedType());
4753 return CachedProperties(
T->TypeBits.getLinkage(),
4754 T->TypeBits.hasLocalOrUnnamedType());
4759 if (
T->TypeBits.isCacheValid())
4764 if (!
T->isCanonicalUnqualified()) {
4765 const Type *CT =
T->getCanonicalTypeInternal().getTypePtr();
4767 T->TypeBits.CacheValid =
true;
4768 T->TypeBits.CachedLinkage = CT->
TypeBits.CachedLinkage;
4769 T->TypeBits.CachedLocalOrUnnamed = CT->
TypeBits.CachedLocalOrUnnamed;
4775 T->TypeBits.CacheValid =
true;
4776 T->TypeBits.CachedLinkage = llvm::to_underlying(
Result.getLinkage());
4777 T->TypeBits.CachedLocalOrUnnamed =
Result.hasLocalOrUnnamedType();
4795 switch (
T->getTypeClass()) {
4796#define TYPE(Class, Base)
4797#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
4798#include "clang/AST/TypeNodes.inc"
4799 llvm_unreachable(
"didn't expect a non-canonical type here");
4801#define TYPE(Class, Base)
4802#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4803#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
4804#include "clang/AST/TypeNodes.inc"
4806 assert(
T->isInstantiationDependentType());
4810 case Type::DeducedTemplateSpecialization:
4831 Linkage L = Tag->getLinkageInternal();
4832 bool IsLocalOrUnnamed = Tag->getDeclContext()->isFunctionOrMethod() ||
4833 !Tag->hasNameForLinkage();
4834 return CachedProperties(L, IsLocalOrUnnamed);
4844 case Type::BlockPointer:
4846 case Type::LValueReference:
4847 case Type::RValueReference:
4849 case Type::MemberPointer: {
4851 CachedProperties Cls = [&] {
4852 if (MPT->isSugared())
4854 return Cache::get(MPT->getQualifier().getAsType());
4856 return merge(Cls,
Cache::get(MPT->getPointeeType()));
4858 case Type::ConstantArray:
4859 case Type::IncompleteArray:
4860 case Type::VariableArray:
4861 case Type::ArrayParameter:
4864 case Type::ExtVector:
4866 case Type::ConstantMatrix:
4868 case Type::FunctionNoProto:
4870 case Type::FunctionProto: {
4872 CachedProperties result =
Cache::get(FPT->getReturnType());
4873 for (
const auto &ai : FPT->param_types())
4877 case Type::ObjCInterface: {
4879 return CachedProperties(L,
false);
4881 case Type::ObjCObject:
4883 case Type::ObjCObjectPointer:
4889 case Type::HLSLAttributedResource:
4891 case Type::HLSLInlineSpirv:
4895 llvm_unreachable(
"unhandled type class");
4906 return TypeBits.hasLocalOrUnnamedType();
4910 switch (
T->getTypeClass()) {
4911#define TYPE(Class, Base)
4912#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
4913#include "clang/AST/TypeNodes.inc"
4914 llvm_unreachable(
"didn't expect a non-canonical type here");
4916#define TYPE(Class, Base)
4917#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4918#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
4919#include "clang/AST/TypeNodes.inc"
4921 assert(
T->isInstantiationDependentType());
4929 case Type::DeducedTemplateSpecialization:
4941 case Type::BlockPointer:
4943 case Type::LValueReference:
4944 case Type::RValueReference:
4946 case Type::MemberPointer: {
4949 if (
auto *D = MPT->getMostRecentCXXRecordDecl()) {
4957 case Type::ConstantArray:
4958 case Type::IncompleteArray:
4959 case Type::VariableArray:
4960 case Type::ArrayParameter:
4963 case Type::ExtVector:
4965 case Type::ConstantMatrix:
4968 case Type::FunctionNoProto:
4970 case Type::FunctionProto: {
4973 for (
const auto &ai : FPT->param_types())
4977 case Type::ObjCInterface:
4979 case Type::ObjCObject:
4981 case Type::ObjCObjectPointer:
4988 case Type::HLSLAttributedResource:
4990 ->getContainedType()
4991 ->getCanonicalTypeInternal());
4992 case Type::HLSLInlineSpirv:
4996 llvm_unreachable(
"unhandled type class");
5010 if (!
T->isCanonicalUnqualified())
5024 while (
const auto *AT =
Type->getAs<AttributedType>()) {
5027 if (
auto Nullability = AT->getImmediateNullability())
5030 Type = AT->getEquivalentType();
5032 return std::nullopt;
5038 switch (
type->getTypeClass()) {
5039#define NON_CANONICAL_TYPE(Class, Parent) \
5042 llvm_unreachable("non-canonical type");
5043#define TYPE(Class, Parent)
5044#include "clang/AST/TypeNodes.inc"
5048 case Type::BlockPointer:
5049 case Type::MemberPointer:
5050 case Type::ObjCObjectPointer:
5054 case Type::UnresolvedUsing:
5055 case Type::TypeOfExpr:
5057 case Type::Decltype:
5058 case Type::PackIndexing:
5059 case Type::UnaryTransform:
5060 case Type::TemplateTypeParm:
5061 case Type::SubstTemplateTypeParmPack:
5062 case Type::SubstBuiltinTemplatePack:
5063 case Type::DependentName:
5065 return ResultIfUnknown;
5068 case Type::TemplateSpecialization:
5073 .getAsTemplateDecl())
5074 if (
auto *CTD = dyn_cast<ClassTemplateDecl>(templateDecl))
5075 return llvm::any_of(
5077 return RTD->getTemplatedDecl()->hasAttr<TypeNullableAttr>();
5079 return ResultIfUnknown;
5084#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
5085#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
5086#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
5087#define BUILTIN_TYPE(Id, SingletonId)
5088#include "clang/AST/BuiltinTypes.def"
5091 case BuiltinType::UnresolvedTemplate:
5093 case BuiltinType::Dependent:
5094 case BuiltinType::Overload:
5095 case BuiltinType::BoundMember:
5096 case BuiltinType::PseudoObject:
5097 case BuiltinType::UnknownAny:
5098 case BuiltinType::ARCUnbridgedCast:
5099 return ResultIfUnknown;
5101 case BuiltinType::Void:
5102 case BuiltinType::ObjCId:
5103 case BuiltinType::ObjCClass:
5104 case BuiltinType::ObjCSel:
5105#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
5106 case BuiltinType::Id:
5107#include "clang/Basic/OpenCLImageTypes.def"
5108#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
5109#include "clang/Basic/OpenCLExtensionTypes.def"
5110 case BuiltinType::OCLSampler:
5111 case BuiltinType::OCLEvent:
5112 case BuiltinType::OCLClkEvent:
5113 case BuiltinType::OCLQueue:
5114 case BuiltinType::OCLReserveID:
5115#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
5116#include "clang/Basic/AArch64ACLETypes.def"
5117#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
5118#include "clang/Basic/PPCTypes.def"
5119#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
5120#include "clang/Basic/RISCVVTypes.def"
5121#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
5122#include "clang/Basic/WebAssemblyReferenceTypes.def"
5123#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
5124#include "clang/Basic/AMDGPUTypes.def"
5125#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
5126#include "clang/Basic/HLSLIntangibleTypes.def"
5127 case BuiltinType::BuiltinFn:
5128 case BuiltinType::NullPtr:
5129 case BuiltinType::IncompleteMatrixIdx:
5130 case BuiltinType::ArraySection:
5131 case BuiltinType::OMPArrayShaping:
5132 case BuiltinType::OMPIterator:
5135 llvm_unreachable(
"unknown builtin type");
5137 case Type::Record: {
5141 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
5142 return llvm::any_of(
5143 CTSD->getSpecializedTemplate()->redecls(),
5145 return RTD->getTemplatedDecl()->hasAttr<TypeNullableAttr>();
5148 return RD->hasAttr<TypeNullableAttr>();
5154 case Type::LValueReference:
5155 case Type::RValueReference:
5156 case Type::ConstantArray:
5157 case Type::IncompleteArray:
5158 case Type::VariableArray:
5159 case Type::DependentSizedArray:
5160 case Type::DependentVector:
5161 case Type::DependentSizedExtVector:
5163 case Type::ExtVector:
5164 case Type::ConstantMatrix:
5165 case Type::DependentSizedMatrix:
5166 case Type::DependentAddressSpace:
5167 case Type::FunctionProto:
5168 case Type::FunctionNoProto:
5169 case Type::DeducedTemplateSpecialization:
5171 case Type::InjectedClassName:
5172 case Type::PackExpansion:
5173 case Type::ObjCObject:
5174 case Type::ObjCInterface:
5178 case Type::DependentBitInt:
5179 case Type::ArrayParameter:
5180 case Type::HLSLAttributedResource:
5181 case Type::HLSLInlineSpirv:
5184 llvm_unreachable(
"bad type kind!");
5187std::optional<NullabilityKind> AttributedType::getImmediateNullability()
const {
5188 if (getAttrKind() == attr::TypeNonNull)
5190 if (getAttrKind() == attr::TypeNullable)
5192 if (getAttrKind() == attr::TypeNullUnspecified)
5194 if (getAttrKind() == attr::TypeNullableResult)
5196 return std::nullopt;
5199std::optional<NullabilityKind>
5200AttributedType::stripOuterNullability(
QualType &
T) {
5202 if (
auto MacroTy = dyn_cast<MacroQualifiedType>(
T))
5203 AttrTy = MacroTy->getUnderlyingType();
5205 if (
auto attributed = dyn_cast<AttributedType>(AttrTy)) {
5206 if (
auto nullability = attributed->getImmediateNullability()) {
5207 T = attributed->getModifiedType();
5212 return std::nullopt;
5226 if (objcPtr->isObjCIdType()) {
5237 }
else if (objcPtr->isObjCQualifiedIdType()) {
5262 "cannot query implicit lifetime for non-inferrable type");
5267 while (
const auto *array = dyn_cast<ArrayType>(canon))
5268 canon = array->getElementType().getTypePtr();
5270 if (
const auto *
opt = dyn_cast<ObjCObjectPointerType>(canon)) {
5272 if (
opt->getObjectType()->isObjCClass())
5281 return typedefType->getDecl()->hasAttr<ObjCNSObjectAttr>();
5287 return typedefType->getDecl()->hasAttr<ObjCIndependentClassAttr>();
5300 return OPT->getPointeeType()->isObjCIndirectLifetimeType();
5302 return Ref->getPointeeType()->isObjCIndirectLifetimeType();
5304 return MemPtr->getPointeeType()->isObjCIndirectLifetimeType();
5312 while (
const ArrayType *array =
type->getAsArrayTypeUnsafe())
5313 type = array->getElementType().getTypePtr();
5314 return type->isObjCRetainableType();
5336 return RT->getOriginalDecl()
5337 ->getMostRecentDecl()
5338 ->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>();
5345 return RT->getOriginalDecl()
5346 ->getMostRecentDecl()
5347 ->hasAttr<CUDADeviceBuiltinTextureTypeAttr>();
5356 return ptr->getPointeeType()->hasSizedVLAType();
5358 return ref->getPointeeType()->hasSizedVLAType();
5364 return arr->getElementType()->hasSizedVLAType();
5371 return HLSLAttributedResourceType::findHandleTypeOnResource(
this) !=
nullptr;
5394 const RecordType *RT =
5400 assert(RD !=
nullptr &&
5401 "all HLSL structs and classes should be CXXRecordDecl");
5407 switch (
type.getObjCLifetime()) {
5419 if (
const auto *RD =
type->getBaseElementTypeUnsafe()->getAsRecordDecl()) {
5420 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
5422 if (CXXRD->hasDefinition() && !CXXRD->hasTrivialDestructor())
5446 Qualifier.Profile(ID);
5458 auto *RD = getCXXRecordDecl();
5465 llvm::APSInt Val,
unsigned Scale) {
5466 llvm::FixedPointSemantics FXSema(Val.getBitWidth(), Scale, Val.isSigned(),
5469 llvm::APFixedPoint(Val, FXSema).toString(Str);
5476 : DeducedType(
Auto, DeducedAsType, ExtraDependence, Canon) {
5477 AutoTypeBits.Keyword = llvm::to_underlying(
Keyword);
5478 AutoTypeBits.NumArgs = TypeConstraintArgs.size();
5479 this->TypeConstraintConcept = TypeConstraintConcept;
5480 assert(TypeConstraintConcept || AutoTypeBits.NumArgs == 0);
5481 if (TypeConstraintConcept) {
5483 addDependence(TypeDependence::DependentInstantiation);
5498void AutoType::Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context,
5503 ID.AddInteger((
unsigned)
Keyword);
5504 ID.AddBoolean(IsDependent);
5507 Arg.Profile(ID, Context);
5510void AutoType::Profile(llvm::FoldingSetNodeID &ID,
const ASTContext &Context) {
5511 Profile(ID, Context, getDeducedType(), getKeyword(), isDependentType(),
5512 getTypeConstraintConcept(), getTypeConstraintArguments());
5526 llvm_unreachable(
"unknown effect kind");
5532 return "nonblocking";
5534 return "nonallocating";
5538 return "allocating";
5540 llvm_unreachable(
"unknown effect kind");
5556 return std::nullopt;
5561 assert(0 &&
"effectProhibitingInference with non-inferable effect kind");
5564 llvm_unreachable(
"unknown effect kind");
5574 const Kind EK = Effect.kind();
5576 if (EK == CallerKind ||
5587 llvm_unreachable(
"unknown effect kind");
5599 unsigned InsertIdx = Effects.size();
5614 Errs.push_back({EC, NewEC});
5625 if (NewCondition || !Conditions.empty()) {
5626 if (Conditions.empty() && !Effects.empty())
5627 Conditions.resize(Effects.size());
5628 Conditions.insert(Conditions.begin() + InsertIdx,
5631 Effects.insert(Effects.begin() + InsertIdx, NewEC.
Effect);
5636 for (
const auto &Item :
Set)
5638 return Errs.empty();
5649 auto IterA = LHS.
begin(), EndA = LHS.
end();
5650 auto IterB = RHS.
begin(), EndB = RHS.
end();
5654 return std::tuple(LHS.Effect,
uintptr_t(LHS.Cond.getCondition())) <
5655 std::tuple(RHS.Effect,
uintptr_t(RHS.Cond.getCondition()));
5658 while (IterA != EndA && IterB != EndB) {
5663 else if (FEWCLess(B, A))
5674 assert(Errs.empty() &&
"conflict shouldn't be possible in getIntersection");
5687 Combined.
insert(RHS, Errs);
5708 llvm::interleaveComma(*
this, OS);
5718 llvm::interleaveComma(*
this, OS);
5725 assert(llvm::is_sorted(FX) &&
"effects should be sorted");
5726 assert((Conds.empty() || Conds.size() == FX.size()) &&
5727 "effects size should match conditions size");
5733 if (
Cond.getCondition() !=
nullptr)
5738const HLSLAttributedResourceType *
5739HLSLAttributedResourceType::findHandleTypeOnResource(
const Type *RT) {
5744 if (!RD->
fields().empty()) {
5745 const auto &FirstFD = RD->
fields().begin();
5746 return dyn_cast<HLSLAttributedResourceType>(
5747 FirstFD->getType().getTypePtr());
5753StringRef PredefinedSugarType::getName(Kind KD) {
5758 return "__signed_size_t";
5760 return "__ptrdiff_t";
5762 llvm_unreachable(
"unexpected kind");
Defines the clang::ASTContext interface.
Provides definitions for the various language-specific address spaces.
static std::optional< NonLoc > getIndex(ProgramStateRef State, const ElementRegion *ER, CharKind CK)
static Decl::Kind getKind(const Decl *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
static DeclT * getDefinitionOrSelf(DeclT *D)
Defines the ExceptionSpecificationType enumeration and various utility functions.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
#define CC_VLS_CASE(ABI_VLEN)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
static QualType getUnderlyingType(const SubRegion *R)
static RecordDecl * getAsRecordDecl(QualType BaseType, HeuristicResolver &Resolver)
static bool isRecordType(QualType T)
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the TargetCXXABI class, which abstracts details of the C++ ABI that we're targeting.
static TypeDependence getTemplateSpecializationTypeDependence(QualType Underlying, TemplateName T)
#define ENUMERATE_ATTRS(PREFIX)
#define SUGARED_TYPE_CLASS(Class)
static const TemplateTypeParmDecl * getReplacedParameter(Decl *D, unsigned Index)
TypePropertyCache< Private > Cache
static bool isTriviallyCopyableTypeImpl(const QualType &type, const ASTContext &Context, bool IsCopyConstructible)
static const T * getAsSugar(const Type *Cur)
This will check for a T (which should be a Type which can act as sugar, such as a TypedefType) by rem...
#define TRIVIAL_TYPE_CLASS(Class)
static CachedProperties computeCachedProperties(const Type *T)
C Language Family Type Representation.
Defines the clang::Visibility enumeration and various utility functions.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
QualType getParenType(QualType NamedType) const
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType, const Attr *attr=nullptr) const
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
QualType getArrayParameterType(QualType Ty) const
Return the uniqued reference to a specified array parameter type from the original array type.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, UnsignedOrNone PackIndex, bool Final) const
Retrieve a substitution-result type.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
QualType applyObjCProtocolQualifiers(QualType type, ArrayRef< ObjCProtocolDecl * > protocols, bool &hasError, bool allowOnPointerType=false) const
Apply Objective-C protocol qualifiers to the given type.
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
CanQualType ObjCBuiltinIdTy
IdentifierInfo * getNSObjectName() const
Retrieve the identifier 'NSObject'.
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a non-unique reference to the type for a variable array of the specified element type.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false, TemplateDecl *TypeConstraintConcept=nullptr, ArrayRef< TemplateArgument > TypeConstraintArgs={}) const
C++11 deduced auto type.
CanQualType UnsignedCharTy
TemplateName getQualifiedTemplateName(NestedNameSpecifier Qualifier, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getMemberPointerType(QualType T, NestedNameSpecifier Qualifier, const CXXRecordDecl *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
const TargetInfo & getTargetInfo() const
QualType getIncompleteArrayType(QualType EltTy, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type.
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
IdentifierInfo * getNSCopyingName()
Retrieve the identifier 'NSCopying'.
QualType getConstantArrayType(const ASTContext &Ctx) const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
ArraySizeModifier getSizeModifier() const
Qualifiers getIndexTypeQualifiers() const
QualType getElementType() const
ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm, unsigned tq, const Expr *sz=nullptr)
Attr - This represents one attribute.
BitIntType(bool isUnsigned, unsigned NumBits)
[BoundsSafety] Represents a parent type class for CountAttributedType and similar sugar types that wi...
BoundsAttributedType(TypeClass TC, QualType Wrapped, QualType Canon)
decl_range dependent_decls() const
bool referencesFieldDecls() const
This class is used for builtin types like 'int'.
StringRef getName(const PrintingPolicy &Policy) const
Represents a C++ struct/union/class.
bool isHLSLIntangible() const
Returns true if the class contains HLSL intangible type, either as a field or in base class.
bool mayBeNonDynamicClass() const
bool mayBeDynamicClass() const
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Declaration of a class template.
Complex values, per C99 6.2.5p11.
Represents the canonical version of C arrays with a specified constant size.
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
const Expr * getSizeExpr() const
Return a pointer to the size expression.
llvm::APInt getSize() const
Return the constant array size as an APInt.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
llvm::APSInt getResultAsAPSInt() const
ConstantMatrixType(QualType MatrixElementType, unsigned NRows, unsigned NColumns, QualType CanonElementType)
unsigned NumRows
Number of rows and columns.
Represents a sugar type with __counted_by or __sized_by annotations, including their _or_null variant...
void Profile(llvm::FoldingSetNodeID &ID)
StringRef getAttributeName(bool WithMacroPrefix) const
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
ASTContext & getParentASTContext() const
Decl - This represents one declaration (or definition), e.g.
bool isInStdNamespace() const
ASTContext & getASTContext() const LLVM_READONLY
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Expr * getNumBitsExpr() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
DependentBitIntType(bool IsUnsigned, Expr *NumBits)
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Expr * getCondition() const
This represents one expression.
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
ExprDependence getDependence() const
Represents a member of a struct/union/class.
A mutable set of FunctionEffect::Kind.
void dump(llvm::raw_ostream &OS) const
FunctionEffectSet()=default
bool insert(const FunctionEffectWithCondition &NewEC, Conflicts &Errs)
SmallVector< Conflict > Conflicts
static FunctionEffectSet getIntersection(FunctionEffectsRef LHS, FunctionEffectsRef RHS)
void dump(llvm::raw_ostream &OS) const
static FunctionEffectSet getUnion(FunctionEffectsRef LHS, FunctionEffectsRef RHS, Conflicts &Errs)
Kind kind() const
The kind of the effect.
Kind
Identifies the particular effect.
bool shouldDiagnoseFunctionCall(bool Direct, FunctionEffectKindSet CalleeFX) const
StringRef name() const
The description printed in diagnostics, e.g. 'nonblocking'.
Kind oppositeKind() const
Return the opposite kind, for effects which have opposites.
std::optional< FunctionEffect > effectProhibitingInference(const Decl &Callee, FunctionEffectKindSet CalleeFX) const
Determine whether the effect is allowed to be inferred on the callee, which is either a FunctionDecl ...
An immutable set of FunctionEffects and possibly conditions attached to them.
void dump(llvm::raw_ostream &OS) const
ArrayRef< FunctionEffect > effects() const
ArrayRef< EffectConditionExpr > conditions() const
static FunctionEffectsRef create(ArrayRef< FunctionEffect > FX, ArrayRef< EffectConditionExpr > Conds)
Asserts invariants.
FunctionEffectsRef()=default
bool hasDependentExceptionSpec() const
Return whether this function has a dependent exception spec.
param_type_iterator param_type_begin() const
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
bool isTemplateVariadic() const
Determines whether this function prototype contains a parameter pack at the end.
unsigned getNumParams() const
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
QualType getParamType(unsigned i) const
QualType getExceptionType(unsigned i) const
Return the ith exception type, where 0 <= i < getNumExceptions().
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
unsigned getNumExceptions() const
Return the number of types in the exception specification.
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
ExtProtoInfo getExtProtoInfo() const
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
ArrayRef< QualType > getParamTypes() const
ArrayRef< QualType > exceptions() const
bool hasInstantiationDependentExceptionSpec() const
Return whether this function has an instantiation-dependent exception spec.
A class which abstracts out some details necessary for making a call.
ExtInfo getExtInfo() const
static StringRef getNameForCallConv(CallingConv CC)
bool getCFIUncheckedCalleeAttr() const
Determine whether this is a function prototype that includes the cfi_unchecked_callee attribute.
QualType getReturnType() const
FunctionType(TypeClass tc, QualType res, QualType Canonical, TypeDependence Dependence, ExtInfo Info)
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
LinkageInfo computeTypeLinkageInfo(const Type *T)
LinkageInfo getTypeLinkageAndVisibility(const Type *T)
LinkageInfo getDeclLinkageAndVisibility(const NamedDecl *D)
static LinkageInfo external()
Linkage getLinkage() const
void merge(LinkageInfo other)
Merge both linkage and visibility.
QualType getModifiedType() const
Return this attributed type's modified type with no qualifiers attached to it.
QualType getUnderlyingType() const
const IdentifierInfo * getMacroIdentifier() const
Represents a matrix type, as defined in the Matrix Types clang extensions.
MatrixType(QualType ElementTy, QualType CanonElementTy)
QualType ElementType
The element type of the matrix.
NestedNameSpecifier getQualifier() const
void Profile(llvm::FoldingSetNodeID &ID)
CXXRecordDecl * getMostRecentCXXRecordDecl() const
Note: this can trigger extra deserialization when external AST sources are used.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier, or null.
ObjCCategoryDecl - Represents a category declaration.
ObjCInterfaceDecl * getClassInterface()
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameter list associated with this category or extension.
Represents an ObjC class declaration.
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
const ObjCObjectType * getSuperClassType() const
Retrieve the superclass type.
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Represents a pointer to an Objective C object.
const ObjCObjectPointerType * stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const
Strip off the Objective-C "kindof" type and (with it) any protocol qualifiers.
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
QualType getSuperClassType() const
Retrieve the type of the superclass of this object pointer type.
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
bool isKindOfType() const
Whether this is a "__kindof" type.
Represents an Objective-C protocol declaration.
Represents the declaration of an Objective-C type parameter.
unsigned getIndex() const
Retrieve the index into its type parameter list.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
unsigned size() const
Determine the number of type parameters in this list.
A (possibly-)qualified type.
bool hasAddressDiscriminatedPointerAuth() const
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.
QualType withFastQualifiers(unsigned TQs) 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...
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 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.
void Profile(llvm::FoldingSetNodeID &ID) const
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
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
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.
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.
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
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.
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
bool UseExcessPrecision(const ASTContext &Ctx)
PrimitiveDefaultInitializeKind isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C struct types.
void * getAsOpaquePtr() const
bool isWebAssemblyExternrefType() const
Returns true if it is a WebAssembly Externref Type.
QualType getNonPackExpansionType() const
Remove an outer pack expansion type (if any) from this type.
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.
QualType substObjCTypeArgs(ASTContext &ctx, ArrayRef< QualType > typeArgs, ObjCSubstitutionContext context) const
Substitute type arguments for the Objective-C type parameters used in the subject type.
QualType getAtomicUnqualifiedType() const
Remove all qualifiers including _Atomic.
bool hasNonTrivialObjCLifetime() const
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
@ 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.
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
A qualifier set is used to build a set of qualifiers.
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
The collection of all-type qualifiers we support.
@ 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.
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 addConsistentQualifiers(Qualifiers qs)
Add the qualifiers from the given set to this set, given that they don't conflict.
static bool isTargetAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
bool hasAddressSpace() const
unsigned getFastQualifiers() const
bool hasObjCGCAttr() const
bool hasObjCLifetime() const
ObjCLifetime getObjCLifetime() const
LangAS getAddressSpace() const
Represents a struct/union/class.
bool hasNonTrivialToPrimitiveDestructCUnion() const
bool hasNonTrivialToPrimitiveCopyCUnion() const
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
bool isNonTrivialToPrimitiveDestroy() const
bool isNonTrivialToPrimitiveCopy() const
field_range fields() const
RecordDecl * getMostRecentDecl()
bool isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C structs.
Declaration of a redeclarable template.
Encodes a location in the source.
Stmt - This represents one statement.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
void dump() const
Dumps the specified AST fragment and all subtrees to llvm::errs().
Represents the declaration of a struct/union/class/enum.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
NestedNameSpecifier getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Exposes information about the current target.
virtual bool hasFullBFloat16Type() const
Determine whether the BFloat type is fully supported on this target, i.e arithemtic operations.
virtual bool hasFastHalfType() const
Determine whether the target has fast native support for operations on half types.
virtual bool hasFloat16Type() const
Determine whether the _Float16 type is supported on this target.
virtual bool hasBFloat16Type() const
Determine whether the _BFloat16 type is supported on this target.
virtual bool isAddressSpaceSupersetOf(LangAS A, LangAS B) const
Returns true if an address space can be safely converted to another.
A convenient class for passing around template argument information.
ArrayRef< TemplateArgumentLoc > arguments() const
Location wrapper for a TemplateArgument.
Represents a template argument.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
@ Type
The template argument is a type.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Represents a C++ template name within the type system.
Declaration of a template type parameter.
[BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by a...
ValueDecl * getDecl() const
bool operator==(const TypeCoupledDeclRefInfo &Other) const
void * getOpaqueValue() const
TypeCoupledDeclRefInfo(ValueDecl *D=nullptr, bool Deref=false)
D is to a declaration referenced by the argument of attribute.
void setFromOpaqueValue(void *V)
bool isSugared() const
Returns whether this type directly provides sugar.
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 desugar() const
Remove a single level of sugar.
static void ensure(const Type *T)
static CachedProperties get(QualType T)
static CachedProperties get(const Type *T)
A helper class for Type nodes having an ElaboratedTypeKeyword.
The base class of the type hierarchy.
bool isSizelessType() const
As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.
bool isStructureType() const
bool isBlockPointerType() const
const ObjCObjectPointerType * getAsObjCQualifiedClassType() const
bool isLinkageValid() const
True if the computed linkage is valid.
TypedefBitfields TypedefBits
bool isBooleanType() const
const ObjCObjectType * getAsObjCQualifiedInterfaceType() const
const ObjCObjectPointerType * getAsObjCQualifiedIdType() const
const TemplateSpecializationType * getAsNonAliasTemplateSpecializationType() const
Look through sugar for an instance of TemplateSpecializationType which is not a type alias,...
bool isMFloat8Type() const
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
bool isPackedVectorBoolType(const ASTContext &ctx) const
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
bool isAlwaysIncompleteType() const
QualType getRVVEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an RVV builtin type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
ArrayTypeBitfields ArrayTypeBits
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
VectorTypeBitfields VectorTypeBits
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
bool isVoidPointerType() const
const ComplexType * getAsComplexIntegerType() const
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
QualType getLocallyUnqualifiedSingleStepDesugaredType() const
Pull a single level of sugar off of this locally-unqualified type.
bool isFunctionPointerType() const
bool isCountAttributedType() const
bool isObjCARCBridgableType() const
Determine whether the given type T is a "bridgable" Objective-C type, which is either an Objective-C ...
CXXRecordDecl * castAsCXXRecordDecl() const
bool isArithmeticType() const
bool isHLSLBuiltinIntangibleType() const
TypeOfBitfields TypeOfBits
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
bool isSVESizelessBuiltinType() const
Returns true for SVE scalable vector types.
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isHLSLIntangibleType() const
bool isEnumeralType() const
void addDependence(TypeDependence D)
bool isObjCNSObjectType() const
Type(TypeClass tc, QualType canon, TypeDependence Dependence)
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
NestedNameSpecifier getPrefix() const
If this type represents a qualified-id, this returns its nested name specifier.
bool isScalarType() const
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to.
bool isInterfaceType() const
bool isVariableArrayType() const
bool isSizelessBuiltinType() const
bool isCUDADeviceBuiltinSurfaceType() const
Check if the type is the CUDA device builtin surface type.
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
bool isElaboratedTypeSpecifier() const
Determine wither this type is a C++ elaborated-type-specifier.
CountAttributedTypeBitfields CountAttributedTypeBits
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
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 hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e....
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
bool isExtVectorBoolType() const
bool isWebAssemblyExternrefType() const
Check if this is a WebAssembly Externref Type.
bool canHaveNullability(bool ResultIfUnknown=true) const
Determine whether the given type can have a nullability specifier applied to it, i....
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isLValueReferenceType() const
bool isBitIntType() const
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isStructuralType() const
Determine if this type is a structural type, per C++20 [temp.param]p7.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isAggregateType() const
Determines whether the type is a C++ aggregate type or C aggregate or union type.
bool isCARCBridgableType() const
Determine whether the given type T is a "bridgeable" C type.
bool isSignableIntegerType(const ASTContext &Ctx) const
RecordDecl * castAsRecordDecl() const
bool isChar16Type() const
bool isAnyComplexType() const
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g....
QualType getCanonicalTypeInternal() const
const RecordType * getAsStructureType() const
const char * getTypeClassName() const
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
@ PtrdiffT
The "ptrdiff_t" type.
@ SizeT
The "size_t" type.
@ SignedSizeT
The signed integer type corresponding to "size_t".
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
AttributedTypeBitfields AttributedTypeBits
bool isObjCBoxableRecordType() const
bool isChar32Type() const
bool isStandardLayoutType() const
Test if this type is a standard-layout type.
TagTypeBitfields TagTypeBits
EnumDecl * castAsEnumDecl() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isComplexIntegerType() const
bool isUnscopedEnumerationType() const
bool isStdByteType() const
UnresolvedUsingBitfields UnresolvedUsingBits
bool isCUDADeviceBuiltinTextureType() const
Check if the type is the CUDA device builtin texture type.
bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const
bool isObjCClassOrClassKindOfType() const
Whether the type is Objective-C 'Class' or a __kindof type of an Class type, e.g.,...
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isHLSLResourceRecord() const
EnumDecl * getAsEnumDecl() const
Retrieves the EnumDecl this type refers to.
bool isObjCIndirectLifetimeType() const
bool hasUnnamedOrLocalType() const
Whether this type is or contains a local or unnamed type.
bool isPointerOrReferenceType() const
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
FunctionTypeBitfields FunctionTypeBits
bool isObjCQualifiedInterfaceType() const
bool isSpecifierType() const
Returns true if this type can be represented by some set of type specifiers.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isObjCObjectPointerType() const
bool isStructureTypeWithFlexibleArrayMember() const
TypeDependence getDependence() const
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
bool isStructureOrClassType() const
bool isVectorType() const
bool isRVVVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'riscv_rvv_vector_bits' type attribute,...
bool isRealFloatingType() const
Floating point categories.
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
std::optional< ArrayRef< QualType > > getObjCSubstitutions(const DeclContext *dc) const
Retrieve the set of substitutions required when accessing a member of the Objective-C receiver type t...
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
Linkage getLinkage() const
Determine the linkage of this type.
ObjCObjectTypeBitfields ObjCObjectTypeBits
bool isFloatingType() const
const ObjCObjectType * getAsObjCInterfaceType() const
bool isWideCharType() const
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
bool hasSizedVLAType() const
Whether this type involves a variable-length array type with a definite size.
TypeClass getTypeClass() const
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
bool hasAutoForTrailingReturnType() const
Determine whether this type was written with a leading 'auto' corresponding to a trailing return type...
bool isObjCIdOrObjectKindOfType(const ASTContext &ctx, const ObjCObjectType *&bound) const
Whether the type is Objective-C 'id' or a __kindof type of an object type, e.g., __kindof NSView * or...
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 isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
bool isRecordType() const
bool isHLSLResourceRecordArray() const
bool isObjCRetainableType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isObjCIndependentClassType() const
bool isSizelessVectorType() const
Returns true for all scalable vector types.
bool isScopedEnumeralType() const
Determine whether this type is a scoped enumeration type.
bool acceptsObjCTypeParams() const
Determines if this is an ObjC interface type that may accept type parameters.
QualType getSizelessVectorEltType(const ASTContext &Ctx) const
Returns the representative type for the element of a sizeless vector builtin type.
bool isUnicodeCharacterType() const
bool hasBooleanRepresentation() const
Determine whether this type has a boolean representation – i.e., it is a boolean type,...
Base class for declarations which introduce a typedef-name.
QualType getUnderlyingType() const
bool typeMatchesDecl() const
Represents a dependent using declaration which was marked with typename.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a GCC generic vector type.
VectorType(QualType vecType, unsigned nElements, QualType canonType, VectorKind vecKind)
QualType ElementType
The element type of the vector.
QualType getElementType() const
Defines the Linkage enumeration and various utility functions.
Defines the clang::TargetInfo interface.
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 ...
const internal::VariadicAllOfMatcher< Attr > attr
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
const AstTypeMatcher< TypedefType > typedefType
The JSON file list parser is used to communicate input to InstallAPI.
@ Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
bool isa(CodeGen::Address addr)
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
AutoTypeKeyword
Which keyword(s) were used to create an AutoType.
CanThrowResult
Possible results from evaluation of a noexcept expression.
TypeDependenceScope::TypeDependence TypeDependence
void initialize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
Linkage minLinkage(Linkage L1, Linkage L2)
Compute the minimum linkage given two linkages.
@ Nullable
Values of this type can be null.
@ Unspecified
Whether values of this type can be null is (explicitly) unspecified.
@ NonNull
Values of this type can never be null.
@ TemplateName
The identifier is a template name. FIXME: Add an annotation for that.
bool IsEnumDeclComplete(EnumDecl *ED)
Check if the given decl is complete.
bool isPackProducingBuiltinTemplateName(TemplateName N)
ExprDependence computeDependence(FullExpr *E)
@ Private
'private' clause, allowed on 'parallel', 'serial', 'loop', 'parallel loop', and 'serial loop' constru...
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
TypeOfKind
The kind of 'typeof' expression we're after.
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
TypeDependence toTypeDependence(ExprDependence D)
ExprDependence turnValueToTypeDependence(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.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
@ External
External linkage, which indicates that the entity can be referred to from other translation units.
ObjCSubstitutionContext
The kind of type we are substituting Objective-C type arguments into.
@ Superclass
The superclass of a type.
@ Result
The result type of a method or function.
ArraySizeModifier
Capture whether this is a normal array (e.g.
const FunctionProtoType * T
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
@ Template
We are parsing a template declaration.
TagTypeKind
The kind of a tag type.
@ Interface
The "__interface" keyword.
@ Struct
The "struct" keyword.
@ Class
The "class" keyword.
@ Union
The "union" keyword.
@ Enum
The "enum" keyword.
@ Keyword
The name has been typo-corrected to a keyword.
@ Type
The name was classified as a type.
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 isPtrSizeAddressSpace(LangAS AS)
TemplateParameterList * getReplacedTemplateParameterList(const Decl *D)
Internal helper used by Subst* nodes to retrieve the parameter list for their AssociatedDecl.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
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.
TypeDependence toSemanticDependence(TypeDependence D)
TypeDependence toSyntacticDependence(TypeDependence D)
@ Other
Other implicit parameter.
@ 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)
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e....
FunctionEffectWithCondition(FunctionEffect E, const EffectConditionExpr &C)
std::string description() const
Return a textual description of the effect, and its condition, if any.
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
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.
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
unsigned HasTrailingReturn
bool requiresFunctionProtoTypeExtraBitfields() const
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.
unsigned Bool
Whether we can use 'bool' rather than '_Bool' (even if the language doesn't actually have 'bool',...
unsigned NullptrTypeInNamespace
Whether 'nullptr_t' is in namespace 'std' or not.
unsigned Half
When true, print the half-precision floating-point type as 'half' instead of '__fp16'.
unsigned MSWChar
When true, print the built-in wchar_t type as __wchar_t.
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
const Type * Ty
The locally-unqualified type.
Qualifiers Quals
The local qualifiers.
constexpr unsigned toInternalRepresentation() const