43#include "llvm/ADT/ArrayRef.h"
44#include "llvm/ADT/STLForwardCompat.h"
45#include "llvm/ADT/SmallPtrSet.h"
46#include "llvm/ADT/SmallString.h"
47#include "llvm/ADT/StringExtras.h"
48#include "llvm/IR/DerivedTypes.h"
49#include "llvm/Support/Casting.h"
50#include "llvm/Support/ErrorHandling.h"
65 if (
D.getContext() != DeclaratorContext::BlockLiteral ||
66 D.getDeclSpec().hasTypeSpecifier())
69 if (
D.getNumTypeObjects() == 0)
72 if (
D.getNumTypeObjects() == 1 &&
84 bool useExpansionLoc =
true;
85 switch (
attr.getKind()) {
86 case ParsedAttr::AT_ObjCGC:
89 case ParsedAttr::AT_ObjCOwnership:
95 useExpansionLoc =
false;
100 StringRef name =
attr.getAttrName()->getName();
105 if (useExpansionLoc && loc.
isMacroID() && II) {
106 if (II->
isStr(
"strong")) {
108 }
else if (II->
isStr(
"weak")) {
113 S.
Diag(loc,
attr.isRegularKeywordAttribute()
114 ? diag::err_type_attribute_wrong_type
115 : diag::warn_type_attribute_wrong_type)
116 << name << WhichType <<
type;
121#define OBJC_POINTER_TYPE_ATTRS_CASELIST \
122 case ParsedAttr::AT_ObjCGC: \
123 case ParsedAttr::AT_ObjCOwnership
126#define CALLING_CONV_ATTRS_CASELIST \
127 case ParsedAttr::AT_CDecl: \
128 case ParsedAttr::AT_FastCall: \
129 case ParsedAttr::AT_StdCall: \
130 case ParsedAttr::AT_ThisCall: \
131 case ParsedAttr::AT_RegCall: \
132 case ParsedAttr::AT_Pascal: \
133 case ParsedAttr::AT_SwiftCall: \
134 case ParsedAttr::AT_SwiftAsyncCall: \
135 case ParsedAttr::AT_VectorCall: \
136 case ParsedAttr::AT_AArch64VectorPcs: \
137 case ParsedAttr::AT_AArch64SVEPcs: \
138 case ParsedAttr::AT_AMDGPUKernelCall: \
139 case ParsedAttr::AT_MSABI: \
140 case ParsedAttr::AT_SysVABI: \
141 case ParsedAttr::AT_Pcs: \
142 case ParsedAttr::AT_IntelOclBicc: \
143 case ParsedAttr::AT_PreserveMost: \
144 case ParsedAttr::AT_PreserveAll: \
145 case ParsedAttr::AT_M68kRTD: \
146 case ParsedAttr::AT_PreserveNone: \
147 case ParsedAttr::AT_RISCVVectorCC
150#define FUNCTION_TYPE_ATTRS_CASELIST \
151 case ParsedAttr::AT_NSReturnsRetained: \
152 case ParsedAttr::AT_NoReturn: \
153 case ParsedAttr::AT_NonBlocking: \
154 case ParsedAttr::AT_NonAllocating: \
155 case ParsedAttr::AT_Blocking: \
156 case ParsedAttr::AT_Allocating: \
157 case ParsedAttr::AT_Regparm: \
158 case ParsedAttr::AT_CmseNSCall: \
159 case ParsedAttr::AT_ArmStreaming: \
160 case ParsedAttr::AT_ArmStreamingCompatible: \
161 case ParsedAttr::AT_ArmPreserves: \
162 case ParsedAttr::AT_ArmIn: \
163 case ParsedAttr::AT_ArmOut: \
164 case ParsedAttr::AT_ArmInOut: \
165 case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: \
166 case ParsedAttr::AT_AnyX86NoCfCheck: \
167 CALLING_CONV_ATTRS_CASELIST
170#define MS_TYPE_ATTRS_CASELIST \
171 case ParsedAttr::AT_Ptr32: \
172 case ParsedAttr::AT_Ptr64: \
173 case ParsedAttr::AT_SPtr: \
174 case ParsedAttr::AT_UPtr
177#define NULLABILITY_TYPE_ATTRS_CASELIST \
178 case ParsedAttr::AT_TypeNonNull: \
179 case ParsedAttr::AT_TypeNullable: \
180 case ParsedAttr::AT_TypeNullableResult: \
181 case ParsedAttr::AT_TypeNullUnspecified
186 class TypeProcessingState {
210 using TypeAttrPair = std::pair<const AttributedType*, const Attr*>;
212 bool AttrsForTypesSorted =
true;
216 llvm::DenseMap<const MacroQualifiedType *, SourceLocation> LocsForMacros;
224 : sema(sema), declarator(declarator),
227 Sema &getSema()
const {
235 bool isProcessingDeclSpec()
const {
239 unsigned getCurrentChunkIndex()
const {
243 void setCurrentChunkIndex(
unsigned idx) {
249 if (isProcessingDeclSpec())
250 return getMutableDeclSpec().getAttributes();
255 void saveDeclSpecAttrs() {
257 if (!savedAttrs.empty())
260 DeclSpec &spec = getMutableDeclSpec();
261 llvm::append_range(savedAttrs,
268 ignoredTypeAttrs.push_back(&
attr);
274 for (
auto *
Attr : ignoredTypeAttrs)
284 AttrsForTypes.push_back({cast<AttributedType>(
T.getTypePtr()), A});
285 AttrsForTypesSorted =
false;
290 QualType getBTFTagAttributedType(
const BTFTypeTagAttr *BTFAttr,
302 auto *NewAttrTy = cast<AttributedType>(
T.getTypePtr());
303 for (TypeAttrPair &A : AttrsForTypes) {
304 if (A.first == AttrTy)
307 AttrsForTypesSorted =
false;
314 if (!AttrsForTypesSorted) {
315 llvm::stable_sort(AttrsForTypes, llvm::less_first());
316 AttrsForTypesSorted =
true;
321 for (
auto It = std::partition_point(
322 AttrsForTypes.begin(), AttrsForTypes.end(),
323 [=](
const TypeAttrPair &A) { return A.first < AT; });
324 It != AttrsForTypes.end() && It->first == AT; ++It) {
326 const Attr *Result = It->second;
327 It->second =
nullptr;
332 llvm_unreachable(
"no Attr* for AttributedType*");
337 auto FoundLoc = LocsForMacros.find(MQT);
338 assert(FoundLoc != LocsForMacros.end() &&
339 "Unable to find macro expansion location for MacroQualifedType");
340 return FoundLoc->second;
345 LocsForMacros[MQT] =
Loc;
348 void setParsedNoDeref(
bool parsed) { parsedNoDeref = parsed; }
350 bool didParseNoDeref()
const {
return parsedNoDeref; }
352 ~TypeProcessingState() {
353 if (savedAttrs.empty())
356 getMutableDeclSpec().getAttributes().clearListOnly();
358 getMutableDeclSpec().getAttributes().addAtEnd(AL);
362 DeclSpec &getMutableDeclSpec()
const {
404 if (
attr.getKind() == ParsedAttr::AT_ObjCGC)
406 assert(
attr.getKind() == ParsedAttr::AT_ObjCOwnership);
421 bool onlyBlockPointers) {
427 for (; i != 0; --i) {
429 switch (fnChunk.
Kind) {
445 for (--i; i != 0; --i) {
447 switch (ptrChunk.
Kind) {
457 if (onlyBlockPointers)
466 llvm_unreachable(
"bad declarator chunk kind");
472 llvm_unreachable(
"bad declarator chunk kind");
489 Declarator &declarator = state.getDeclarator();
492 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
494 switch (chunk.
Kind) {
500 if (state.isProcessingDeclSpec() &&
501 attr.getKind() == ParsedAttr::AT_ObjCOwnership)
504 if (!destChunk) destChunk = &chunk;
517 if (state.isProcessingDeclSpec() &&
518 attr.getKind() == ParsedAttr::AT_ObjCOwnership) {
545 Declarator &declarator = state.getDeclarator();
549 unsigned innermost = -1U;
550 bool considerDeclSpec =
true;
553 switch (chunk.
Kind) {
567 considerDeclSpec =
false;
575 if (considerDeclSpec) {
580 state.saveDeclSpecAttrs();
589 if (innermost != -1U) {
597 state.addIgnoredTypeAttr(
attr);
606 Declarator &declarator = state.getDeclarator();
610 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
612 switch (chunk.
Kind) {
639 Declarator &declarator = state.getDeclarator();
659 state.saveDeclSpecAttrs();
663 state,
attr, state.getCurrentAttributes(), declSpecType, CFT))
668 state.addIgnoredTypeAttr(
attr);
679 Declarator &declarator = state.getDeclarator();
689 state.addIgnoredTypeAttr(
attr);
714 if (
attr.isStandardAttributeSyntax() ||
attr.isRegularKeywordAttribute())
717 switch (
attr.getKind()) {
734 case ParsedAttr::AT_ObjCKindOf:
747 Declarator &declarator = state.getDeclarator();
793 std::nullopt, loc, loc, declarator));
808 typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc;
813 if (!(RemoveTQs & Qual.first))
817 if (TypeQuals & Qual.first)
818 S.
Diag(Qual.second, DiagID)
823 TypeQuals &= ~Qual.first;
837 if (AL.isInvalid() || !AL.isTypeAttr())
840 diag::warn_block_literal_attributes_on_omitted_return_type)
842 ToBeRemoved.push_back(&AL);
852 diag::warn_block_literal_qualifiers_on_omitted_return_type);
858static OpenCLAccessAttr::Spelling
861 if (AL.getKind() == ParsedAttr::AT_OpenCLAccess)
862 return static_cast<OpenCLAccessAttr::Spelling
>(AL.getSemanticSpelling());
863 return OpenCLAccessAttr::Keyword_read_only;
869#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait) \
871 return UnaryTransformType::Enum;
872#include "clang/Basic/TransformTypeTraits.def"
874 llvm_unreachable(
"attempted to parse a non-unary transform builtin");
888 Sema &S = state.getSema();
889 Declarator &declarator = state.getDeclarator();
909 "Unknown TSS value");
923 "Unknown TSS value");
932 "Unknown TSS value");
937 "Unknown TSS value");
942 "Unknown TSS value");
951 declarator.
getContext() == DeclaratorContext::LambdaExpr) {
955 }
else if (declarator.
getContext() == DeclaratorContext::LambdaExpr ||
970 S.
Diag(DeclLoc, diag::warn_missing_type_specifier)
979 S.
Diag(DeclLoc, diag::err_missing_type_specifier)
988 S.
Diag(DeclLoc, diag::err_missing_actual_pipe_type)
993 "implicit int is disabled?");
994 S.
Diag(DeclLoc, diag::ext_missing_type_specifier)
1004 case TypeSpecifierWidth::Unspecified:
1005 Result = Context.
IntTy;
1007 case TypeSpecifierWidth::Short:
1010 case TypeSpecifierWidth::Long:
1013 case TypeSpecifierWidth::LongLong:
1021 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1029 case TypeSpecifierWidth::Unspecified:
1032 case TypeSpecifierWidth::Short:
1035 case TypeSpecifierWidth::Long:
1038 case TypeSpecifierWidth::LongLong:
1046 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1061 if (Result.isNull()) {
1062 Result = Context.
IntTy;
1069 case TypeSpecifierWidth::Short:
1072 case TypeSpecifierWidth::Unspecified:
1075 case TypeSpecifierWidth::Long:
1078 case TypeSpecifierWidth::LongLong:
1079 llvm_unreachable(
"Unable to specify long long as _Accum width");
1092 case TypeSpecifierWidth::Short:
1095 case TypeSpecifierWidth::Unspecified:
1098 case TypeSpecifierWidth::Long:
1101 case TypeSpecifierWidth::LongLong:
1102 llvm_unreachable(
"Unable to specify long long as _Fract width");
1153 ?
"cl_khr_fp64 and __opencl_c_fp64"
1181 Result = Context.
IntTy;
1192 Result = Context.
IntTy;
1203 "No qualifiers on tag names!");
1219 "Can't handle qualifiers on typedef names yet!");
1221 if (Result.isNull()) {
1232 assert(!Result.isNull() &&
"Didn't get a type for typeof?");
1233 if (!Result->isDependentType())
1239 ? TypeOfKind::Unqualified
1240 : TypeOfKind::Qualified);
1245 assert(
E &&
"Didn't get an expression for typeof?");
1249 ? TypeOfKind::Unqualified
1250 : TypeOfKind::Qualified);
1251 if (Result.isNull()) {
1252 Result = Context.
IntTy;
1259 assert(
E &&
"Didn't get an expression for decltype?");
1262 if (Result.isNull()) {
1263 Result = Context.
IntTy;
1270 assert(
E &&
"Didn't get an expression for pack indexing");
1274 if (Result.isNull()) {
1276 Result = Context.
IntTy;
1281#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
1282#include "clang/Basic/TransformTypeTraits.def"
1284 assert(!Result.isNull() &&
"Didn't get a type for the transformation?");
1288 if (Result.isNull()) {
1289 Result = Context.
IntTy;
1297 ? AutoTypeKeyword::DecltypeAuto
1298 : AutoTypeKeyword::Auto;
1304 TypeConstraintConcept =
1305 cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl());
1310 TemplateId->NumArgs);
1312 for (
const auto &ArgLoc : TemplateArgsInfo.
arguments())
1313 TemplateArgs.push_back(ArgLoc.getArgument());
1320 TypeConstraintConcept, TemplateArgs);
1334 assert(!Result.isNull() &&
"Didn't get a type for _Atomic?");
1336 if (Result.isNull()) {
1337 Result = Context.
IntTy;
1342#define GENERIC_IMAGE_TYPE(ImgType, Id) \
1343 case DeclSpec::TST_##ImgType##_t: \
1344 switch (getImageAccess(DS.getAttributes())) { \
1345 case OpenCLAccessAttr::Keyword_write_only: \
1346 Result = Context.Id##WOTy; \
1348 case OpenCLAccessAttr::Keyword_read_write: \
1349 Result = Context.Id##RWTy; \
1351 case OpenCLAccessAttr::Keyword_read_only: \
1352 Result = Context.Id##ROTy; \
1354 case OpenCLAccessAttr::SpellingNotCalculated: \
1355 llvm_unreachable("Spelling not yet calculated"); \
1358#include "clang/Basic/OpenCLImageTypes.def"
1360#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
1361 case DeclSpec::TST_##Name: \
1362 Result = Context.SingletonId; \
1364#include "clang/Basic/HLSLIntangibleTypes.def"
1367 Result = Context.
IntTy;
1375 if (Result->containsErrors())
1380 bool IsOpenCLC30Compatible =
1389 if ((Result->isImageType() || Result->isSamplerT()) &&
1390 (IsOpenCLC30Compatible &&
1393 << 0 << Result <<
"__opencl_c_images";
1395 }
else if (Result->isOCLImage3dWOType() &&
1400 << (IsOpenCLC30Compatible
1401 ?
"cl_khr_3d_image_writes and __opencl_c_3d_image_writes"
1402 :
"cl_khr_3d_image_writes");
1422 unsigned typeSize =
static_cast<unsigned>(Context.
getTypeSize(Result));
1423 assert(typeSize > 0 &&
"type size for vector must be greater than 0 bits");
1424 VectorKind VecKind = VectorKind::AltiVecVector;
1426 VecKind = VectorKind::AltiVecPixel;
1428 VecKind = VectorKind::AltiVecBool;
1429 Result = Context.
getVectorType(Result, 128/typeSize, VecKind);
1440 if (declarator.
getContext() == DeclaratorContext::BlockLiteral)
1454 if (AL.slidesFromDeclToDeclSpecLegacyBehavior()) {
1465 if (AL.isStandardAttributeSyntax() && AL.isClangScope() &&
1466 !(AL.getKind() == ParsedAttr::AT_MatrixType &&
1468 S.
Diag(AL.getLoc(), diag::warn_type_attribute_deprecated_on_decl)
1494 if (Result->isFunctionType()) {
1498 ? diag::warn_typecheck_function_qualifiers_ignored
1499 : diag::warn_typecheck_function_qualifiers_unspecified);
1512 if (TypeQuals && Result->isReferenceType()) {
1514 S, DS, TypeQuals, Result,
1516 diag::warn_typecheck_reference_qualifiers);
1523 && TypeQuals & Result.getCVRQualifiers()) {
1547 assert(!Result.isNull() &&
"This function should not return a null type");
1562 const auto *AT = dyn_cast<AutoType>(
T);
1563 return AT && AT->isGNUAutoType();
1580 unsigned DiagID = 0;
1596 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
1603 DiagID = diag::err_typecheck_invalid_restrict_not_pointer;
1617 unsigned CVRAU,
const DeclSpec *DS) {
1651 Split.Quals.addCVRQualifiers(CVR);
1669 if (!
type->isObjCLifetimeType() ||
1679 if (
type.isConstQualified()) {
1685 }
else if (
type->isObjCARCImplicitlyUnretainedType()) {
1703 diag::err_arc_indirect_no_ownership,
type, isReference));
1705 S.
Diag(loc, diag::err_arc_indirect_no_ownership) <<
type << isReference;
1709 assert(implicitLifetime &&
"didn't infer any lifetime!");
1750enum QualifiedFunctionKind { QFK_BlockPointer, QFK_Pointer, QFK_Reference };
1756 QualifiedFunctionKind QFK) {
1763 S.
Diag(
Loc, diag::err_compound_qualified_function_type)
1764 << QFK << isa<FunctionType>(
T.IgnoreParens()) <<
T
1775 Diag(
Loc, diag::err_qualified_function_typeid)
1794 Diag(
Loc, diag::err_illegal_decl_pointer_to_reference)
1802 Diag(
Loc, diag::err_opencl_function_pointer) << 0;
1807 Diag(
Loc, diag::err_hlsl_pointers_unsupported) << 0;
1826 if (
T.isWebAssemblyReferenceType()) {
1827 Diag(
Loc, diag::err_wasm_reference_pr) << 0;
1833 Diag(
Loc, diag::err_wasm_table_pr) << 0;
1846 "Unresolved overloaded function type");
1874 Diag(
Loc, diag::err_reference_to_void);
1879 Diag(
Loc, diag::err_hlsl_pointers_unsupported) << 1;
1889 Diag(
Loc, diag::err_opencl_function_pointer) << 1;
1902 T.isWebAssemblyReferenceType()) {
1903 Diag(
Loc, diag::err_wasm_reference_pr) << 1;
1907 Diag(
Loc, diag::err_wasm_table_pr) << 1;
1930 llvm::APSInt Bits(32);
1937 size_t NumBits = Bits.getZExtValue();
1938 if (!IsUnsigned && NumBits < 2) {
1939 Diag(
Loc, diag::err_bit_int_bad_size) << 0;
1943 if (IsUnsigned && NumBits < 1) {
1944 Diag(
Loc, diag::err_bit_int_bad_size) << 1;
1950 Diag(
Loc, diag::err_bit_int_max_size)
1964 llvm::APSInt &SizeVal,
unsigned VLADiag,
1989 VLADiagnoser(
unsigned VLADiag,
bool VLAIsError)
1990 : VLADiag(VLADiag), VLAIsError(VLAIsError) {}
1994 return S.
Diag(
Loc, diag::err_array_size_non_int) <<
T;
1999 IsVLA = !VLAIsError;
2005 return S.
Diag(
Loc, diag::ext_vla_folded_to_constant);
2007 } Diagnoser(VLADiag, VLAIsError);
2011 if (Diagnoser.IsVLA)
2025 if (Size.isMultipleOf(Alignment))
2028 Diag(
Loc, diag::err_array_element_alignment)
2029 << EltTy << Size.getQuantity() << Alignment.
getQuantity();
2034 Expr *ArraySize,
unsigned Quals,
2051 Diag(
Loc, diag::err_illegal_decl_array_of_references)
2057 Diag(
Loc, diag::err_array_incomplete_or_sizeless_type) << 0 <<
T;
2062 diag::err_array_of_abstract_type))
2069 if (!MPTy->getClass()->isDependentType())
2075 if (!
T.isWebAssemblyReferenceType() &&
2077 diag::err_array_incomplete_or_sizeless_type))
2083 const auto *ATy = dyn_cast<ArrayType>(
T);
2084 if (ATy && ATy->getElementType().isWebAssemblyReferenceType()) {
2085 Diag(
Loc, diag::err_wasm_reftype_multidimensional_array);
2091 Diag(
Loc, diag::err_array_incomplete_or_sizeless_type) << 1 <<
T;
2096 Diag(
Loc, diag::err_illegal_decl_array_of_functions)
2104 if (EltTy->getDecl()->hasFlexibleArrayMember())
2105 Diag(
Loc, diag::ext_flexible_array_in_array) <<
T;
2107 Diag(
Loc, diag::err_objc_array_of_interfaces) <<
T;
2118 ArraySize =
Result.get();
2122 if (ArraySize && !ArraySize->
isPRValue()) {
2127 ArraySize =
Result.get();
2150 if (
const auto *CondExpr = dyn_cast_if_present<ConditionalOperator>(
2152 std::optional<llvm::APSInt> LHS =
2153 CondExpr->getLHS()->getIntegerConstantExpr(
Context);
2154 std::optional<llvm::APSInt> RHS =
2155 CondExpr->getRHS()->getIntegerConstantExpr(
Context);
2156 return LHS && RHS && LHS->isNegative() != RHS->isNegative();
2166 VLADiag = diag::err_opencl_vla;
2169 VLADiag = diag::warn_vla_used;
2172 VLADiag = diag::err_vla_in_sfinae;
2175 VLADiag = diag::err_openmp_vla_in_task_untied;
2180 ? diag::ext_vla_cxx_in_gnu_mode_static_assert
2181 : diag::ext_vla_cxx_static_assert;
2183 VLADiag =
getLangOpts().GNUMode ? diag::ext_vla_cxx_in_gnu_mode
2184 : diag::ext_vla_cxx;
2187 VLADiag = diag::ext_vla;
2228 if (ConstVal.isSigned() && ConstVal.isNegative()) {
2235 diag::err_typecheck_negative_array_size)
2239 if (ConstVal == 0 && !
T.isWebAssemblyReferenceType()) {
2244 : diag::ext_typecheck_zero_array_size)
2249 unsigned ActiveSizeBits =
2253 : ConstVal.getActiveBits();
2269 IsCUDADevice ? diag::err_cuda_vla : diag::err_vla_unsupported)
2270 << (IsCUDADevice ? llvm::to_underlying(
CUDA().CurrentTarget()) : 0);
2274 FSI->setHasVLA(
Loc);
2282 : diag::ext_c99_array_usage)
2283 << llvm::to_underlying(ASM);
2293 Diag(
Loc, diag::err_opencl_invalid_type_array) << ArrType;
2310 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << CurType;
2315 unsigned NumBits = BIT->getNumBits();
2316 if (!llvm::isPowerOf2_32(NumBits) || NumBits < 8) {
2317 Diag(AttrLoc, diag::err_attribute_invalid_bitint_vector_type)
2327 std::optional<llvm::APSInt> VecSize =
2330 Diag(AttrLoc, diag::err_attribute_argument_type)
2341 if (!VecSize->isIntN(61)) {
2343 Diag(AttrLoc, diag::err_attribute_size_too_large)
2347 uint64_t VectorSizeBits = VecSize->getZExtValue() * 8;
2350 if (VectorSizeBits == 0) {
2351 Diag(AttrLoc, diag::err_attribute_zero_size)
2356 if (!TypeSize || VectorSizeBits % TypeSize) {
2357 Diag(AttrLoc, diag::err_attribute_invalid_size)
2362 if (VectorSizeBits / TypeSize > std::numeric_limits<uint32_t>::max()) {
2363 Diag(AttrLoc, diag::err_attribute_size_too_large)
2387 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) <<
T;
2394 if (!llvm::isPowerOf2_32(NumBits) || NumBits < 8) {
2395 Diag(AttrLoc, diag::err_attribute_invalid_bitint_vector_type)
2402 std::optional<llvm::APSInt> vecSize =
2405 Diag(AttrLoc, diag::err_attribute_argument_type)
2411 if (!vecSize->isIntN(32)) {
2412 Diag(AttrLoc, diag::err_attribute_size_too_large)
2418 unsigned vectorSize =
static_cast<unsigned>(vecSize->getZExtValue());
2420 if (vectorSize == 0) {
2421 Diag(AttrLoc, diag::err_attribute_zero_size)
2435 "Should never build a matrix type when it is disabled");
2440 Diag(AttrLoc, diag::err_attribute_invalid_matrix_type) << ElementTy;
2449 std::optional<llvm::APSInt> ValueRows =
2451 std::optional<llvm::APSInt> ValueColumns =
2458 if (!ValueRows && !ValueColumns) {
2459 Diag(AttrLoc, diag::err_attribute_argument_type)
2467 Diag(AttrLoc, diag::err_attribute_argument_type)
2473 if (!ValueColumns) {
2474 Diag(AttrLoc, diag::err_attribute_argument_type)
2480 unsigned MatrixRows =
static_cast<unsigned>(ValueRows->getZExtValue());
2481 unsigned MatrixColumns =
static_cast<unsigned>(ValueColumns->getZExtValue());
2482 if (MatrixRows == 0 && MatrixColumns == 0) {
2483 Diag(AttrLoc, diag::err_attribute_zero_size)
2484 <<
"matrix" << RowRange << ColRange;
2487 if (MatrixRows == 0) {
2488 Diag(AttrLoc, diag::err_attribute_zero_size) <<
"matrix" << RowRange;
2491 if (MatrixColumns == 0) {
2492 Diag(AttrLoc, diag::err_attribute_zero_size) <<
"matrix" << ColRange;
2496 Diag(AttrLoc, diag::err_attribute_size_too_large)
2497 << RowRange <<
"matrix row";
2501 Diag(AttrLoc, diag::err_attribute_size_too_large)
2502 << ColRange <<
"matrix column";
2510 Diag(
Loc, diag::err_func_returning_array_function)
2518 Diag(
Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 <<
2526 Diag(
Loc, diag::err_object_cannot_be_passed_returned_by_value)
2531 if (
T.hasNonTrivialToPrimitiveDestructCUnion() ||
2532 T.hasNonTrivialToPrimitiveCopyCUnion())
2539 Diag(
Loc, diag::warn_deprecated_volatile_return) <<
T;
2554 bool emittedError =
false;
2556 enum class RequiredCC { OnlySwift, SwiftOrSwiftAsync };
2557 auto checkCompatible = [&](
unsigned paramIndex, RequiredCC required) {
2559 (required == RequiredCC::OnlySwift)
2562 if (isCompatible || emittedError)
2564 S.
Diag(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall)
2566 << (required == RequiredCC::OnlySwift);
2567 emittedError =
true;
2569 for (
size_t paramIndex = 0, numParams = paramTypes.size();
2570 paramIndex != numParams; ++paramIndex) {
2579 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
2580 if (paramIndex != 0 &&
2583 S.
Diag(getParamLoc(paramIndex),
2584 diag::err_swift_indirect_result_not_first);
2589 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
2598 checkCompatible(paramIndex, RequiredCC::OnlySwift);
2599 if (paramIndex == 0 ||
2602 S.
Diag(getParamLoc(paramIndex),
2603 diag::err_swift_error_result_not_after_swift_context);
2607 llvm_unreachable(
"bad ABI kind");
2619 for (
unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) {
2623 Diag(
Loc, diag::err_param_with_void_type);
2628 Diag(
Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<
2632 Diag(
Loc, diag::err_wasm_table_as_function_parameter);
2639 Diag(
Loc, diag::warn_deprecated_volatile_param) << ParamType;
2641 ParamTypes[Idx] = ParamType;
2646 [=](
unsigned i) {
return Loc; });
2666 Diag(
Loc, diag::err_distant_exception_spec);
2673 Diag(
Loc, diag::err_illegal_decl_mempointer_to_reference)
2679 Diag(
Loc, diag::err_illegal_decl_mempointer_to_void)
2684 if (!
Class->isDependentType() && !
Class->isRecordType()) {
2685 Diag(
Loc, diag::err_mempointer_in_nonclass_type) <<
Class;
2692 Diag(
Loc, diag::err_opencl_function_pointer) << 0;
2697 Diag(
Loc, diag::err_hlsl_pointers_unsupported) << 0;
2716 Diag(
Loc, diag::err_nonfunction_block_type);
2732 if (TInfo) *TInfo =
nullptr;
2737 if (
const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
2738 QT = LIT->getType();
2739 DI = LIT->getTypeSourceInfo();
2742 if (TInfo) *TInfo = DI;
2748 unsigned chunkIndex);
2755 Sema &S = state.getSema();
2756 Declarator &declarator = state.getDeclarator();
2762 unsigned outermostPointerIndex = 0;
2764 unsigned numPointers = 0;
2766 unsigned chunkIndex = i;
2768 switch (chunk.
Kind) {
2778 outermostPointerIndex = chunkIndex;
2786 if (numPointers != 1)
return;
2788 outermostPointerIndex = chunkIndex;
2806 if (numPointers == 1) {
2824 }
else if (numPointers == 2) {
2837 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership)
2841 outermostPointerIndex);
2863 }
const QualKinds[5] = {
2872 unsigned NumQuals = 0;
2877 for (
auto &
E : QualKinds) {
2878 if (Quals &
E.Mask) {
2879 if (!QualStr.empty()) QualStr +=
' ';
2896 << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];
2902 unsigned FunctionChunkIndex) {
2904 D.getTypeObject(FunctionChunkIndex).Fun;
2912 for (
unsigned OuterChunkIndex = FunctionChunkIndex + 1,
2913 End =
D.getNumTypeObjects();
2914 OuterChunkIndex != End; ++OuterChunkIndex) {
2916 switch (OuterChunk.
Kind) {
2923 diag::warn_qual_return_type,
2945 D.getIdentifierLoc());
2949 llvm_unreachable(
"unknown declarator chunk kind");
2961 D.getDeclSpec().getTypeQualifiers(),
2962 D.getIdentifierLoc(),
2963 D.getDeclSpec().getConstSpecLoc(),
2964 D.getDeclSpec().getVolatileSpecLoc(),
2965 D.getDeclSpec().getRestrictSpecLoc(),
2966 D.getDeclSpec().getAtomicSpecLoc(),
2967 D.getDeclSpec().getUnalignedSpecLoc());
2970static std::pair<QualType, TypeSourceInfo *>
2974 Sema &S = state.getSema();
2978 const unsigned AutoParameterPosition = Info.
TemplateParams.size();
2979 const bool IsParameterPack =
D.hasEllipsis();
2990 D.getDeclSpec().getTypeSpecTypeLoc(),
2991 D.getIdentifierLoc(),
2992 TemplateParameterDepth, AutoParameterPosition,
2994 D.getIdentifier(), AutoParameterPosition),
false,
2995 IsParameterPack,
Auto->isConstrained());
3000 if (
Auto->isConstrained()) {
3007 for (
unsigned Idx = 0; Idx < AutoLoc.
getNumArgs(); ++Idx) {
3008 if (
D.getEllipsisLoc().isInvalid() && !
Invalid &&
3020 InventedTemplateParam,
D.getEllipsisLoc());
3034 if (
D.getEllipsisLoc().isInvalid()) {
3050 D.getDeclSpec().getTypeSpecScope().getWithLocInContext(S.
Context),
3055 USD ? cast<NamedDecl>(USD) : CD,
3057 InventedTemplateParam,
D.getEllipsisLoc());
3067 QualType NewT = state.ReplaceAutoType(
T, Replacement);
3071 return {NewT, NewTSI};
3080 Sema &SemaRef = state.getSema();
3083 ReturnTypeInfo =
nullptr;
3086 TagDecl *OwnedTagDecl =
nullptr;
3096 if (!
D.isInvalidType() &&
D.getDeclSpec().isTypeSpecOwned()) {
3097 OwnedTagDecl = cast<TagDecl>(
D.getDeclSpec().getRepAsDecl());
3110 D.getMutableDeclSpec().getAttributes());
3137 bool DeducedIsTrailingReturnType =
false;
3138 if (Deduced && isa<AutoType>(Deduced) &&
D.hasTrailingReturnType()) {
3141 DeducedIsTrailingReturnType =
true;
3151 bool IsCXXAutoType =
3153 bool IsDeducedReturnType =
false;
3155 switch (
D.getContext()) {
3194 assert(Info &&
"No LambdaScopeInfo on the stack!");
3200 if (!DeducedIsTrailingReturnType)
3205 if (
D.isStaticMember() ||
D.isFunctionDeclarator())
3208 if (isa<ObjCContainerDecl>(SemaRef.
CurContext)) {
3211 switch (cast<TagDecl>(SemaRef.
CurContext)->getTagKind()) {
3213 llvm_unreachable(
"unhandled tag kind");
3215 Error = Cxx ? 1 : 2;
3218 Error = Cxx ? 3 : 4;
3228 if (
D.getDeclSpec().isFriendSpecified())
3237 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
3249 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
3250 !
D.getNumTypeObjects() &&
3263 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3265 IsDeducedReturnType =
true;
3268 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3270 IsDeducedReturnType =
true;
3273 if (isa<DeducedTemplateSpecializationType>(Deduced))
3275 if (SemaRef.
getLangOpts().CPlusPlus23 && IsCXXAutoType &&
3276 !
Auto->isDecltypeAuto())
3295 if (!IsCXXAutoType && !isa<DeducedTemplateSpecializationType>(Deduced))
3308 if (
D.isFunctionDeclarator() &&
3309 (!SemaRef.
getLangOpts().CPlusPlus11 || !IsCXXAutoType))
3312 SourceRange AutoRange =
D.getDeclSpec().getTypeSpecTypeLoc();
3319 switch (
Auto->getKeyword()) {
3325 assert(isa<DeducedTemplateSpecializationType>(Deduced) &&
3326 "unknown auto type");
3330 auto *DTST = dyn_cast<DeducedTemplateSpecializationType>(Deduced);
3333 SemaRef.
Diag(AutoRange.
getBegin(), diag::err_auto_not_allowed)
3335 <<
QualType(Deduced, 0) << AutoRange;
3340 D.setInvalidType(
true);
3346 ? diag::warn_cxx11_compat_generic_lambda
3347 : IsDeducedReturnType
3348 ? diag::warn_cxx11_compat_deduced_return_type
3349 : diag::warn_cxx98_compat_auto_type_specifier)
3358 unsigned DiagID = 0;
3359 switch (
D.getContext()) {
3364 llvm_unreachable(
"parser should not have allowed this");
3380 DiagID = diag::err_type_defined_in_alias_template;
3392 DiagID = diag::err_type_defined_in_type_specifier;
3402 DiagID = diag::err_type_defined_in_param_type;
3408 DiagID = diag::err_type_defined_in_condition;
3415 D.setInvalidType(
true);
3419 assert(!
T.isNull() &&
"This function should not return a null type");
3428 assert(FTI.
isAmbiguous &&
"no direct-initializer / function ambiguity");
3444 if (!
D.isFunctionDeclarator() ||
3458 FTI.
NumParams ? diag::warn_parens_disambiguated_as_function_declaration
3459 : diag::warn_empty_parens_are_function_decl)
3467 if (!
D.isFirstDeclarator() &&
D.getIdentifier()) {
3470 if (Comma.getFileID() != Name.getFileID() ||
3471 Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) {
3475 S.
Diag(
D.getCommaLoc(), diag::note_empty_parens_function_call)
3477 <<
D.getIdentifier();
3478 Result.suppressDiagnostics();
3491 S.
Diag(B, diag::note_additional_parens_for_variable_declaration)
3506 S.
Diag(DeclType.
Loc, diag::note_empty_parens_default_ctor)
3514 S.
Diag(DeclType.
Loc, diag::note_empty_parens_zero_initialize)
3525 "do not have redundant top-level parentheses");
3534 bool CouldBeTemporaryObject =
3535 S.
getLangOpts().CPlusPlus &&
D.isExpressionContext() &&
3536 !
D.isInvalidType() &&
D.getIdentifier() &&
3539 D.getDeclSpec().getTypeQualifiers() == 0 &&
D.isFirstDeclarator();
3541 bool StartsWithDeclaratorId =
true;
3542 for (
auto &
C :
D.type_objects()) {
3549 StartsWithDeclaratorId =
false;
3554 CouldBeTemporaryObject =
false;
3562 CouldBeTemporaryObject =
false;
3563 StartsWithDeclaratorId =
false;
3573 CouldBeTemporaryObject =
false;
3580 CouldBeTemporaryObject =
false;
3581 StartsWithDeclaratorId =
false;
3591 if (CouldBeTemporaryObject) {
3595 CouldBeTemporaryObject =
false;
3596 Result.suppressDiagnostics();
3601 if (!CouldBeTemporaryObject) {
3606 if (StartsWithDeclaratorId &&
D.getCXXScopeSpec().isValid()) {
3608 NNS = NNS->getPrefix()) {
3614 S.
Diag(
Paren.Loc, diag::warn_redundant_parens_around_declarator)
3620 S.
Diag(
Paren.Loc, diag::warn_parens_disambiguated_as_variable_declaration)
3621 << ParenRange <<
D.getIdentifier();
3623 if (!RD || !RD->hasDefinition() || RD->hasNonTrivialDestructor())
3624 S.
Diag(
Paren.Loc, diag::note_raii_guard_add_name)
3626 <<
D.getIdentifier();
3632 S.
Diag(
Paren.Loc, diag::note_remove_parens_for_variable_declaration)
3648 switch (AL.getKind()) {
3667 bool IsCXXInstanceMethod =
false;
3673 unsigned I = ChunkIndex;
3674 bool FoundNonParen =
false;
3675 while (I && !FoundNonParen) {
3678 FoundNonParen =
true;
3681 if (FoundNonParen) {
3684 IsCXXInstanceMethod =
3689 IsCXXInstanceMethod =
3693 assert(
D.isFunctionDeclarator());
3697 IsCXXInstanceMethod =
3698 D.isFirstDeclarationOfMember() &&
3700 !
D.isStaticMember();
3705 IsCXXInstanceMethod);
3712 for (
const ParsedAttr &AL :
D.getDeclSpec().getAttributes()) {
3713 if (AL.getKind() == ParsedAttr::AT_OpenCLKernel) {
3723 if (Triple.getArch() == llvm::Triple::spirv32 ||
3724 Triple.getArch() == llvm::Triple::spirv64) {
3725 for (
const ParsedAttr &AL :
D.getDeclSpec().getAttributes()) {
3726 if (AL.getKind() == ParsedAttr::AT_CUDAGlobal) {
3740 enum class SimplePointerKind {
3749 switch (nullability) {
3751 if (!Ident__Nonnull)
3753 return Ident__Nonnull;
3756 if (!Ident__Nullable)
3758 return Ident__Nullable;
3761 if (!Ident__Nullable_result)
3763 return Ident__Nullable_result;
3766 if (!Ident__Null_unspecified)
3768 return Ident__Null_unspecified;
3770 llvm_unreachable(
"Unknown nullability kind.");
3777 if (AL.getKind() == ParsedAttr::AT_TypeNonNull ||
3778 AL.getKind() == ParsedAttr::AT_TypeNullable ||
3779 AL.getKind() == ParsedAttr::AT_TypeNullableResult ||
3780 AL.getKind() == ParsedAttr::AT_TypeNullUnspecified)
3789 enum class PointerDeclaratorKind {
3797 MaybePointerToCFRef,
3801 NSErrorPointerPointer,
3807 enum class PointerWrappingDeclaratorKind {
3821static PointerDeclaratorKind
3823 PointerWrappingDeclaratorKind &wrappingKind) {
3824 unsigned numNormalPointers = 0;
3827 if (
type->isDependentType())
3828 return PointerDeclaratorKind::NonPointer;
3833 switch (chunk.
Kind) {
3835 if (numNormalPointers == 0)
3836 wrappingKind = PointerWrappingDeclaratorKind::Array;
3845 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3846 : PointerDeclaratorKind::SingleLevelPointer;
3852 if (numNormalPointers == 0)
3853 wrappingKind = PointerWrappingDeclaratorKind::Reference;
3857 ++numNormalPointers;
3858 if (numNormalPointers > 2)
3859 return PointerDeclaratorKind::MultiLevelPointer;
3865 unsigned numTypeSpecifierPointers = 0;
3869 ++numNormalPointers;
3871 if (numNormalPointers > 2)
3872 return PointerDeclaratorKind::MultiLevelPointer;
3874 type = ptrType->getPointeeType();
3875 ++numTypeSpecifierPointers;
3881 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3882 : PointerDeclaratorKind::SingleLevelPointer;
3887 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3888 : PointerDeclaratorKind::SingleLevelPointer;
3893 ++numNormalPointers;
3894 ++numTypeSpecifierPointers;
3897 if (
auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) {
3899 numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3900 return PointerDeclaratorKind::NSErrorPointerPointer;
3909 if (objcClass->getInterface()->getIdentifier() ==
3911 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2)
3912 return PointerDeclaratorKind::NSErrorPointerPointer;
3919 if (numNormalPointers == 0)
3920 return PointerDeclaratorKind::NonPointer;
3926 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2 &&
3928 return PointerDeclaratorKind::CFErrorRefPointer;
3936 switch (numNormalPointers) {
3938 return PointerDeclaratorKind::NonPointer;
3941 return PointerDeclaratorKind::SingleLevelPointer;
3944 return PointerDeclaratorKind::MaybePointerToCFRef;
3947 return PointerDeclaratorKind::MultiLevelPointer;
3956 if (ctx->isFunctionOrMethod())
3959 if (ctx->isFileContext())
3970 bool invalid =
false;
3972 if (invalid || !sloc.
isFile())
3990template <
typename DiagBuilderT>
3999 if (!FixItLoc.
isValid() || FixItLoc == PointerLoc)
4008 InsertionTextBuf +=
" ";
4009 StringRef InsertionText = InsertionTextBuf.str();
4012 InsertionText = InsertionText.drop_back();
4013 }
else if (NextChar[-1] ==
'[') {
4014 if (NextChar[0] ==
']')
4015 InsertionText = InsertionText.drop_back().drop_front();
4017 InsertionText = InsertionText.drop_front();
4020 InsertionText = InsertionText.drop_back().drop_front();
4027 SimplePointerKind PointerKind,
4032 if (PointerKind == SimplePointerKind::Array) {
4033 S.
Diag(PointerLoc, diag::warn_nullability_missing_array);
4035 S.
Diag(PointerLoc, diag::warn_nullability_missing)
4036 <<
static_cast<unsigned>(PointerKind);
4039 auto FixItLoc = PointerEndLoc.
isValid() ? PointerEndLoc : PointerLoc;
4040 if (FixItLoc.isMacroID())
4044 auto Diag = S.
Diag(FixItLoc, diag::note_nullability_fix_it);
4045 Diag << static_cast<unsigned>(Nullability);
4046 Diag << static_cast<unsigned>(PointerKind);
4075 if (pointerKind == SimplePointerKind::Array)
4076 diagKind = diag::warn_nullability_missing_array;
4078 diagKind = diag::warn_nullability_missing;
4084 fileNullability.
PointerKind =
static_cast<unsigned>(pointerKind);
4116 auto kind =
static_cast<SimplePointerKind
>(fileNullability.
PointerKind);
4131 unsigned i = endIndex;
4159template<
typename AttrT>
4162 return ::new (Ctx) AttrT(Ctx, AL);
4169 return createSimpleAttr<TypeNonNullAttr>(Ctx,
Attr);
4172 return createSimpleAttr<TypeNullableAttr>(Ctx,
Attr);
4175 return createSimpleAttr<TypeNullableResultAttr>(Ctx,
Attr);
4178 return createSimpleAttr<TypeNullUnspecifiedAttr>(Ctx,
Attr);
4180 llvm_unreachable(
"unknown NullabilityKind");
4191 if (ASOld != ASNew) {
4192 S.
Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
4197 diag::warn_attribute_address_multiple_identical_qualifiers);
4211 !isa<RecordType, TemplateSpecializationType>(
4222 Sema &S = state.getSema();
4228 if (
D.getIdentifier())
4229 Name =
D.getIdentifier();
4232 bool IsTypedefName =
4248 bool IsClassTemplateDeduction = isa<DeducedTemplateSpecializationType>(DT);
4250 for (
unsigned I = 0,
E =
D.getNumTypeObjects(); I !=
E; ++I) {
4251 unsigned Index =
E - I - 1;
4253 unsigned DiagId = IsClassTemplateDeduction
4254 ? diag::err_deduced_class_template_compound_type
4255 : diag::err_decltype_auto_compound_type;
4256 unsigned DiagKind = 0;
4257 switch (DeclChunk.
Kind) {
4260 if (IsClassTemplateDeduction) {
4266 if (IsClassTemplateDeduction) {
4271 if (
D.isFunctionDeclarationContext() &&
4272 D.isFunctionDeclarator(FnIndex) && FnIndex == Index)
4274 DiagId = diag::err_decltype_auto_function_declarator_not_declaration;
4292 S.
Diag(DeclChunk.
Loc, DiagId) << DiagKind;
4293 D.setInvalidType(
true);
4300 std::optional<NullabilityKind> inferNullability;
4301 bool inferNullabilityCS =
false;
4302 bool inferNullabilityInnerOnly =
false;
4303 bool inferNullabilityInnerOnlyComplete =
false;
4306 bool inAssumeNonNullRegion =
false;
4308 if (assumeNonNullLoc.
isValid()) {
4309 inAssumeNonNullRegion =
true;
4323 } complainAboutMissingNullability = CAMN_No;
4324 unsigned NumPointersRemaining = 0;
4325 auto complainAboutInferringWithinChunk = PointerWrappingDeclaratorKind::None;
4327 if (IsTypedefName) {
4331 complainAboutMissingNullability = CAMN_InnerPointers;
4335 ++NumPointersRemaining;
4338 for (
unsigned i = 0, n =
D.getNumTypeObjects(); i != n; ++i) {
4340 switch (chunk.
Kind) {
4348 ++NumPointersRemaining;
4356 ++NumPointersRemaining;
4361 bool isFunctionOrMethod =
false;
4362 switch (
auto context = state.getDeclarator().getContext()) {
4368 isFunctionOrMethod =
true;
4372 if (state.getDeclarator().isObjCIvar() && !isFunctionOrMethod) {
4373 complainAboutMissingNullability = CAMN_No;
4378 if (state.getDeclarator().isObjCWeakProperty()) {
4381 complainAboutMissingNullability = CAMN_No;
4382 if (inAssumeNonNullRegion) {
4392 complainAboutMissingNullability = CAMN_Yes;
4395 auto wrappingKind = PointerWrappingDeclaratorKind::None;
4397 case PointerDeclaratorKind::NonPointer:
4398 case PointerDeclaratorKind::MultiLevelPointer:
4402 case PointerDeclaratorKind::SingleLevelPointer:
4404 if (inAssumeNonNullRegion) {
4405 complainAboutInferringWithinChunk = wrappingKind;
4412 case PointerDeclaratorKind::CFErrorRefPointer:
4413 case PointerDeclaratorKind::NSErrorPointerPointer:
4416 if (isFunctionOrMethod && inAssumeNonNullRegion)
4420 case PointerDeclaratorKind::MaybePointerToCFRef:
4421 if (isFunctionOrMethod) {
4425 auto hasCFReturnsAttr =
4427 return AttrList.hasAttribute(ParsedAttr::AT_CFReturnsRetained) ||
4428 AttrList.hasAttribute(ParsedAttr::AT_CFReturnsNotRetained);
4430 if (
const auto *InnermostChunk =
D.getInnermostNonParenChunk()) {
4431 if (hasCFReturnsAttr(
D.getDeclarationAttributes()) ||
4432 hasCFReturnsAttr(
D.getAttributes()) ||
4433 hasCFReturnsAttr(InnermostChunk->getAttrs()) ||
4434 hasCFReturnsAttr(
D.getDeclSpec().getAttributes())) {
4436 inferNullabilityInnerOnly =
true;
4446 complainAboutMissingNullability = CAMN_Yes;
4474 auto isVaList = [&S](
QualType T) ->
bool {
4480 if (typedefTy->getDecl() == vaListTypedef)
4482 if (
auto *name = typedefTy->getDecl()->getIdentifier())
4483 if (name->isStr(
"va_list"))
4485 typedefTy = typedefTy->desugar()->getAs<
TypedefType>();
4486 }
while (typedefTy);
4492 auto inferPointerNullability =
4497 if (NumPointersRemaining > 0)
4498 --NumPointersRemaining;
4505 if (inferNullability && !inferNullabilityInnerOnlyComplete) {
4508 ? ParsedAttr::Form::ContextSensitiveKeyword()
4509 : ParsedAttr::Form::Keyword(
false ,
4515 attrs.addAtEnd(nullabilityAttr);
4517 if (inferNullabilityCS) {
4518 state.getDeclarator().getMutableDeclSpec().getObjCQualifiers()
4522 if (pointerLoc.isValid() &&
4523 complainAboutInferringWithinChunk !=
4524 PointerWrappingDeclaratorKind::None) {
4526 S.
Diag(pointerLoc, diag::warn_nullability_inferred_on_nested_type);
4527 Diag << static_cast<int>(complainAboutInferringWithinChunk);
4531 if (inferNullabilityInnerOnly)
4532 inferNullabilityInnerOnlyComplete =
true;
4533 return nullabilityAttr;
4538 switch (complainAboutMissingNullability) {
4542 case CAMN_InnerPointers:
4543 if (NumPointersRemaining == 0)
4559 if (NumPointersRemaining > 0)
4560 --NumPointersRemaining;
4562 SimplePointerKind pointerKind = SimplePointerKind::Pointer;
4564 pointerKind = SimplePointerKind::BlockPointer;
4566 pointerKind = SimplePointerKind::MemberPointer;
4568 if (
auto *
attr = inferPointerNullability(
4569 pointerKind,
D.getDeclSpec().getTypeSpecTypeLoc(),
4571 D.getMutableDeclSpec().getAttributes(),
4572 D.getMutableDeclSpec().getAttributePool())) {
4573 T = state.getAttributedType(
4579 if (complainAboutMissingNullability == CAMN_Yes &&
T->
isArrayType() &&
4583 D.getDeclSpec().getTypeSpecTypeLoc());
4587 bool ExpectNoDerefChunk =
4588 state.getCurrentAttributes().hasAttribute(ParsedAttr::AT_NoDeref);
4598 bool AreDeclaratorChunksValid =
true;
4599 for (
unsigned i = 0, e =
D.getNumTypeObjects(); i != e; ++i) {
4600 unsigned chunkIndex = e - i - 1;
4601 state.setCurrentChunkIndex(chunkIndex);
4604 switch (DeclType.
Kind) {
4612 if (!LangOpts.Blocks)
4613 S.
Diag(DeclType.
Loc, diag::err_blocks_disable) << LangOpts.OpenCL;
4616 inferPointerNullability(SimplePointerKind::BlockPointer, DeclType.
Loc,
4618 state.getDeclarator().getAttributePool());
4624 if (LangOpts.OpenCL)
4633 S.
Diag(
D.getIdentifierLoc(), diag::err_distant_exception_spec);
4634 D.setInvalidType(
true);
4639 inferPointerNullability(SimplePointerKind::Pointer, DeclType.
Loc,
4641 state.getDeclarator().getAttributePool());
4653 if (LangOpts.OpenCL) {
4656 S.
Diag(
D.getIdentifierLoc(), diag::err_opencl_pointer_to_type) <<
T;
4657 D.setInvalidType(
true);
4669 S.
Diag(
D.getIdentifierLoc(), diag::err_distant_exception_spec);
4670 D.setInvalidType(
true);
4683 S.
Diag(
D.getIdentifierLoc(), diag::err_distant_exception_spec);
4684 D.setInvalidType(
true);
4694 if (chunkIndex != 0 && !ArraySize &&
4695 D.getDeclSpec().getAttributes().hasMSPropertyAttr()) {
4713 S.
Diag(DeclType.
Loc, diag::err_array_star_outside_prototype);
4715 D.setInvalidType(
true);
4722 if (!(
D.isPrototypeContext() ||
4724 S.
Diag(DeclType.
Loc, diag::err_array_static_outside_prototype)
4726 :
"type qualifier");
4731 D.setInvalidType(
true);
4737 S.
Diag(DeclType.
Loc, diag::err_array_static_not_outermost)
4739 :
"type qualifier");
4743 D.setInvalidType(
true);
4749 if (complainAboutMissingNullability == CAMN_Yes &&
4765 IsQualifiedFunction =
4770 if (!
D.isInvalidType()) {
4774 return SS.isInvalid() ||
4796 ? dyn_cast_if_present<ParmVarDecl>(FTI.
Params[0].
Param)
4799 bool IsFunctionDecl =
D.getInnermostNonParenChunk() == &DeclType;
4800 if (
First &&
First->isExplicitObjectParameter() &&
4811 !IsClassType(
D.getCXXScopeSpec())) {
4814 diag::err_explicit_object_parameter_nonmember)
4816 <<
First->getSourceRange();
4819 diag::err_explicit_object_parameter_invalid)
4820 <<
First->getSourceRange();
4823 AreDeclaratorChunksValid =
false;
4828 if (
D.getDeclSpec().hasAutoTypeSpec() &&
4831 S.
Diag(
D.getDeclSpec().getTypeSpecTypeLoc(),
4833 ? diag::err_auto_missing_trailing_return
4834 : diag::err_deduced_return_type);
4836 D.setInvalidType(
true);
4837 AreDeclaratorChunksValid =
false;
4839 S.
Diag(
D.getDeclSpec().getTypeSpecTypeLoc(),
4840 diag::warn_cxx11_compat_deduced_return_type);
4844 if (isa<ParenType>(
T)) {
4847 D.setInvalidType(
true);
4849 AreDeclaratorChunksValid =
false;
4850 }
else if (
D.getName().
getKind() ==
4854 diag::err_deduction_guide_with_complex_decl)
4856 D.setInvalidType(
true);
4858 AreDeclaratorChunksValid =
false;
4861 (
T.hasQualifiers() || !isa<AutoType>(
T) ||
4862 cast<AutoType>(
T)->getKeyword() !=
4864 cast<AutoType>(
T)->isConstrained())) {
4865 S.
Diag(
D.getDeclSpec().getTypeSpecTypeLoc(),
4866 diag::err_trailing_return_without_auto)
4868 D.setInvalidType(
true);
4870 AreDeclaratorChunksValid =
false;
4876 D.setInvalidType(
true);
4886 if (InventedParamInfo) {
4888 state,
T, TInfo,
Auto, *InventedParamInfo);
4902 unsigned diagID = diag::err_func_returning_array_function;
4905 if (chunkIndex == 0 &&
4907 diagID = diag::err_block_returning_array_function;
4910 D.setInvalidType(
true);
4911 AreDeclaratorChunksValid =
false;
4920 S.
Diag(
D.getIdentifierLoc(), diag::err_opencl_invalid_return)
4922 D.setInvalidType(
true);
4924 }
else if (!S.
getLangOpts().NativeHalfArgsAndReturns &&
4926 S.
Diag(
D.getIdentifierLoc(),
4927 diag::err_parameters_retval_cannot_have_fp16_type) << 1;
4928 D.setInvalidType(
true);
4932 if (LangOpts.OpenCL) {
4937 S.
Diag(
D.getIdentifierLoc(), diag::err_opencl_invalid_return)
4939 D.setInvalidType(
true);
4946 "__cl_clang_variadic_functions", S.
getLangOpts()) &&
4947 !(
D.getIdentifier() &&
4948 ((
D.getIdentifier()->getName() ==
"printf" &&
4950 D.getIdentifier()->getName().starts_with(
"__")))) {
4951 S.
Diag(
D.getIdentifierLoc(), diag::err_opencl_variadic_function);
4952 D.setInvalidType(
true);
4964 DiagLoc =
D.getDeclSpec().getTypeSpecTypeLoc();
4967 S.
Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value)
4979 AreDeclaratorChunksValid =
false;
4982 D.setInvalidType(
true);
4991 D.getFunctionDefinitionKind() ==
4996 S.
Diag(DeclType.
Loc, diag::err_func_returning_qualified_void) <<
T;
5002 if (
T.isVolatileQualified() && S.
getLangOpts().CPlusPlus20)
5003 S.
Diag(DeclType.
Loc, diag::warn_deprecated_volatile_return) <<
T;
5009 if (
T.getQualifiers().hasObjCLifetime()) {
5011 if (chunkIndex + 1 <
D.getNumTypeObjects()) {
5014 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5015 AttrLoc = AL.getLoc();
5021 for (
const ParsedAttr &AL :
D.getDeclSpec().getAttributes()) {
5022 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5023 AttrLoc = AL.getLoc();
5037 S.
Diag(AttrLoc, diag::warn_arc_lifetime_result_type)
5038 <<
T.getQualifiers().getObjCLifetime();
5042 if (LangOpts.CPlusPlus &&
D.getDeclSpec().hasTagDefinition()) {
5045 TagDecl *Tag = cast<TagDecl>(
D.getDeclSpec().getRepAsDecl());
5046 S.
Diag(Tag->getLocation(), diag::err_type_defined_in_result_type)
5054 diag::err_exception_spec_in_typedef)
5080 diag::warn_c17_compat_ellipsis_only_parameter);
5081 else if (!
D.getDeclarationAttributes().hasAttribute(
5082 ParsedAttr::AT_Overloadable) &&
5083 !
D.getAttributes().hasAttribute(
5084 ParsedAttr::AT_Overloadable) &&
5085 !
D.getDeclSpec().getAttributes().hasAttribute(
5086 ParsedAttr::AT_Overloadable))
5094 diag::err_ident_list_in_fn_declaration);
5095 D.setInvalidType(
true);
5100 AreDeclaratorChunksValid =
false;
5123 bool HasAnyInterestingExtParameterInfos =
false;
5125 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
5128 assert(!ParamTy.
isNull() &&
"Couldn't parse type?");
5139 ParamTy = Context.
IntTy;
5144 ParamTy = Context.
IntTy;
5149 S.
Diag(DeclType.
Loc, diag::err_void_param_qualified);
5165 }
else if (!S.
getLangOpts().NativeHalfArgsAndReturns &&
5168 diag::err_parameters_retval_cannot_have_fp16_type) << 0;
5176 if (BTy->getKind() == BuiltinType::Float) {
5188 if (LangOpts.ObjCAutoRefCount && Param->
hasAttr<NSConsumedAttr>()) {
5189 ExtParameterInfos[i] = ExtParameterInfos[i].withIsConsumed(
true);
5190 HasAnyInterestingExtParameterInfos =
true;
5194 ExtParameterInfos[i] =
5195 ExtParameterInfos[i].withABI(
attr->getABI());
5196 HasAnyInterestingExtParameterInfos =
true;
5199 if (Param->
hasAttr<PassObjectSizeAttr>()) {
5200 ExtParameterInfos[i] = ExtParameterInfos[i].withHasPassObjectSize();
5201 HasAnyInterestingExtParameterInfos =
true;
5204 if (Param->
hasAttr<NoEscapeAttr>()) {
5205 ExtParameterInfos[i] = ExtParameterInfos[i].withIsNoEscape(
true);
5206 HasAnyInterestingExtParameterInfos =
true;
5209 ParamTys.push_back(ParamTy);
5212 if (HasAnyInterestingExtParameterInfos) {
5221 Expr *NoexceptExpr =
nullptr;
5227 DynamicExceptions.reserve(N);
5228 DynamicExceptionRanges.reserve(N);
5229 for (
unsigned I = 0; I != N; ++I) {
5240 DynamicExceptionRanges,
5247 auto IsClassMember = [&]() {
5248 return (!state.getDeclarator().getCXXScopeSpec().isEmpty() &&
5249 state.getDeclarator()
5253 state.getDeclarator().getContext() ==
5255 state.getDeclarator().getContext() ==
5259 if (state.getSema().getLangOpts().OpenCLCPlusPlus && IsClassMember()) {
5268 D.setInvalidType(
true);
5289 inferPointerNullability(SimplePointerKind::MemberPointer, DeclType.
Loc,
5291 state.getDeclarator().getAttributePool());
5295 D.setInvalidType(
true);
5310 llvm_unreachable(
"Nested-name-specifier must name a type");
5320 if (isa<TemplateSpecializationType>(NNS->
getAsType()))
5322 NNSPrefix, ClsType);
5327 diag::err_illegal_decl_mempointer_in_nonclass)
5328 << (
D.getIdentifier() ?
D.getIdentifier()->getName() :
"type name")
5330 D.setInvalidType(
true);
5337 AreDeclaratorChunksValid =
false;
5341 D.setInvalidType(
true);
5342 AreDeclaratorChunksValid =
false;
5352 D.getMutableDeclSpec().getAttributes());
5358 D.setInvalidType(
true);
5360 AreDeclaratorChunksValid =
false;
5369 S.
Diag(DeclType.
Loc, diag::warn_noderef_on_non_pointer_or_array);
5371 ExpectNoDerefChunk = state.didParseNoDeref();
5375 if (ExpectNoDerefChunk)
5376 S.
Diag(state.getDeclarator().getBeginLoc(),
5377 diag::warn_noderef_on_non_pointer_or_array);
5390 bool IsBlock =
false;
5392 switch (DeclType.Kind) {
5404 S.
Diag(DeclType.Loc, diag::warn_strict_prototypes)
5416 assert(!
T.isNull() &&
"T must not be null after this point");
5420 assert(FnTy &&
"Why oh why is there not a FunctionProtoType here?");
5433 ExplicitObjectMember,
5437 Kind = DeductionGuide;
5438 else if (!
D.getCXXScopeSpec().isSet()) {
5441 !
D.getDeclSpec().isFriendSpecified())
5451 if (
D.isFunctionDeclarator(I)) {
5455 if (
P &&
P->isExplicitObjectParameter())
5456 Kind = ExplicitObjectMember;
5482 if (IsQualifiedFunction &&
5485 (Kind !=
Member ||
D.isExplicitObjectMemberFunction() ||
5488 D.isStaticMember())) &&
5494 if (
D.isFunctionDeclarator(I)) {
5507 if (!RemovalLocs.empty()) {
5508 llvm::sort(RemovalLocs,
5510 RemovalRange =
SourceRange(RemovalLocs.front(), RemovalLocs.back());
5511 Loc = RemovalLocs.front();
5515 S.
Diag(
Loc, diag::err_invalid_qualified_function_type)
5516 << Kind <<
D.isFunctionDeclarator() <<
T
5528 for (
unsigned i = 0, e =
D.getNumTypeObjects(); i != e; ++i) {
5538 for (
ParsedAttr &AL :
D.getDeclarationAttributes()) {
5539 if (!AL.slidesFromDeclToDeclSpecLegacyBehavior()) {
5547 state.diagnoseIgnoredTypeAttrs(
T);
5558 if (
T.isVolatileQualified() && S.
getLangOpts().CPlusPlus20 &&
5561 S.
Diag(
D.getIdentifierLoc(), diag::warn_deprecated_volatile_param) <<
T;
5565 if (
D.hasEllipsis()) {
5570 switch (
D.getContext()) {
5585 S.
Diag(
D.getEllipsisLoc(),
5586 diag::err_function_parameter_pack_without_parameter_packs)
5606 S.
Diag(
D.getEllipsisLoc(),
5607 LangOpts.CPlusPlus11
5608 ? diag::warn_cxx98_compat_variadic_templates
5609 : diag::ext_variadic_templates);
5638 S.
Diag(
D.getEllipsisLoc(),
5639 diag::err_ellipsis_in_declarator_not_parameter);
5645 assert(!
T.isNull() &&
"T must not be null at the end of this function");
5646 if (!AreDeclaratorChunksValid)
5655 TypeProcessingState state(*
this,
D);
5659 if (
D.isPrototypeContext() &&
getLangOpts().ObjCAutoRefCount)
5678 unsigned chunkIndex) {
5679 Sema &S = state.getSema();
5687 const char *attrStr =
nullptr;
5688 switch (ownership) {
5707 &Args, 1, ParsedAttr::Form::GNU());
5716 Sema &S = state.getSema();
5720 bool hasIndirection =
false;
5721 for (
unsigned i = 0, e =
D.getNumTypeObjects(); i != e; ++i) {
5723 switch (chunk.
Kind) {
5732 hasIndirection =
true;
5765 TypeProcessingState state(*
this,
D);
5780 TypeProcessingState &State) {
5787 if (AL.getKind() == ParsedAttr::AT_MatrixType) {
5796 llvm_unreachable(
"no matrix_type attribute found at the expected location!");
5800 class TypeSpecLocFiller :
public TypeLocVisitor<TypeSpecLocFiller> {
5803 TypeProcessingState &State;
5807 TypeSpecLocFiller(
Sema &S,
ASTContext &Context, TypeProcessingState &State,
5809 : SemaRef(S), Context(Context), State(State), DS(DS) {}
5821 State.getExpansionLocForMacroQualifiedType(TL.
getTypePtr()));
5944 void VisitDependentTemplateSpecializationTypeLoc(
5973 if (TemplateId->
NumArgs > 0) {
5985 FoundDecl = cast<NamedDecl>(USD);
5987 FoundDecl = cast_if_present<NamedDecl>(TN.getAsTemplateDecl());
6033 void VisitTypeLoc(
TypeLoc TL) {
6039 class DeclaratorLocFiller :
public TypeLocVisitor<DeclaratorLocFiller> {
6041 TypeProcessingState &State;
6045 DeclaratorLocFiller(
ASTContext &Context, TypeProcessingState &State,
6047 : Context(Context), State(State), Chunk(Chunk) {}
6050 llvm_unreachable(
"qualified type locs not expected here!");
6053 llvm_unreachable(
"decayed type locs not expected here!");
6056 llvm_unreachable(
"array parameter type locs not expected here!");
6095 assert(isa<DependentNameType>(ClsTy) &&
"Unexpected TypeLoc");
6106 if (isa<ElaboratedType>(ClsTy)) {
6121 llvm_unreachable(
"Nested-name-specifier must name a type");
6153 for (
unsigned i = 0, e = TL.
getNumParams(), tpi = 0; i != e; ++i) {
6189 void VisitTypeLoc(
TypeLoc TL) {
6190 llvm_unreachable(
"unsupported TypeLoc kind in declarator!");
6197 switch (Chunk.
Kind) {
6202 llvm_unreachable(
"cannot be _Atomic qualified");
6223 if (AL.getKind() == ParsedAttr::AT_AddressSpace) {
6232 "no address_space attribute found at the expected location!");
6246 Sema &S = State.getSema();
6253 if (isa<PackExpansionType>(
T)) {
6258 for (
unsigned i = 0, e =
D.getNumTypeObjects(); i != e; ++i) {
6262 D.getDeclSpec().getAttributes().hasMSPropertyAttr())
6272 bool HasDesugaredTypeLoc =
true;
6273 while (HasDesugaredTypeLoc) {
6275 case TypeLoc::MacroQualified: {
6278 State.getExpansionLocForMacroQualifiedType(TL.
getTypePtr()));
6283 case TypeLoc::Attributed: {
6290 case TypeLoc::Adjusted:
6291 case TypeLoc::BTFTagAttributed: {
6296 case TypeLoc::DependentAddressSpace: {
6304 HasDesugaredTypeLoc =
false;
6309 DeclaratorLocFiller(S.
Context, State,
D.getTypeObject(i)).Visit(CurrTL);
6315 if (ReturnTypeInfo) {
6320 TypeSpecLocFiller(S, S.
Context, State,
D.getDeclSpec()).Visit(CurrTL);
6335 "LocInfoType's TypeClass conflicts with an existing Type class");
6341 llvm_unreachable(
"LocInfoType leaked into the type system; an opaque TypeTy*"
6342 " was used directly instead of getting the QualType through"
6343 " GetTypeFromParser");
6349 assert(
D.getIdentifier() ==
nullptr &&
6350 "Type name should have no identifier!");
6354 if (
D.isInvalidType())
6387 const Expr *AddrSpace,
6390 std::optional<llvm::APSInt> OptAddrSpace =
6392 if (!OptAddrSpace) {
6393 S.
Diag(AttrLoc, diag::err_attribute_argument_type)
6398 llvm::APSInt &addrSpace = *OptAddrSpace;
6401 if (addrSpace.isSigned()) {
6402 if (addrSpace.isNegative()) {
6403 S.
Diag(AttrLoc, diag::err_attribute_address_space_negative)
6407 addrSpace.setIsSigned(
false);
6410 llvm::APSInt
max(addrSpace.getBitWidth());
6414 if (addrSpace >
max) {
6415 S.
Diag(AttrLoc, diag::err_attribute_address_space_too_high)
6446 Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
6462 TypeProcessingState &State) {
6463 Sema &S = State.getSema();
6466 if (
Attr.getNumArgs() != 1) {
6467 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
6474 auto *StrLiteral = dyn_cast<StringLiteral>(
Attr.getArgAsExpr(0));
6483 StringRef BTFTypeTag = StrLiteral->getString();
6484 Type = State.getBTFTagAttributedType(
6485 ::new (Ctx) BTFTypeTagAttr(Ctx,
Attr, BTFTypeTag),
Type);
6493 TypeProcessingState &State) {
6494 Sema &S = State.getSema();
6499 S.
Diag(
Attr.
getLoc(), diag::err_attribute_address_function_type);
6505 if (
Attr.
getKind() == ParsedAttr::AT_AddressSpace) {
6508 if (
Attr.getNumArgs() != 1) {
6515 Expr *ASArgExpr =
static_cast<Expr *
>(
Attr.getArgAsExpr(0));
6524 ::new (Ctx) AddressSpaceAttr(Ctx,
Attr,
static_cast<unsigned>(ASIdx));
6536 if (EquivType.
isNull()) {
6540 T = State.getAttributedType(ASAttr,
Type, EquivType);
6542 T = State.getAttributedType(ASAttr,
Type,
Type);
6553 :
Attr.asOpenCLLangAS();
6555 ASIdx =
Attr.asHLSLLangAS();
6558 llvm_unreachable(
"Invalid address space");
6576 bool NonObjCPointer =
false;
6578 if (!
type->isDependentType() && !
type->isUndeducedType()) {
6586 NonObjCPointer =
true;
6587 }
else if (!
type->isObjCRetainableType()) {
6593 if (state.isProcessingDeclSpec()) {
6601 Sema &S = state.getSema();
6607 if (!
attr.isArgIdent(0)) {
6608 S.
Diag(AttrLoc, diag::err_attribute_argument_type) <<
attr
6616 if (II->
isStr(
"none"))
6618 else if (II->
isStr(
"strong"))
6620 else if (II->
isStr(
"weak"))
6622 else if (II->
isStr(
"autoreleasing"))
6625 S.
Diag(AttrLoc, diag::warn_attribute_type_not_supported) <<
attr << II;
6642 =
type.getQualifiers().getObjCLifetime()) {
6645 S.
Diag(AttrLoc, diag::err_attr_objc_ownership_redundant)
6652 if (previousLifetime != lifetime) {
6655 const Type *prevTy =
nullptr;
6656 while (!prevTy || prevTy != underlyingType.
Ty) {
6657 prevTy = underlyingType.
Ty;
6666 if (NonObjCPointer) {
6667 StringRef name =
attr.getAttrName()->getName();
6676 S.
Diag(AttrLoc, diag::warn_type_attribute_wrong_type) << name
6693 type = state.getAttributedType(
6694 createSimpleAttr<ObjCInertUnsafeUnretainedAttr>(S.
Context,
attr),
6700 if (!NonObjCPointer)
6717 diagnostic,
type, 0));
6719 S.
Diag(loc, diagnostic);
6728 unsigned diagnostic =
6729 (S.
getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled
6730 : diag::err_arc_weak_no_runtime);
6733 diagnoseOrDelay(S, AttrLoc, diagnostic,
type);
6745 if (
Class->isArcWeakrefUnavailable()) {
6746 S.
Diag(AttrLoc, diag::err_arc_unsupported_weak_class);
6747 S.
Diag(ObjT->getInterfaceDecl()->getLocation(),
6748 diag::note_class_declared);
6763 Sema &S = state.getSema();
6766 if (!
type->isPointerType() &&
6767 !
type->isObjCObjectPointerType() &&
6768 !
type->isBlockPointerType())
6772 S.
Diag(
attr.getLoc(), diag::err_attribute_multiple_objc_gc);
6778 if (!
attr.isArgIdent(0)) {
6779 S.
Diag(
attr.getLoc(), diag::err_attribute_argument_type)
6785 if (
attr.getNumArgs() > 1) {
6786 S.
Diag(
attr.getLoc(), diag::err_attribute_wrong_number_arguments) <<
attr
6793 if (II->
isStr(
"weak"))
6795 else if (II->
isStr(
"strong"))
6798 S.
Diag(
attr.getLoc(), diag::warn_attribute_type_not_supported)
6808 if (
attr.getLoc().isValid())
6809 type = state.getAttributedType(
6826 struct FunctionTypeUnwrapper {
6845 const Type *Ty =
T.getTypePtr();
6846 if (isa<FunctionType>(Ty)) {
6847 Fn = cast<FunctionType>(Ty);
6849 }
else if (isa<ParenType>(Ty)) {
6850 T = cast<ParenType>(Ty)->getInnerType();
6852 }
else if (isa<ConstantArrayType>(Ty) || isa<VariableArrayType>(Ty) ||
6853 isa<IncompleteArrayType>(Ty)) {
6854 T = cast<ArrayType>(Ty)->getElementType();
6855 Stack.push_back(Array);
6856 }
else if (isa<PointerType>(Ty)) {
6859 }
else if (isa<BlockPointerType>(Ty)) {
6861 Stack.push_back(BlockPointer);
6862 }
else if (isa<MemberPointerType>(Ty)) {
6864 Stack.push_back(MemberPointer);
6865 }
else if (isa<ReferenceType>(Ty)) {
6868 }
else if (isa<AttributedType>(Ty)) {
6869 T = cast<AttributedType>(Ty)->getEquivalentType();
6870 Stack.push_back(Attributed);
6871 }
else if (isa<MacroQualifiedType>(Ty)) {
6872 T = cast<MacroQualifiedType>(Ty)->getUnderlyingType();
6873 Stack.push_back(MacroQualified);
6882 Stack.push_back(Desugar);
6887 bool isFunctionType()
const {
return (Fn !=
nullptr); }
6892 if (New == get())
return Original;
6895 return wrap(S.
Context, Original, 0);
6900 if (I == Stack.size())
6909 return wrap(
C, SplitOld.
Ty, I);
6910 return C.getQualifiedType(wrap(
C, SplitOld.
Ty, I), SplitOld.
Quals);
6914 if (I == Stack.size())
return QualType(Fn, 0);
6916 switch (
static_cast<WrapKind
>(Stack[I++])) {
6923 return wrap(
C, cast<AttributedType>(Old)->getEquivalentType(), I);
6926 QualType New = wrap(
C, cast<ParenType>(Old)->getInnerType(), I);
6927 return C.getParenType(New);
6930 case MacroQualified:
6934 if (
const auto *CAT = dyn_cast<ConstantArrayType>(Old)) {
6935 QualType New = wrap(
C, CAT->getElementType(), I);
6936 return C.getConstantArrayType(New, CAT->getSize(), CAT->getSizeExpr(),
6937 CAT->getSizeModifier(),
6938 CAT->getIndexTypeCVRQualifiers());
6941 if (
const auto *VAT = dyn_cast<VariableArrayType>(Old)) {
6942 QualType New = wrap(
C, VAT->getElementType(), I);
6943 return C.getVariableArrayType(
6944 New, VAT->getSizeExpr(), VAT->getSizeModifier(),
6945 VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange());
6948 const auto *IAT = cast<IncompleteArrayType>(Old);
6949 QualType New = wrap(
C, IAT->getElementType(), I);
6950 return C.getIncompleteArrayType(New, IAT->getSizeModifier(),
6951 IAT->getIndexTypeCVRQualifiers());
6956 return C.getPointerType(New);
6959 case BlockPointer: {
6961 return C.getBlockPointerType(New);
6964 case MemberPointer: {
6967 return C.getMemberPointerType(New, OldMPT->
getClass());
6973 if (isa<LValueReferenceType>(OldRef))
6976 return C.getRValueReferenceType(New);
6980 llvm_unreachable(
"unknown wrapping kind");
6987 Sema &S = State.getSema();
6991 default: llvm_unreachable(
"Unknown attribute kind");
6992 case ParsedAttr::AT_Ptr32:
6993 A = createSimpleAttr<Ptr32Attr>(S.
Context, PAttr);
6995 case ParsedAttr::AT_Ptr64:
6996 A = createSimpleAttr<Ptr64Attr>(S.
Context, PAttr);
6998 case ParsedAttr::AT_SPtr:
6999 A = createSimpleAttr<SPtrAttr>(S.
Context, PAttr);
7001 case ParsedAttr::AT_UPtr:
7002 A = createSimpleAttr<UPtrAttr>(S.
Context, PAttr);
7006 std::bitset<attr::LastAttr> Attrs;
7009 if (
const TypedefType *TT = dyn_cast<TypedefType>(Desugared)) {
7010 Desugared = TT->desugar();
7012 }
else if (
const ElaboratedType *ET = dyn_cast<ElaboratedType>(Desugared)) {
7013 Desugared = ET->desugar();
7026 if (Attrs[NewAttrKind]) {
7027 S.
Diag(PAttr.
getLoc(), diag::warn_duplicate_attribute_exact) << PAttr;
7030 Attrs[NewAttrKind] =
true;
7034 if (Attrs[attr::Ptr32] && Attrs[attr::Ptr64]) {
7035 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
7037 <<
"'__ptr64'" << 0;
7039 }
else if (Attrs[attr::SPtr] && Attrs[attr::UPtr]) {
7040 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
7048 if (!isa<PointerType>(Desugared)) {
7052 S.
Diag(PAttr.
getLoc(), diag::err_attribute_no_member_pointers) << PAttr;
7054 S.
Diag(PAttr.
getLoc(), diag::err_attribute_pointers_only) << PAttr << 0;
7062 if (PtrWidth == 32) {
7063 if (Attrs[attr::Ptr64])
7065 else if (Attrs[attr::UPtr])
7067 }
else if (PtrWidth == 64 && Attrs[attr::Ptr32]) {
7084 assert(PAttr.
getKind() == ParsedAttr::AT_WebAssemblyFuncref);
7086 Sema &S = State.getSema();
7087 Attr *A = createSimpleAttr<WebAssemblyFuncrefAttr>(S.
Context, PAttr);
7089 std::bitset<attr::LastAttr> Attrs;
7091 const auto *AT = dyn_cast<AttributedType>(QT);
7093 Attrs[AT->getAttrKind()] =
true;
7094 AT = dyn_cast<AttributedType>(AT->getModifiedType());
7099 if (Attrs[NewAttrKind]) {
7100 S.
Diag(PAttr.
getLoc(), diag::warn_duplicate_attribute_exact) << PAttr;
7116 auto Attributed = dyn_cast<AttributedType>(
Type.getTypePtr());
7121 if (Attributed->getImmediateNullability())
7122 return Attributed->getModifiedType();
7126 Ctx, Attributed->getModifiedType());
7127 assert(Modified.
getTypePtr() != Attributed->getModifiedType().getTypePtr());
7129 Attributed->getEquivalentType());
7135 case ParsedAttr::AT_TypeNonNull:
7138 case ParsedAttr::AT_TypeNullable:
7141 case ParsedAttr::AT_TypeNullableResult:
7144 case ParsedAttr::AT_TypeNullUnspecified:
7148 llvm_unreachable(
"not a nullability attribute kind");
7155 bool IsContextSensitive,
bool AllowOnArrayType,
bool OverrideExisting) {
7156 bool Implicit = (State ==
nullptr);
7162 while (
auto *Attributed = dyn_cast<AttributedType>(Desugared.
getTypePtr())) {
7164 if (
auto ExistingNullability = Attributed->getImmediateNullability()) {
7166 if (Nullability == *ExistingNullability) {
7170 S.
Diag(NullabilityLoc, diag::warn_nullability_duplicate)
7177 if (!OverrideExisting) {
7179 S.
Diag(NullabilityLoc, diag::err_nullability_conflicting)
7189 Desugared = Attributed->getModifiedType();
7197 if (Nullability != *ExistingNullability && !
Implicit) {
7198 S.
Diag(NullabilityLoc, diag::err_nullability_conflicting)
7206 if (
auto typedefNullability =
7208 if (*typedefNullability == *ExistingNullability) {
7221 !(AllowOnArrayType && Desugared->
isArrayType())) {
7223 S.
Diag(NullabilityLoc, diag::err_nullability_nonpointer)
7231 if (IsContextSensitive) {
7233 const Type *pointeeType =
nullptr;
7242 S.
Diag(NullabilityLoc, diag::err_nullability_cs_multilevel)
7244 S.
Diag(NullabilityLoc, diag::note_nullability_type_specifier)
7256 QT = State->getAttributedType(A, QT, QT);
7266 bool AllowOnArrayType) {
7272 Nullability, NullabilityLoc,
7273 IsContextSensitive, AllowOnArrayType,
7280 bool AllowArrayTypes,
7281 bool OverrideExisting) {
7283 *
this,
nullptr,
nullptr,
Type, Nullability, DiagLoc,
7284 false, AllowArrayTypes, OverrideExisting);
7291 Sema &S = state.getSema();
7293 if (isa<ObjCTypeParamType>(
type)) {
7295 type = state.getAttributedType(
7308 S.
Diag(
attr.getLoc(), diag::err_objc_kindof_nonobject)
7317 objType->getBaseType(), objType->getTypeArgsAsWritten(),
7318 objType->getProtocols(),
7319 objType->isObjCUnqualifiedId() ?
false :
true);
7324 if (
auto nullability =
type->getNullability()) {
7327 assert(
attr.getAttributeSpellingListIndex() == 0 &&
7328 "multiple spellings for __kindof?");
7331 equivType = state.getAttributedType(A, equivType, equivType);
7336 type = state.getAttributedType(
7349 Declarator &declarator = state.getDeclarator();
7352 auto moveToChunk = [&](
DeclaratorChunk &chunk,
bool inFunction) ->
bool {
7365 PK_MemberFunctionPointer,
7370 : inFunction? PK_MemberFunctionPointer : PK_MemberPointer;
7372 auto diag = state.getSema().Diag(
attr.getLoc(),
7373 diag::warn_nullability_declspec)
7375 attr.isContextSensitiveKeywordAttribute())
7377 <<
static_cast<unsigned>(pointerKind);
7383 state.getSema().getPreprocessor().getLocForEndOfToken(
7385 " " +
attr.getAttrName()->getName().str() +
" ");
7395 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
7397 switch (chunk.
Kind) {
7401 return moveToChunk(chunk,
false);
7413 return moveToChunk(*dest,
true);
7429 assert(!
Attr.isInvalid());
7432 llvm_unreachable(
"not a calling convention attribute");
7433 case ParsedAttr::AT_CDecl:
7434 return createSimpleAttr<CDeclAttr>(Ctx,
Attr);
7435 case ParsedAttr::AT_FastCall:
7436 return createSimpleAttr<FastCallAttr>(Ctx,
Attr);
7437 case ParsedAttr::AT_StdCall:
7438 return createSimpleAttr<StdCallAttr>(Ctx,
Attr);
7439 case ParsedAttr::AT_ThisCall:
7440 return createSimpleAttr<ThisCallAttr>(Ctx,
Attr);
7441 case ParsedAttr::AT_RegCall:
7442 return createSimpleAttr<RegCallAttr>(Ctx,
Attr);
7443 case ParsedAttr::AT_Pascal:
7444 return createSimpleAttr<PascalAttr>(Ctx,
Attr);
7445 case ParsedAttr::AT_SwiftCall:
7446 return createSimpleAttr<SwiftCallAttr>(Ctx,
Attr);
7447 case ParsedAttr::AT_SwiftAsyncCall:
7448 return createSimpleAttr<SwiftAsyncCallAttr>(Ctx,
Attr);
7449 case ParsedAttr::AT_VectorCall:
7450 return createSimpleAttr<VectorCallAttr>(Ctx,
Attr);
7451 case ParsedAttr::AT_AArch64VectorPcs:
7452 return createSimpleAttr<AArch64VectorPcsAttr>(Ctx,
Attr);
7453 case ParsedAttr::AT_AArch64SVEPcs:
7454 return createSimpleAttr<AArch64SVEPcsAttr>(Ctx,
Attr);
7455 case ParsedAttr::AT_ArmStreaming:
7456 return createSimpleAttr<ArmStreamingAttr>(Ctx,
Attr);
7457 case ParsedAttr::AT_AMDGPUKernelCall:
7458 return createSimpleAttr<AMDGPUKernelCallAttr>(Ctx,
Attr);
7459 case ParsedAttr::AT_Pcs: {
7464 if (
Attr.isArgExpr(0))
7465 Str = cast<StringLiteral>(
Attr.getArgAsExpr(0))->getString();
7467 Str =
Attr.getArgAsIdent(0)->Ident->getName();
7468 PcsAttr::PCSType
Type;
7469 if (!PcsAttr::ConvertStrToPCSType(Str,
Type))
7470 llvm_unreachable(
"already validated the attribute");
7471 return ::new (Ctx) PcsAttr(Ctx,
Attr,
Type);
7473 case ParsedAttr::AT_IntelOclBicc:
7474 return createSimpleAttr<IntelOclBiccAttr>(Ctx,
Attr);
7475 case ParsedAttr::AT_MSABI:
7476 return createSimpleAttr<MSABIAttr>(Ctx,
Attr);
7477 case ParsedAttr::AT_SysVABI:
7478 return createSimpleAttr<SysVABIAttr>(Ctx,
Attr);
7479 case ParsedAttr::AT_PreserveMost:
7480 return createSimpleAttr<PreserveMostAttr>(Ctx,
Attr);
7481 case ParsedAttr::AT_PreserveAll:
7482 return createSimpleAttr<PreserveAllAttr>(Ctx,
Attr);
7483 case ParsedAttr::AT_M68kRTD:
7484 return createSimpleAttr<M68kRTDAttr>(Ctx,
Attr);
7485 case ParsedAttr::AT_PreserveNone:
7486 return createSimpleAttr<PreserveNoneAttr>(Ctx,
Attr);
7487 case ParsedAttr::AT_RISCVVectorCC:
7488 return createSimpleAttr<RISCVVectorCCAttr>(Ctx,
Attr);
7490 llvm_unreachable(
"unexpected attribute kind!");
7493std::optional<FunctionEffectMode>
7498 std::optional<llvm::APSInt> ConditionValue =
7500 if (!ConditionValue) {
7506 return std::nullopt;
7515 FunctionTypeUnwrapper &Unwrapped) {
7517 if (!Unwrapped.isFunctionType())
7520 Sema &S = TPState.getSema();
7524 if (FPT ==
nullptr) {
7525 S.
Diag(PAttr.
getLoc(), diag::err_func_with_effects_no_prototype)
7532 bool IsNonBlocking = PAttr.
getKind() == ParsedAttr::AT_NonBlocking ||
7533 PAttr.
getKind() == ParsedAttr::AT_Blocking;
7536 Expr *CondExpr =
nullptr;
7538 if (PAttr.
getKind() == ParsedAttr::AT_NonBlocking ||
7539 PAttr.
getKind() == ParsedAttr::AT_NonAllocating) {
7548 std::optional<FunctionEffectMode> MaybeMode =
7554 NewMode = *MaybeMode;
7589 assert(
Success &&
"effect conflicts should have been diagnosed above");
7593 FPT->getParamTypes(), EPI);
7602 auto OtherAttr = std::find_if(
7603 state.getCurrentAttributes().begin(), state.getCurrentAttributes().end(),
7604 [OtherKind](
const ParsedAttr &A) { return A.getKind() == OtherKind; });
7605 if (OtherAttr == state.getCurrentAttributes().end() || OtherAttr->isInvalid())
7608 Sema &S = state.getSema();
7610 << *OtherAttr <<
Attr
7611 << (OtherAttr->isRegularKeywordAttribute() ||
7613 S.
Diag(OtherAttr->getLoc(), diag::note_conflicting_attribute);
7622 if (!
Attr.getNumArgs()) {
7628 for (
unsigned I = 0; I <
Attr.getNumArgs(); ++I) {
7629 StringRef StateName;
7636 if (StateName ==
"za") {
7639 }
else if (StateName ==
"zt0") {
7643 S.
Diag(LiteralLoc, diag::err_unknown_arm_state) << StateName;
7652 S.
Diag(LiteralLoc, diag::err_conflicting_attributes_arm_state)
7668 Sema &S = state.getSema();
7670 FunctionTypeUnwrapper unwrapped(S,
type);
7672 if (
attr.getKind() == ParsedAttr::AT_NoReturn) {
7677 if (!unwrapped.isFunctionType())
7686 if (
attr.getKind() == ParsedAttr::AT_CmseNSCall) {
7688 if (!unwrapped.isFunctionType())
7693 S.
Diag(
attr.getLoc(), diag::warn_attribute_ignored) <<
attr;
7707 if (
attr.getKind() == ParsedAttr::AT_NSReturnsRetained) {
7708 if (
attr.getNumArgs())
return true;
7711 if (!unwrapped.isFunctionType())
7716 attr.getLoc(), unwrapped.get()->getReturnType()))
7721 if (state.getSema().getLangOpts().ObjCAutoRefCount) {
7726 type = state.getAttributedType(
7727 createSimpleAttr<NSReturnsRetainedAttr>(S.
Context,
attr),
7732 if (
attr.getKind() == ParsedAttr::AT_AnyX86NoCallerSavedRegisters) {
7737 if (!unwrapped.isFunctionType())
7746 if (
attr.getKind() == ParsedAttr::AT_AnyX86NoCfCheck) {
7748 S.
Diag(
attr.getLoc(), diag::warn_nocf_check_attribute_ignored);
7758 if (!unwrapped.isFunctionType())
7767 if (
attr.getKind() == ParsedAttr::AT_Regparm) {
7773 if (!unwrapped.isFunctionType())
7780 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
7782 <<
attr.isRegularKeywordAttribute();
7793 if (
attr.getKind() == ParsedAttr::AT_ArmStreaming ||
7794 attr.getKind() == ParsedAttr::AT_ArmStreamingCompatible ||
7795 attr.getKind() == ParsedAttr::AT_ArmPreserves ||
7796 attr.getKind() == ParsedAttr::AT_ArmIn ||
7797 attr.getKind() == ParsedAttr::AT_ArmOut ||
7798 attr.getKind() == ParsedAttr::AT_ArmInOut) {
7802 if (
attr.getKind() == ParsedAttr::AT_ArmStreaming ||
7803 attr.getKind() == ParsedAttr::AT_ArmStreamingCompatible)
7807 if (!unwrapped.isFunctionType())
7814 S.
Diag(
attr.getLoc(), diag::warn_attribute_wrong_decl_type) <<
7821 switch (
attr.getKind()) {
7822 case ParsedAttr::AT_ArmStreaming:
7824 ParsedAttr::AT_ArmStreamingCompatible))
7828 case ParsedAttr::AT_ArmStreamingCompatible:
7833 case ParsedAttr::AT_ArmPreserves:
7837 case ParsedAttr::AT_ArmIn:
7841 case ParsedAttr::AT_ArmOut:
7845 case ParsedAttr::AT_ArmInOut:
7850 llvm_unreachable(
"Unsupported attribute");
7854 FnTy->getParamTypes(), EPI);
7859 if (
attr.getKind() == ParsedAttr::AT_NoThrow) {
7861 if (!unwrapped.isFunctionType())
7874 if (Proto->hasExceptionSpec()) {
7875 switch (Proto->getExceptionSpecType()) {
7877 llvm_unreachable(
"This doesn't have an exception spec!");
7895 S.
Diag(
attr.getLoc(), diag::warn_nothrow_attribute_ignored);
7901 type = unwrapped.wrap(
7910 if (
attr.getKind() == ParsedAttr::AT_NonBlocking ||
7911 attr.getKind() == ParsedAttr::AT_NonAllocating ||
7912 attr.getKind() == ParsedAttr::AT_Blocking ||
7913 attr.getKind() == ParsedAttr::AT_Allocating) {
7918 if (!unwrapped.isFunctionType())
return false;
7933 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
7936 <<
attr.isRegularKeywordAttribute();
7955 return S.
Diag(
attr.getLoc(), diag::warn_cconv_unsupported)
7960 return S.
Diag(
attr.getLoc(), diag::err_cconv_varargs)
7967 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
7969 <<
attr.isRegularKeywordAttribute();
7981 auto EI = unwrapped.get()->getExtInfo().withCallingConv(CC);
8005 FunctionTypeUnwrapper Unwrapped(*
this,
T);
8007 bool IsVariadic = (isa<FunctionProtoType>(FT) &&
8008 cast<FunctionProtoType>(FT)->isVariadic());
8022 Diag(
Loc, diag::warn_cconv_unsupported)
8033 if (CurCC != DefaultCC)
8041 QualType Wrapped = Unwrapped.wrap(*
this, FT);
8055 if (
Attr.getNumArgs() != 1) {
8062 Expr *SizeExpr =
Attr.getArgAsExpr(0);
8075 if (
Attr.getNumArgs() != 1) {
8081 Expr *SizeExpr =
Attr.getArgAsExpr(0);
8096 bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 ||
8097 Triple.getArch() == llvm::Triple::aarch64_32 ||
8098 Triple.getArch() == llvm::Triple::aarch64_be;
8100 if (IsPolyUnsigned) {
8102 return BTy->
getKind() == BuiltinType::UChar ||
8103 BTy->
getKind() == BuiltinType::UShort ||
8104 BTy->
getKind() == BuiltinType::ULong ||
8105 BTy->
getKind() == BuiltinType::ULongLong;
8108 return BTy->
getKind() == BuiltinType::SChar ||
8109 BTy->
getKind() == BuiltinType::Short ||
8110 BTy->
getKind() == BuiltinType::LongLong;
8116 if ((Triple.isArch64Bit() || Triple.getArch() == llvm::Triple::aarch64_32) &&
8117 BTy->
getKind() == BuiltinType::Double)
8120 return BTy->
getKind() == BuiltinType::SChar ||
8121 BTy->
getKind() == BuiltinType::UChar ||
8122 BTy->
getKind() == BuiltinType::Short ||
8123 BTy->
getKind() == BuiltinType::UShort ||
8124 BTy->
getKind() == BuiltinType::Int ||
8125 BTy->
getKind() == BuiltinType::UInt ||
8126 BTy->
getKind() == BuiltinType::Long ||
8127 BTy->
getKind() == BuiltinType::ULong ||
8128 BTy->
getKind() == BuiltinType::LongLong ||
8129 BTy->
getKind() == BuiltinType::ULongLong ||
8130 BTy->
getKind() == BuiltinType::Float ||
8131 BTy->
getKind() == BuiltinType::Half ||
8132 BTy->
getKind() == BuiltinType::BFloat16;
8137 const auto *AttrExpr =
Attr.getArgAsExpr(0);
8138 if (!AttrExpr->isTypeDependent()) {
8139 if (std::optional<llvm::APSInt> Res =
8140 AttrExpr->getIntegerConstantExpr(S.
Context)) {
8160 bool IsTargetCUDAAndHostARM =
false;
8163 IsTargetCUDAAndHostARM =
8187 if (
Attr.getNumArgs() != 1) {
8188 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8194 llvm::APSInt numEltsInt(32);
8200 !IsTargetCUDAAndHostARM) {
8201 S.
Diag(
Attr.
getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
8208 unsigned numElts =
static_cast<unsigned>(numEltsInt.getZExtValue());
8209 unsigned vecSize = typeSize * numElts;
8210 if (vecSize != 64 && vecSize != 128) {
8211 S.
Diag(
Attr.
getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType;
8235 S.
Diag(
Attr.
getLoc(), diag::err_attribute_arm_feature_sve_bits_unsupported)
8242 if (
Attr.getNumArgs() != 1) {
8243 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8250 llvm::APSInt SveVectorSizeInBits(32);
8254 unsigned VecSize =
static_cast<unsigned>(SveVectorSizeInBits.getZExtValue());
8277 if (BT->getKind() == BuiltinType::SveBool) {
8282 VecSize /= TypeSize;
8289 const VectorType *VT = dyn_cast<VectorType>(CurType);
8292 diag::err_attribute_arm_mve_polymorphism);
8298 State.getAttributedType(createSimpleAttr<ArmMveStrictPolymorphismAttr>(
8299 State.getSema().Context,
Attr),
8311 <<
Attr <<
"'zve32x'";
8317 if (!VScale || !VScale->first || VScale->first != VScale->second) {
8318 S.
Diag(
Attr.
getLoc(), diag::err_attribute_riscv_rvv_bits_unsupported)
8325 if (
Attr.getNumArgs() != 1) {
8326 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8333 llvm::APSInt RVVVectorSizeInBits(32);
8345 unsigned VecSize =
static_cast<unsigned>(RVVVectorSizeInBits.getZExtValue());
8349 unsigned MinElts = Info.
EC.getKnownMinValue();
8352 unsigned ExpectedSize = VScale->first * MinElts;
8374 ExpectedSize *= EltSize;
8375 NumElts = VecSize / EltSize;
8379 if (VecSize != ExpectedSize) {
8381 << VecSize << ExpectedSize;
8394 S.
Diag(
Attr.
getLoc(), diag::err_opencl_invalid_access_qualifier);
8400 QualType BaseTy = TypedefTy->desugar();
8402 std::string PrevAccessQual;
8404 if (TypedefTy->getDecl()->hasAttr<OpenCLAccessAttr>()) {
8405 OpenCLAccessAttr *
Attr =
8406 TypedefTy->getDecl()->getAttr<OpenCLAccessAttr>();
8409 PrevAccessQual =
"read_only";
8413 switch (ImgType->getKind()) {
8414 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8415 case BuiltinType::Id: \
8416 PrevAccessQual = #Access; \
8418 #include "clang/Basic/OpenCLImageTypes.def"
8420 llvm_unreachable(
"Unable to find corresponding image type.");
8423 llvm_unreachable(
"unexpected type");
8426 if (PrevAccessQual == AttrName.ltrim(
"_")) {
8432 S.
Diag(
Attr.
getLoc(), diag::err_opencl_multiple_access_qualifiers);
8435 S.
Diag(TypedefTy->getDecl()->getBeginLoc(),
8436 diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;
8438 if (
Attr.getSemanticSpelling() == OpenCLAccessAttr::Keyword_write_only) {
8453 if (
Attr.getNumArgs() != 2) {
8454 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8459 Expr *RowsExpr =
Attr.getArgAsExpr(0);
8460 Expr *ColsExpr =
Attr.getArgAsExpr(1);
8468 Sema &S = State.getSema();
8471 S.
Diag(PA.
getLoc(), diag::err_attribute_too_few_arguments) << PA << 1;
8483 for (
unsigned Idx = 1; Idx < PA.
getNumArgs(); Idx++) {
8489 auto *AnnotateTypeAttr =
8490 AnnotateTypeAttr::Create(S.
Context, Str, Args.data(), Args.size(), PA);
8491 CurType = State.getAttributedType(AnnotateTypeAttr, CurType, CurType);
8497 if (State.getDeclarator().isDeclarationOfFunction()) {
8498 CurType = State.getAttributedType(
8499 createSimpleAttr<LifetimeBoundAttr>(State.getSema().Context,
Attr),
8510 if (
Attr.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_inout ||
8511 Attr.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_out)
8520 state.setParsedNoDeref(
false);
8536 if (
attr.isInvalid())
8539 if (
attr.isStandardAttributeSyntax() ||
attr.isRegularKeywordAttribute()) {
8544 if (
attr.isGNUScope()) {
8545 assert(
attr.isStandardAttributeSyntax());
8546 bool IsTypeAttr =
attr.isTypeAttr();
8548 state.getSema().Diag(
attr.getLoc(),
8550 ? diag::warn_gcc_ignores_type_attr
8551 : diag::warn_cxx11_gnu_attribute_on_type)
8557 !
attr.isTypeAttr()) {
8570 switch (
attr.getKind()) {
8573 if ((
attr.isStandardAttributeSyntax() ||
8574 attr.isRegularKeywordAttribute()) &&
8576 state.getSema().Diag(
attr.getLoc(), diag::err_attribute_not_type_attr)
8577 <<
attr <<
attr.isRegularKeywordAttribute();
8578 attr.setUsedAsTypeAttr();
8583 if (
attr.isStandardAttributeSyntax()) {
8584 state.getSema().Diag(
attr.getLoc(),
8585 diag::warn_unknown_attribute_ignored)
8596 case ParsedAttr::AT_BTFTypeTag:
8598 attr.setUsedAsTypeAttr();
8601 case ParsedAttr::AT_MayAlias:
8604 attr.setUsedAsTypeAttr();
8606 case ParsedAttr::AT_OpenCLPrivateAddressSpace:
8607 case ParsedAttr::AT_OpenCLGlobalAddressSpace:
8608 case ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace:
8609 case ParsedAttr::AT_OpenCLGlobalHostAddressSpace:
8610 case ParsedAttr::AT_OpenCLLocalAddressSpace:
8611 case ParsedAttr::AT_OpenCLConstantAddressSpace:
8612 case ParsedAttr::AT_OpenCLGenericAddressSpace:
8613 case ParsedAttr::AT_HLSLGroupSharedAddressSpace:
8614 case ParsedAttr::AT_AddressSpace:
8616 attr.setUsedAsTypeAttr();
8621 attr.setUsedAsTypeAttr();
8623 case ParsedAttr::AT_VectorSize:
8625 attr.setUsedAsTypeAttr();
8627 case ParsedAttr::AT_ExtVectorType:
8629 attr.setUsedAsTypeAttr();
8631 case ParsedAttr::AT_NeonVectorType:
8633 attr.setUsedAsTypeAttr();
8635 case ParsedAttr::AT_NeonPolyVectorType:
8638 attr.setUsedAsTypeAttr();
8640 case ParsedAttr::AT_ArmSveVectorBits:
8642 attr.setUsedAsTypeAttr();
8644 case ParsedAttr::AT_ArmMveStrictPolymorphism: {
8646 attr.setUsedAsTypeAttr();
8649 case ParsedAttr::AT_RISCVRVVVectorBits:
8651 attr.setUsedAsTypeAttr();
8653 case ParsedAttr::AT_OpenCLAccess:
8655 attr.setUsedAsTypeAttr();
8657 case ParsedAttr::AT_LifetimeBound:
8662 case ParsedAttr::AT_NoDeref: {
8667 if (
attr.isStandardAttributeSyntax()) {
8668 state.getSema().Diag(
attr.getLoc(), diag::warn_attribute_ignored)
8673 type = state.getAttributedType(createSimpleAttr<NoDerefAttr>(Ctx,
attr),
8675 attr.setUsedAsTypeAttr();
8676 state.setParsedNoDeref(
true);
8680 case ParsedAttr::AT_MatrixType:
8682 attr.setUsedAsTypeAttr();
8685 case ParsedAttr::AT_WebAssemblyFuncref: {
8687 attr.setUsedAsTypeAttr();
8691 case ParsedAttr::AT_HLSLParamModifier: {
8693 attr.setUsedAsTypeAttr();
8699 attr.setUsedAsTypeAttr();
8707 if (
type->canHaveNullability() ||
type->isDependentType() ||
8708 type->isArrayType() ||
8712 endIndex = state.getCurrentChunkIndex();
8714 endIndex = state.getDeclarator().getNumTypeObjects();
8715 bool allowOnArrayType =
8716 state.getDeclarator().isPrototypeContext() &&
8719 allowOnArrayType)) {
8723 attr.setUsedAsTypeAttr();
8727 case ParsedAttr::AT_ObjCKindOf:
8735 state.getSema().Diag(
attr.getLoc(),
8736 diag::err_objc_kindof_wrong_position)
8739 state.getDeclarator().getDeclSpec().getBeginLoc(),
8749 case ParsedAttr::AT_NoThrow:
8752 if (!state.getSema().getLangOpts().CPlusPlus)
8756 attr.setUsedAsTypeAttr();
8760 if (
attr.isStandardAttributeSyntax() ||
8761 attr.isRegularKeywordAttribute()) {
8778 case ParsedAttr::AT_AcquireHandle: {
8779 if (!
type->isFunctionType())
8782 if (
attr.getNumArgs() != 1) {
8783 state.getSema().Diag(
attr.getLoc(),
8784 diag::err_attribute_wrong_number_arguments)
8790 StringRef HandleType;
8791 if (!state.getSema().checkStringLiteralArgumentAttr(
attr, 0, HandleType))
8793 type = state.getAttributedType(
8794 AcquireHandleAttr::Create(state.getSema().Context, HandleType,
attr),
8796 attr.setUsedAsTypeAttr();
8799 case ParsedAttr::AT_AnnotateType: {
8801 attr.setUsedAsTypeAttr();
8808 if (isa<AttributedType>(
type) &&
attr.hasMacroIdentifier() &&
8809 !
type.getQualifiers().hasObjCLifetime() &&
8810 !
type.getQualifiers().hasObjCGCAttr() &&
8811 attr.getKind() != ParsedAttr::AT_ObjCGC &&
8812 attr.getKind() != ParsedAttr::AT_ObjCOwnership) {
8814 type = state.getSema().Context.getMacroQualifiedType(
type, MacroII);
8815 state.setExpansionLocForMacroQualifiedType(
8816 cast<MacroQualifiedType>(
type.getTypePtr()),
8817 attr.getMacroExpansionLoc());
8824 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
8826 auto *Def = Var->getDefinition();
8832 Def = Var->getDefinition();
8839 if (Var->getPointOfInstantiation().isInvalid() && Def) {
8840 assert(Var->getTemplateSpecializationKind() ==
8842 "explicit instantiation with no point of instantiation");
8843 Var->setTemplateSpecializationKind(
8844 Var->getTemplateSpecializationKind(), PointOfInstantiation);
8864 if (
const auto CastE = dyn_cast<ExplicitCastExpr>(
E)) {
8865 QualType DestType = CastE->getTypeAsWritten();
8871 IAT->getElementType(),
8908 if (RequireCompleteTypeImpl(
Loc,
T, Kind, &Diagnoser))
8911 if (!Tag->getDecl()->isCompleteDefinitionRequired()) {
8912 Tag->getDecl()->setCompleteDefinitionRequired();
8942 if (isa<TagDecl>(
D) && cast<TagDecl>(
D)->isBeingDefined()) {
8946 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(
D)) {
8947 if (
auto *Pattern = RD->getTemplateInstantiationPattern())
8949 D = RD->getDefinition();
8950 }
else if (
auto *ED = dyn_cast<EnumDecl>(
D)) {
8951 if (
auto *Pattern = ED->getTemplateInstantiationPattern())
8953 if (OnlyNeedComplete && (ED->isFixed() ||
getLangOpts().MSVCCompat)) {
8959 *Suggested =
nullptr;
8960 for (
auto *Redecl : ED->redecls()) {
8963 if (Redecl->isThisDeclarationADefinition() ||
8964 (Redecl->isCanonicalDecl() && !*Suggested))
8965 *Suggested = Redecl;
8970 D = ED->getDefinition();
8971 }
else if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
8972 if (
auto *Pattern = FD->getTemplateInstantiationPattern())
8974 D = FD->getDefinition();
8975 }
else if (
auto *VD = dyn_cast<VarDecl>(
D)) {
8976 if (
auto *Pattern = VD->getTemplateInstantiationPattern())
8978 D = VD->getDefinition();
8981 assert(
D &&
"missing definition for pattern of instantiated definition");
8985 auto DefinitionIsAcceptable = [&] {
9005 if (DefinitionIsAcceptable())
9011 Source->CompleteRedeclChain(
D);
9012 return DefinitionIsAcceptable();
9028 bool OnlyNeedComplete) {
9045 bool OnlyNeedComplete) {
9053 if (!RD->
hasAttr<MSInheritanceAttr>()) {
9055 bool BestCase =
false;
9075 RD->
addAttr(MSInheritanceAttr::CreateImplicit(
9082 CompleteTypeKind Kind,
9083 TypeDiagnoser *Diagnoser) {
9093 if (!MPTy->getClass()->isDependentType()) {
9095 !MPTy->getClass()->getAsCXXRecordDecl()->isBeingDefined() &&
9097 diag::err_memptr_incomplete))
9116 if (Def && !isa<EnumDecl>(Def))
9127 if (Diagnoser && Suggested)
9130 return !TreatAsComplete;
9132 CodeSynthesisContext TempInst;
9134 TempInst.Template = Def;
9135 TempInst.Entity = Def;
9136 TempInst.PointOfInstantiation =
Loc;
9144 TagDecl *
Tag = dyn_cast_or_null<TagDecl>(Def);
9158 if (Tag &&
Tag->hasExternalLexicalStorage())
9159 Source->CompleteType(Tag);
9161 Source->CompleteType(IFace);
9165 return RequireCompleteTypeImpl(
Loc,
T, Kind, Diagnoser);
9172 if (
auto *RD = dyn_cast_or_null<CXXRecordDecl>(Tag)) {
9173 bool Instantiated =
false;
9174 bool Diagnosed =
false;
9175 if (RD->isDependentContext()) {
9179 }
else if (
auto *ClassTemplateSpec =
9180 dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
9181 if (ClassTemplateSpec->getSpecializationKind() ==
TSK_Undeclared) {
9187 Instantiated =
true;
9191 if (!RD->isBeingDefined() && Pattern) {
9193 assert(MSI &&
"Missing member specialization information?");
9203 Instantiated =
true;
9211 if (Diagnoser && Diagnosed)
9217 return RequireCompleteTypeImpl(
Loc,
T, Kind, Diagnoser);
9227 Diagnoser->diagnose(*
this,
Loc,
T);
9231 if (Tag && !
Tag->isInvalidDecl() && !
Tag->getLocation().isInvalid())
9233 Tag->isBeingDefined() ? diag::note_type_being_defined
9234 : diag::note_forward_declaration)
9268 default: llvm_unreachable(
"Invalid tag kind for literal type diagnostic!");
9312 for (
const auto &I : RD->
vbases())
9313 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
9314 << I.getSourceRange();
9317 Diag(RD->
getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD;
9319 for (
const auto &I : RD->
bases()) {
9320 if (!I.getType()->isLiteralType(
Context)) {
9321 Diag(I.getBeginLoc(), diag::note_non_literal_base_class)
9322 << RD << I.getType() << I.getSourceRange();
9326 for (
const auto *I : RD->
fields()) {
9327 if (!I->getType()->isLiteralType(
Context) ||
9328 I->getType().isVolatileQualified()) {
9329 Diag(I->getLocation(), diag::note_non_literal_field)
9330 << RD << I << I->getType()
9331 << I->getType().isVolatileQualified();
9341 assert(Dtor &&
"class has literal fields and bases but no dtor?");
9350 ? diag::note_non_literal_user_provided_dtor
9351 : diag::note_non_literal_nontrivial_dtor)
9396 auto *CountDecl = cast<DeclRefExpr>(
E)->getDecl();
9420 if (
auto *ImplCastExpr = dyn_cast<ImplicitCastExpr>(
E))
9421 IDExpr = ImplCastExpr->getSubExpr();
9423 if (
auto *PackExpr = dyn_cast<PackIndexingExpr>(
E)) {
9425 IDExpr = PackExpr->getPackIdExpression();
9427 IDExpr = PackExpr->getSelectedExpr();
9443 if (
const auto *SNTTPE = dyn_cast<SubstNonTypeTemplateParmExpr>(IDExpr))
9444 return SNTTPE->getParameterType(
Context);
9452 if (
const auto *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
9455 return isa<TemplateParamObjectDecl>(VD) ?
T.getUnqualifiedType() :
T;
9457 if (
const auto *ME = dyn_cast<MemberExpr>(IDExpr)) {
9458 if (
const auto *VD = ME->getMemberDecl())
9459 if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
9460 return VD->getType();
9461 }
else if (
const auto *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
9462 return IR->getDecl()->getType();
9463 }
else if (
const auto *PR = dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {
9464 if (PR->isExplicitProperty())
9465 return PR->getExplicitProperty()->getType();
9466 }
else if (
const auto *PE = dyn_cast<PredefinedExpr>(IDExpr)) {
9467 return PE->getType();
9478 if (
auto *DRE = dyn_cast<DeclRefExpr>(IDExpr->
IgnoreParens())) {
9479 if (
auto *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
9512 Diag(
Loc, diag::err_expected_name_of_pack) << Pattern;
9518 : diag::ext_pack_indexing);
9525 bool FullySubstituted,
9528 std::optional<int64_t> Index;
9536 Index =
Value.getExtValue();
9537 IndexExpr = Res.
get();
9540 if (FullySubstituted && Index) {
9541 if (*Index < 0 || *Index >= int64_t(Expansions.size())) {
9543 << *Index << Pattern << Expansions.size();
9549 Expansions, Index.value_or(-1));
9556 assert(ED &&
"EnumType has no EnumDecl");
9561 assert(!Underlying.
isNull());
9569 Diag(
Loc, diag::err_only_enums_have_underlying_types);
9577 Diag(
Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
9578 Diag(FwdDecl->
getLocation(), diag::note_forward_declaration) << FwdDecl;
9614 Split.Quals.removeCVRQualifiers();
9624 UKind == UnaryTransformType::AddLvalueReference,
9632 if (UKind == UnaryTransformType::RemoveAllExtents)
9636 return AT->getElementType();
9645 if (UKind == UTTKind::RemoveCVRef &&
9646 (
T.isConstQualified() ||
T.isVolatileQualified())) {
9658 if ((BaseType->
isReferenceType() && UKind != UTTKind::RemoveRestrict) ||
9665 if (UKind == UTTKind::RemoveConst || UKind == UTTKind::RemoveCV)
9667 if (UKind == UTTKind::RemoveVolatile || UKind == UTTKind::RemoveCV)
9669 if (UKind == UTTKind::RemoveRestrict)
9680 if (
auto *
BitInt = dyn_cast<BitIntType>(Underlying)) {
9681 unsigned int Bits =
BitInt->getNumBits();
9685 S.
Diag(
Loc, diag::err_make_signed_integral_only)
9686 << IsMakeSigned <<
true << BaseType << 1 << Underlying;
9690 S.
Diag(
Loc, diag::err_make_signed_integral_only)
9691 << IsMakeSigned <<
false << BaseType << 1
9698 std::array<CanQualType *, 6> AllSignedIntegers = {
9702 AllSignedIntegers.data(), AllSignedIntegers.size() - Int128Unsupported);
9703 std::array<CanQualType *, 6> AllUnsignedIntegers = {
9708 AllUnsignedIntegers.size() -
9711 IsMakeSigned ? &AvailableSignedIntegers : &AvailableUnsignedIntegers;
9715 llvm::find_if(*Consider, [&S, BaseSize](
const CanQual<Type> *
T) {
9719 assert(
Result != Consider->end());
9720 return QualType((*Result)->getTypePtr(), 0);
9725 bool IsMakeSigned = UKind == UnaryTransformType::MakeSigned;
9730 Diag(
Loc, diag::err_make_signed_integral_only)
9731 << IsMakeSigned << BaseType->
isBitIntType() << BaseType << 0;
9735 bool IsNonIntIntegral =
9755 case UnaryTransformType::EnumUnderlyingType: {
9759 case UnaryTransformType::AddPointer: {
9763 case UnaryTransformType::RemovePointer: {
9767 case UnaryTransformType::Decay: {
9771 case UnaryTransformType::AddLvalueReference:
9772 case UnaryTransformType::AddRvalueReference: {
9776 case UnaryTransformType::RemoveAllExtents:
9777 case UnaryTransformType::RemoveExtent: {
9781 case UnaryTransformType::RemoveCVRef:
9782 case UnaryTransformType::RemoveReference: {
9786 case UnaryTransformType::RemoveConst:
9787 case UnaryTransformType::RemoveCV:
9788 case UnaryTransformType::RemoveRestrict:
9789 case UnaryTransformType::RemoveVolatile: {
9793 case UnaryTransformType::MakeSigned:
9794 case UnaryTransformType::MakeUnsigned: {
9812 int DisallowedKind = -1;
9821 else if (
T.hasQualifiers())
9834 if (DisallowedKind != -1) {
9835 Diag(
Loc, diag::err_atomic_specifier_bad_type) << DisallowedKind <<
T;
Defines the clang::ASTContext interface.
Defines the C++ template declaration subclasses.
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
static QualType getUnderlyingType(const SubRegion *R)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
static void HandleNeonVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S, VectorKind VecKind)
HandleNeonVectorTypeAttr - The "neon_vector_type" and "neon_polyvector_type" attributes are used to c...
static QualType deduceOpenCLPointeeAddrSpace(Sema &S, QualType PointeeType)
static bool isPermittedNeonBaseType(QualType &Ty, VectorKind VecKind, Sema &S)
static void distributeObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType type)
Given that an objc_gc attribute was written somewhere on a declaration other than on the declarator i...
static void maybeSynthesizeBlockSignature(TypeProcessingState &state, QualType declSpecType)
Add a synthetic '()' to a block-literal declarator if it is required, given the return type.
#define MS_TYPE_ATTRS_CASELIST
#define CALLING_CONV_ATTRS_CASELIST
static void emitNullabilityConsistencyWarning(Sema &S, SimplePointerKind PointerKind, SourceLocation PointerLoc, SourceLocation PointerEndLoc)
static void fixItNullability(Sema &S, DiagBuilderT &Diag, SourceLocation PointerLoc, NullabilityKind Nullability)
Creates a fix-it to insert a C-style nullability keyword at pointerLoc, taking into account whitespac...
static ExprResult checkArraySize(Sema &S, Expr *&ArraySize, llvm::APSInt &SizeVal, unsigned VLADiag, bool VLAIsError)
Check whether the specified array bound can be evaluated using the relevant language rules.
static Attr * createNullabilityAttr(ASTContext &Ctx, ParsedAttr &Attr, NullabilityKind NK)
static void HandleVectorSizeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
HandleVectorSizeAttribute - this attribute is only applicable to integral and float scalars,...
static void inferARCWriteback(TypeProcessingState &state, QualType &declSpecType)
Given that this is the declaration of a parameter under ARC, attempt to infer attributes and such for...
static TypeSourceInfo * GetTypeSourceInfoForDeclarator(TypeProcessingState &State, QualType T, TypeSourceInfo *ReturnTypeInfo)
Create and instantiate a TypeSourceInfo with type source information.
static bool BuildAddressSpaceIndex(Sema &S, LangAS &ASIdx, const Expr *AddrSpace, SourceLocation AttrLoc)
Build an AddressSpace index from a constant expression and diagnose any errors related to invalid add...
static void HandleBTFTypeTagAttribute(QualType &Type, const ParsedAttr &Attr, TypeProcessingState &State)
static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, Qualifiers::ObjCLifetime ownership, unsigned chunkIndex)
static bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
handleObjCGCTypeAttr - Process the attribute((objc_gc)) type attribute on the specified type.
static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk)
static void HandleExtVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
Process the OpenCL-like ext_vector_type attribute when it occurs on a type.
static void HandleLifetimeBoundAttr(TypeProcessingState &State, QualType &CurType, ParsedAttr &Attr)
static bool handleArmStateAttribute(Sema &S, FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr, FunctionType::ArmStateValue State)
static void distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType, CUDAFunctionTarget CFT)
A function type attribute was written in the decl spec.
static bool handleObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
static QualType inferARCLifetimeForPointee(Sema &S, QualType type, SourceLocation loc, bool isReference)
Given that we're building a pointer or reference to the given.
static bool handleNonBlockingNonAllocatingTypeAttr(TypeProcessingState &TPState, ParsedAttr &PAttr, QualType &QT, FunctionTypeUnwrapper &Unwrapped)
static QualType ChangeIntegralSignedness(Sema &S, QualType BaseType, bool IsMakeSigned, SourceLocation Loc)
static bool CheckNullabilityTypeSpecifier(Sema &S, TypeProcessingState *State, ParsedAttr *PAttr, QualType &QT, NullabilityKind Nullability, SourceLocation NullabilityLoc, bool IsContextSensitive, bool AllowOnArrayType, bool OverrideExisting)
#define OBJC_POINTER_TYPE_ATTRS_CASELIST
static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr, QualType type)
diagnoseBadTypeAttribute - Diagnoses a type attribute which doesn't apply to the given type.
static PointerDeclaratorKind classifyPointerDeclarator(Sema &S, QualType type, Declarator &declarator, PointerWrappingDeclaratorKind &wrappingKind)
Classify the given declarator, whose type-specified is type, based on what kind of pointer it refers ...
static bool verifyValidIntegerConstantExpr(Sema &S, const ParsedAttr &Attr, llvm::APSInt &Result)
static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
static bool shouldHaveNullability(QualType T)
static void HandleArmMveStrictPolymorphismAttr(TypeProcessingState &State, QualType &CurType, ParsedAttr &Attr)
static void warnAboutAmbiguousFunction(Sema &S, Declarator &D, DeclaratorChunk &DeclType, QualType RT)
Produce an appropriate diagnostic for an ambiguity between a function declarator and a C++ direct-ini...
static void distributeObjCPointerTypeAttrFromDeclarator(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType)
Distribute an objc_gc type attribute that was written on the declarator.
static FileID getNullabilityCompletenessCheckFileID(Sema &S, SourceLocation loc)
static void HandleArmSveVectorBitsTypeAttr(QualType &CurType, ParsedAttr &Attr, Sema &S)
HandleArmSveVectorBitsTypeAttr - The "arm_sve_vector_bits" attribute is used to create fixed-length v...
#define FUNCTION_TYPE_ATTRS_CASELIST
static bool distributeNullabilityTypeAttr(TypeProcessingState &state, QualType type, ParsedAttr &attr)
Distribute a nullability type attribute that cannot be applied to the type specifier to a pointer,...
static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state, QualType &declSpecType, CUDAFunctionTarget CFT)
Given that there are attributes written on the declarator or declaration itself, try to distribute an...
static bool isDependentOrGNUAutoType(QualType T)
static void distributeFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType type)
A function type attribute was written somewhere in a declaration other than on the declarator itself ...
static void HandleMatrixTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
HandleMatrixTypeAttr - "matrix_type" attribute, like ext_vector_type.
static bool HandleWebAssemblyFuncrefAttr(TypeProcessingState &State, QualType &QT, ParsedAttr &PAttr)
static bool hasOuterPointerLikeChunk(const Declarator &D, unsigned endIndex)
Returns true if any of the declarator chunks before endIndex include a level of indirection: array,...
static void HandleOpenCLAccessAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
Handle OpenCL Access Qualifier Attribute.
static NullabilityKind mapNullabilityAttrKind(ParsedAttr::Kind kind)
Map a nullability attribute kind to a nullability kind.
static bool distributeFunctionTypeAttrToInnermost(TypeProcessingState &state, ParsedAttr &attr, ParsedAttributesView &attrList, QualType &declSpecType, CUDAFunctionTarget CFT)
Try to distribute a function type attribute to the innermost function chunk or type.
#define NULLABILITY_TYPE_ATTRS_CASELIST
static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, TypeSourceInfo *&ReturnTypeInfo)
static void checkNullabilityConsistency(Sema &S, SimplePointerKind pointerKind, SourceLocation pointerLoc, SourceLocation pointerEndLoc=SourceLocation())
Complains about missing nullability if the file containing pointerLoc has other uses of nullability (...
static void transferARCOwnership(TypeProcessingState &state, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership)
Used for transferring ownership in casts resulting in l-values.
static std::string getPrintableNameForEntity(DeclarationName Entity)
static std::string getFunctionQualifiersAsString(const FunctionProtoType *FnTy)
static QualType rebuildAttributedTypeWithoutNullability(ASTContext &Ctx, QualType Type)
Rebuild an attributed type without the nullability attribute on it.
static DeclaratorChunk * maybeMovePastReturnType(Declarator &declarator, unsigned i, bool onlyBlockPointers)
Given the index of a declarator chunk, check whether that chunk directly specifies the return type of...
static OpenCLAccessAttr::Spelling getImageAccess(const ParsedAttributesView &Attrs)
static void fillMatrixTypeLoc(MatrixTypeLoc MTL, const ParsedAttributesView &Attrs)
static UnaryTransformType::UTTKind TSTToUnaryTransformType(DeclSpec::TST SwitchTST)
static void HandleRISCVRVVVectorBitsTypeAttr(QualType &CurType, ParsedAttr &Attr, Sema &S)
HandleRISCVRVVVectorBitsTypeAttr - The "riscv_rvv_vector_bits" attribute is used to create fixed-leng...
static void HandleAddressSpaceTypeAttribute(QualType &Type, const ParsedAttr &Attr, TypeProcessingState &State)
HandleAddressSpaceTypeAttribute - Process an address_space attribute on the specified type.
static bool checkQualifiedFunction(Sema &S, QualType T, SourceLocation Loc, QualifiedFunctionKind QFK)
Check whether the type T is a qualified function type, and if it is, diagnose that it cannot be conta...
static bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator, QualType Result)
Return true if this is omitted block return type.
static bool DiagnoseMultipleAddrSpaceAttributes(Sema &S, LangAS ASOld, LangAS ASNew, SourceLocation AttrLoc)
static void warnAboutRedundantParens(Sema &S, Declarator &D, QualType T)
Produce an appropriate diagnostic for a declarator with top-level parentheses.
static QualType ConvertDeclSpecToType(TypeProcessingState &state)
Convert the specified declspec to the appropriate type object.
static std::pair< QualType, TypeSourceInfo * > InventTemplateParameter(TypeProcessingState &state, QualType T, TypeSourceInfo *TrailingTSI, AutoType *Auto, InventedTemplateParameterInfo &Info)
static void distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType, CUDAFunctionTarget CFT)
A function type attribute was written on the declarator or declaration.
static void diagnoseAndRemoveTypeQualifiers(Sema &S, const DeclSpec &DS, unsigned &TypeQuals, QualType TypeSoFar, unsigned RemoveTQs, unsigned DiagID)
static CallingConv getCCForDeclaratorChunk(Sema &S, Declarator &D, const ParsedAttributesView &AttrList, const DeclaratorChunk::FunctionTypeInfo &FTI, unsigned ChunkIndex)
Helper for figuring out the default CC for a function declarator type.
static unsigned getLiteralDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for literal type diagnostic message.
static void recordNullabilitySeen(Sema &S, SourceLocation loc)
Marks that a nullability feature has been used in the file containing loc.
static void HandleHLSLParamModifierAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
static void checkExtParameterInfos(Sema &S, ArrayRef< QualType > paramTypes, const FunctionProtoType::ExtProtoInfo &EPI, llvm::function_ref< SourceLocation(unsigned)> getParamLoc)
Check the extended parameter information.
static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type, CUDAFunctionTarget CFT)
Process an individual function attribute.
static void transferARCOwnershipToDeclSpec(Sema &S, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership)
static void BuildTypeCoupledDecls(Expr *E, llvm::SmallVectorImpl< TypeCoupledDeclRefInfo > &Decls)
static void assignInheritanceModel(Sema &S, CXXRecordDecl *RD)
Locks in the inheritance model for the given class and all of its bases.
static bool checkObjCKindOfType(TypeProcessingState &state, QualType &type, ParsedAttr &attr)
Check the application of the Objective-C '__kindof' qualifier to the given type.
static bool hasNullabilityAttr(const ParsedAttributesView &attrs)
Check whether there is a nullability attribute of any kind in the given attribute list.
static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
handleObjCOwnershipTypeAttr - Process an objc_ownership attribute on the specified type.
static void moveAttrFromListToList(ParsedAttr &attr, ParsedAttributesView &fromList, ParsedAttributesView &toList)
static void HandleAnnotateTypeAttr(TypeProcessingState &State, QualType &CurType, const ParsedAttr &PA)
static void fillAttributedTypeLoc(AttributedTypeLoc TL, TypeProcessingState &State)
static void fillDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc DASTL, const ParsedAttributesView &Attrs)
TypeAttrLocation
The location of a type attribute.
@ TAL_DeclChunk
The attribute is part of a DeclaratorChunk.
@ TAL_DeclSpec
The attribute is in the decl-specifier-seq.
@ TAL_DeclName
The attribute is immediately after the declaration's name.
static bool isOmittedBlockReturnType(const Declarator &D)
isOmittedBlockReturnType - Return true if this declarator is missing a return type because this is a ...
static TypeSourceInfo * GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo)
static QualType GetEnumUnderlyingType(Sema &S, QualType BaseType, SourceLocation Loc)
static bool IsNoDerefableChunk(const DeclaratorChunk &Chunk)
static AttrT * createSimpleAttr(ASTContext &Ctx, ParsedAttr &AL)
static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy, Declarator &D, unsigned FunctionChunkIndex)
static void processTypeAttrs(TypeProcessingState &state, QualType &type, TypeAttrLocation TAL, const ParsedAttributesView &attrs, CUDAFunctionTarget CFT=CUDAFunctionTarget::HostDevice)
static bool checkMutualExclusion(TypeProcessingState &state, const FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr, AttributeCommonInfo::Kind OtherKind)
static Attr * getCCTypeAttr(ASTContext &Ctx, ParsedAttr &Attr)
Defines the clang::SourceLocation class and associated facilities.
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
__DEVICE__ int max(int __a, int __b)
virtual void HandleTagDeclRequiredDefinition(const TagDecl *D)
This callback is invoked the first time each TagDecl is required to be complete.
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
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...
TranslationUnitDecl * getTranslationUnitDecl() const
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
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 getDependentSizedMatrixType(QualType ElementType, Expr *RowExpr, Expr *ColumnExpr, SourceLocation AttrLoc) const
Return the unique reference to the matrix type of the specified element type and size.
unsigned getIntWidth(QualType T) const
QualType getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr, QualType Wrapped)
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false, ConceptDecl *TypeConstraintConcept=nullptr, ArrayRef< TemplateArgument > TypeConstraintArgs={}) const
C++11 deduced auto type.
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
QualType getCountAttributedType(QualType T, Expr *CountExpr, bool CountInBytes, bool OrNull, ArrayRef< TypeCoupledDeclRefInfo > DependentDecls) const
QualType getPackExpansionType(QualType Pattern, std::optional< unsigned > NumExpansions, bool ExpectPackInType=true)
Form a pack expansion type with the given pattern.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
QualType getDependentVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc, VectorKind VecKind) const
Return the unique reference to the type for a dependently sized vector of the specified element 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 getReadPipeType(QualType T) const
Return a read_only pipe type for the specified type.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
QualType getDependentBitIntType(bool Unsigned, Expr *BitsExpr) const
Return a dependent bit-precise integer type with the specified signedness and bit count.
QualType getReferenceQualifiedType(const Expr *e) const
getReferenceQualifiedType - Given an expr, will return the type for that expression,...
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
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 getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const
Get a function type and produce the equivalent function type with the specified exception specificati...
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
const TargetInfo * getAuxTargetInfo() const
CanQualType UnsignedLongTy
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType getCorrespondingSaturatedType(QualType Ty) const
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
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 getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
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.
LangAS getDefaultOpenCLPointeeAddrSpace()
Returns default address space based on OpenCL version and enabled features.
const clang::PrintingPolicy & getPrintingPolicy() const
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
QualType getUnsignedWCharType() const
Return the type of "unsigned wchar_t".
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
QualType getWritePipeType(QualType T) const
Return a write_only pipe type for the specified type.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CanQualType UnsignedInt128Ty
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type.
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
CanQualType UnsignedLongLongTy
CanQualType UnsignedShortTy
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
QualType getDependentAddressSpaceType(QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttrLoc) const
QualType getPackIndexingType(QualType Pattern, Expr *IndexExpr, bool FullySubstituted=false, ArrayRef< QualType > Expansions={}, int Index=-1) const
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind UKind) const
Unary type transforms.
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const
Recurses in pointer/array types until it finds an Objective-C retainable type and returns its ownersh...
DiagnosticsEngine & getDiagnostics() const
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
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 getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
QualType getCorrespondingUnsignedType(QualType T) const
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
QualType getTypeOfType(QualType QT, TypeOfKind Kind) const
getTypeOfType - Unlike many "get<Type>" functions, we don't unique TypeOfType nodes.
QualType getCorrespondingSignedType(QualType T) const
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const
Return the uniqued reference to the type for an Objective-C gc-qualified type.
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const
C++11 decltype.
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 getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
QualType getTypeOfExprType(Expr *E, TypeOfKind Kind) const
C23 feature and GCC extension.
QualType getSignedWCharType() const
Return the type of "signed wchar_t".
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
QualType getBitIntType(bool Unsigned, unsigned NumBits) const
Return a bit-precise integer type with the specified signedness and bit count.
Wrapper for source info for array parameter types.
Wrapper for source info for arrays.
void setLBracketLoc(SourceLocation Loc)
void setRBracketLoc(SourceLocation Loc)
void setSizeExpr(Expr *Size)
TypeLoc getValueLoc() const
void setKWLoc(SourceLocation Loc)
void setParensRange(SourceRange Range)
Attr - This represents one attribute.
attr::Kind getKind() const
const char * getSpelling() const
SourceRange getRange() const
bool isContextSensitiveKeywordAttribute() const
bool isRegularKeywordAttribute() const
SourceLocation getLoc() const
const IdentifierInfo * getAttrName() const
Type source information for an attributed type.
TypeLoc getModifiedLoc() const
The modified type, which is generally canonically different from the attribute type.
void setAttr(const Attr *A)
An attributed type is a type to which a type attribute has been applied.
QualType getModifiedType() const
bool isCallingConv() const
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
static std::optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
bool hasExplicitTemplateArgs() const
const NestedNameSpecifierLoc getNestedNameSpecifierLoc() const
SourceLocation getRAngleLoc() const
ConceptDecl * getNamedConcept() const
SourceLocation getLAngleLoc() const
void setConceptReference(ConceptReference *CR)
NamedDecl * getFoundDecl() const
TemplateArgumentLoc getArgLoc(unsigned i) const
unsigned getNumArgs() const
DeclarationNameInfo getConceptNameInfo() const
void setRParenLoc(SourceLocation Loc)
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
bool isDecltypeAuto() const
ConceptDecl * getTypeConstraintConcept() const
Type source information for an btf_tag attributed type.
TypeLoc getWrappedLoc() const
Comparison function object.
A fixed int type of a specified bitwidth.
unsigned getNumBits() const
Wrapper for source info for block pointers.
void setCaretLoc(SourceLocation Loc)
Wrapper for source info for builtin types.
TypeSpecifierWidth getWrittenWidthSpec() const
bool needsExtraLocalData() const
void setBuiltinLoc(SourceLocation Loc)
WrittenBuiltinSpecs & getWrittenBuiltinSpecs()
TypeSpecifierSign getWrittenSignSpec() const
void expandBuiltinRange(SourceRange Range)
This class is used for builtin types like 'int'.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
bool isAggregate() const
Determine whether this class is an aggregate (C++ [dcl.init.aggr]), which is a class with no user-dec...
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
bool isLambda() const
Determine whether this class describes a lambda function object.
bool hasConstexprNonCopyMoveConstructor() const
Determine whether this class has at least one constexpr constructor other than the copy or move const...
bool hasConstexprDestructor() const
Determine whether this class has a constexpr destructor.
bool hasNonLiteralTypeFieldsOrBases() const
Determine whether this class has a non-literal or/ volatile type non-static data member or base class...
CXXRecordDecl * getMostRecentNonInjectedDecl()
base_class_range vbases()
bool hasUserProvidedDefaultConstructor() const
Whether this class has a user-provided default constructor per C++11.
bool hasDefinition() const
MSInheritanceModel calculateInheritanceModel() const
Calculate what the inheritance model would be for this class.
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Represents a C++ nested-name-specifier or a global scope specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
SourceRange getRange() const
SourceLocation getBeginLoc() const
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Represents a canonical, potentially-qualified type.
SourceLocation getBegin() const
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a C++20 concept.
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten)
const TypeClass * getTypePtr() const
TypeLoc getNextTypeLoc() const
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...
static constexpr bool isDimensionValid(size_t NumElements)
Returns true if NumElements is a valid matrix dimension.
Wrapper for source info for pointers decayed from arrays and functions.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
bool isFunctionOrMethod() const
A reference to a declared variable, function, enum, etc.
Captures information about "declaration specifiers".
const WrittenBuiltinSpecs & getWrittenBuiltinSpecs() const
bool isTypeSpecPipe() const
static const TST TST_typeof_unqualType
SourceLocation getTypeSpecSignLoc() const
static const TST TST_typename
SourceLocation getEndLoc() const LLVM_READONLY
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
static const TST TST_char8
static const TST TST_BFloat16
Expr * getPackIndexingExpr() const
TST getTypeSpecType() const
SCS getStorageClassSpec() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isTypeSpecSat() const
SourceRange getSourceRange() const LLVM_READONLY
static const TST TST_auto_type
static const TST TST_interface
static const TST TST_double
static const TST TST_typeofExpr
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
TemplateIdAnnotation * getRepAsTemplateId() const
static const TST TST_union
static const TST TST_typename_pack_indexing
static const TST TST_char
static const TST TST_bool
static const TST TST_char16
static const TST TST_unknown_anytype
TSC getTypeSpecComplex() const
ParsedType getRepAsType() const
static const TST TST_accum
static const TST TST_half
ParsedAttributes & getAttributes()
SourceLocation getEllipsisLoc() const
bool isTypeAltiVecPixel() const
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
SourceLocation getConstSpecLoc() const
static const TST TST_ibm128
Expr * getRepAsExpr() const
static const TST TST_enum
static const TST TST_float128
static const TST TST_decltype
SourceRange getTypeSpecWidthRange() const
SourceLocation getTypeSpecTypeNameLoc() const
SourceLocation getTypeSpecWidthLoc() const
SourceLocation getRestrictSpecLoc() const
static const TST TST_typeof_unqualExpr
static const TST TST_class
static const TST TST_decimal64
bool isTypeAltiVecBool() const
bool isConstrainedAuto() const
static const TST TST_wchar
SourceLocation getTypeSpecComplexLoc() const
static const TST TST_void
bool isTypeAltiVecVector() const
static const TST TST_bitint
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
static const TST TST_float
static const TST TST_atomic
static const TST TST_fract
Decl * getRepAsDecl() const
static const TST TST_float16
static bool isTransformTypeTrait(TST T)
static const TST TST_unspecified
SourceLocation getAtomicSpecLoc() const
TypeSpecifierSign getTypeSpecSign() const
CXXScopeSpec & getTypeSpecScope()
SourceLocation getTypeSpecTypeLoc() const
static const TST TST_decltype_auto
static const TST TST_error
void forEachQualifier(llvm::function_ref< void(TQ, StringRef, SourceLocation)> Handle)
This method calls the passed in handler on each qual being set.
static const TST TST_decimal32
TypeSpecifierWidth getTypeSpecWidth() const
static const TST TST_char32
static const TST TST_decimal128
bool isTypeSpecOwned() const
SourceLocation getTypeSpecSatLoc() const
SourceRange getTypeofParensRange() const
static const TST TST_int128
SourceLocation getVolatileSpecLoc() const
static const TST TST_typeofType
static const TST TST_auto
static const TST TST_struct
Decl - This represents one declaration (or definition), e.g.
SourceLocation getEndLoc() const LLVM_READONLY
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined.
ASTContext & getASTContext() const LLVM_READONLY
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Kind
Lists the kind of concrete classes of Decl.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setImplicit(bool I=true)
SourceLocation getBeginLoc() const LLVM_READONLY
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
The name of a declaration.
std::string getAsString() const
Retrieve the human-readable string for this name.
NameKind getNameKind() const
Determine what kind of name this is.
Information about one declarator, including the parsed type information and the identifier.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
void AddInnermostTypeInfo(const DeclaratorChunk &TI)
Add a new innermost chunk to this declarator.
const ParsedAttributes & getAttributes() const
SourceLocation getIdentifierLoc() const
void setInvalidType(bool Val=true)
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
const ParsedAttributesView & getDeclarationAttributes() const
DeclaratorContext getContext() const
SourceLocation getBeginLoc() const LLVM_READONLY
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
void setRParenLoc(SourceLocation Loc)
void setDecltypeLoc(SourceLocation Loc)
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
void setAttrNameLoc(SourceLocation loc)
void setAttrOperandParensRange(SourceRange range)
void setAttrExprOperand(Expr *e)
Represents an extended address space qualifier where the input address space value is dependent.
void copy(DependentNameTypeLoc Loc)
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
void setNameLoc(SourceLocation Loc)
void copy(DependentTemplateSpecializationTypeLoc Loc)
void setNameLoc(SourceLocation Loc)
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
bool getSuppressSystemWarnings() const
Wrap a function effect's condition expression in another struct so that FunctionProtoType's TrailingO...
void copy(ElaboratedTypeLoc Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
TypeLoc getNamedTypeLoc() const
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
This represents one expression.
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
A SourceLocation and its associated SourceManager.
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration.
A mutable set of FunctionEffects and possibly conditions attached to them.
bool insert(const FunctionEffectWithCondition &NewEC, Conflicts &Errs)
Represents an abstract function effect, using just an enumeration describing its kind.
Kind
Identifies the particular effect.
An immutable set of FunctionEffects and possibly conditions attached to them.
Represents a prototype with parameter type info, e.g.
Qualifiers getMethodQuals() const
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Wrapper for source info for functions.
unsigned getNumParams() const
void setLocalRangeBegin(SourceLocation L)
void setLParenLoc(SourceLocation Loc)
void setParam(unsigned i, ParmVarDecl *VD)
void setRParenLoc(SourceLocation Loc)
void setLocalRangeEnd(SourceLocation L)
void setExceptionSpecRange(SourceRange R)
A class which abstracts out some details necessary for making a call.
ExtInfo withNoCfCheck(bool noCfCheck) const
ExtInfo withCallingConv(CallingConv cc) const
CallingConv getCC() const
ExtInfo withProducesResult(bool producesResult) const
ExtInfo withNoReturn(bool noReturn) const
bool getProducesResult() const
ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const
ExtInfo withCmseNSCall(bool cmseNSCall) const
ExtInfo withRegParm(unsigned RegParm) const
ParameterABI getABI() const
Return the ABI treatment of this parameter.
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
static StringRef getNameForCallConv(CallingConv CC)
static ArmStateValue getArmZT0State(unsigned AttrBits)
static ArmStateValue getArmZAState(unsigned AttrBits)
CallingConv getCallConv() const
QualType getReturnType() const
bool getHasRegParm() const
AArch64SMETypeAttributes
The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number of function type attributes that...
@ SME_PStateSMEnabledMask
@ SME_PStateSMCompatibleMask
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.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void setAmpLoc(SourceLocation Loc)
An lvalue reference type, per C++11 [dcl.ref].
@ PPTMK_FullGeneralityMultipleInheritance
@ PPTMK_FullGeneralityVirtualInheritance
@ PPTMK_FullGeneralitySingleInheritance
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool requiresStrictPrototypes() const
Returns true if functions without prototypes or functions with an identifier list (aka K&R C function...
bool isImplicitIntAllowed() const
Returns true if implicit int is supported at all.
bool isImplicitIntRequired() const
Returns true if implicit int is part of the language requirements.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
Represents the results of name lookup.
TypeLoc getInnerLoc() const
void setExpansionLoc(SourceLocation Loc)
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.
void setAttrRowOperand(Expr *e)
void setAttrColumnOperand(Expr *e)
void setAttrOperandParensRange(SourceRange range)
void setAttrNameLoc(SourceLocation loc)
static bool isValidElementType(QualType T)
Valid elements types are the following:
Wrapper for source info for member pointers.
void setStarLoc(SourceLocation Loc)
void setClassTInfo(TypeSourceInfo *TI)
const Type * getClass() const
A pointer to member type per C++ 8.3.3 - Pointers to members.
QualType getPointeeType() const
const Type * getClass() const
Provides information a specialization of a member of a class template, which may be a member function...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
This represents a decl that may have a name.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
A C++ nested-name-specifier augmented with source location information.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
SourceLocation getLocalBeginLoc() const
Retrieve the location of the beginning of this component of the nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
Represents an ObjC class declaration.
Wrapper for source info for ObjC interfaces.
void setNameLoc(SourceLocation Loc)
void setNameEndLoc(SourceLocation Loc)
Interfaces are the core concept in Objective-C for object oriented design.
Wraps an ObjCPointerType with source location information.
void setStarLoc(SourceLocation Loc)
Represents a pointer to an Objective C object.
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Represents a class type in Objective C.
static OpaquePtr make(QualType P)
OpenCL supported extensions and optional core features.
bool isAvailableOption(llvm::StringRef Ext, const LangOptions &LO) const
bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const
void setEllipsisLoc(SourceLocation Loc)
A parameter attribute which changes the argument-passing ABI rule for the parameter.
void setRParenLoc(SourceLocation Loc)
void setLParenLoc(SourceLocation Loc)
Represents a parameter to a function.
void setKNRPromoted(bool promoted)
ParsedAttr - Represents a syntactic attribute.
void setInvalid(bool b=true) const
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this attribute.
bool isArgIdent(unsigned Arg) const
Expr * getArgAsExpr(unsigned Arg) const
AttributeCommonInfo::Kind getKind() const
void setUsedAsTypeAttr(bool Used=true)
bool checkAtMostNumArgs(class Sema &S, unsigned Num) const
Check if the attribute has at most as many args as Num.
void addAtEnd(ParsedAttr *newAttr)
bool hasAttribute(ParsedAttr::Kind K) const
void remove(ParsedAttr *ToBeRemoved)
void takeOneFrom(ParsedAttributes &Other, ParsedAttr *PA)
TypeLoc getValueLoc() const
void setKWLoc(SourceLocation Loc)
Wrapper for source info for pointers.
void setStarLoc(SourceLocation Loc)
PointerType - C99 6.7.5.1 - Pointer Declarators.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
SourceLocation getPragmaAssumeNonNullLoc() const
The location of the currently-active #pragma clang assume_nonnull begin.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
bool isReferenceable() const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
SplitQualType getSplitUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Wrapper of type source information for a type with non-trivial direct qualifiers.
UnqualTypeLoc getUnqualifiedLoc() const
The collection of all-type qualifiers we support.
void removeCVRQualifiers(unsigned mask)
void addAddressSpace(LangAS space)
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
void removeObjCLifetime()
void addCVRUQualifiers(unsigned mask)
static Qualifiers fromCVRMask(unsigned CVR)
void setUnaligned(bool flag)
std::string getAsString() const
@ MaxAddressSpace
The maximum supported address space number.
void addObjCLifetime(ObjCLifetime type)
void setAmpAmpLoc(SourceLocation Loc)
Represents a struct/union/class.
field_range fields() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
bool isSpelledAsLValue() const
bool isFunctionDeclarationScope() const
isFunctionDeclarationScope - Return true if this scope is a function prototype scope.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
bool isCFError(RecordDecl *D)
IdentifierInfo * getNSErrorIdent()
Retrieve the identifier "NSError".
bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type)
bool isInOpenMPTaskUntiedContext() const
Return true if currently in OpenMP task with untied clause context.
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
Abstract base class used for diagnosing integer constant expression violations.
Sema - This implements semantic analysis and AST building for C.
bool hasReachableDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a reachable definition.
QualType BuildParenType(QualType T)
Build a paren type including T.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
bool ConstantFoldAttrArgs(const AttributeCommonInfo &CI, MutableArrayRef< Expr * > Args)
ConstantFoldAttrArgs - Folds attribute arguments into ConstantExprs (unless they are value dependent ...
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Scope * getCurScope() const
Retrieve the parser's current scope.
bool hasStructuralCompatLayout(Decl *D, Decl *Suggested)
Determine if D and Suggested have a structurally compatible layout as described in C11 6....
bool checkArrayElementAlignment(QualType EltTy, SourceLocation Loc)
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace, SourceLocation AttrLoc)
BuildAddressSpaceAttr - Builds a DependentAddressSpaceType if an expression is uninstantiated.
QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement)
Completely replace the auto in TypeWithAuto by Replacement.
QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc)
std::optional< FunctionEffectMode > ActOnEffectExpression(Expr *CondExpr, StringRef AttributeName)
Try to parse the conditional expression attached to an effect attribute (e.g.
@ AcceptSizeless
Relax the normal rules for complete types so that they include sizeless built-in types.
class clang::Sema::DelayedDiagnostics DelayedDiagnostics
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
QualType BuildExtVectorType(QualType T, Expr *ArraySize, SourceLocation AttrLoc)
Build an ext-vector type.
const AttributedType * getCallingConvAttributedType(QualType T) const
Get the outermost AttributedType node that sets a calling convention.
bool hasMergedDefinitionInCurrentModule(const NamedDecl *Def)
QualType BuildFunctionType(QualType T, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc, DeclarationName Entity, const FunctionProtoType::ExtProtoInfo &EPI)
Build a function type.
bool diagnoseConflictingFunctionEffect(const FunctionEffectsRef &FX, const FunctionEffectWithCondition &EC, SourceLocation NewAttrLoc)
Warn and return true if adding an effect to a set would create a conflict.
void checkSpecializationReachability(SourceLocation Loc, NamedDecl *Spec)
ASTContext & getASTContext() const
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
void checkExceptionSpecification(bool IsTopLevel, ExceptionSpecificationType EST, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr, SmallVectorImpl< QualType > &Exceptions, FunctionProtoType::ExceptionSpecInfo &ESI)
Check the given exception-specification and update the exception specification information with the r...
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC, const FunctionDecl *FD=nullptr, CUDAFunctionTarget CFT=CUDAFunctionTarget::InvalidTarget)
Check validaty of calling convention attribute attr.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
QualType BuildCountAttributedArrayOrPointerType(QualType WrappedTy, Expr *CountExpr, bool CountInBytes, bool OrNull)
std::string getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const
Get a string to suggest for zero-initialization of a type.
bool CheckAttrNoArgs(const ParsedAttr &CurrAttr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
QualType BuildBitIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc)
Build a bit-precise integer type.
LangAS getDefaultCXXMethodAddrSpace() const
Returns default addr space for method qualifiers.
QualType BuiltinRemoveReference(QualType BaseType, UTTKind UKind, SourceLocation Loc)
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
bool CheckFunctionReturnType(QualType T, SourceLocation Loc)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_TypeConstraint
A type constraint.
const LangOptions & getLangOpts() const
bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type of the given expression is complete.
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
QualType BuiltinEnumUnderlyingType(QualType BaseType, SourceLocation Loc)
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
const LangOptions & LangOpts
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
IdentifierInfo * InventAbbreviatedTemplateParameterTypeName(const IdentifierInfo *ParamName, unsigned Index)
Invent a new identifier for parameters of abbreviated templates.
SourceLocation ImplicitMSInheritanceAttrLoc
Source location for newly created implicit MSInheritanceAttrs.
SmallVector< InventedTemplateParameterInfo, 4 > InventedParameterInfos
Stack containing information needed when in C++2a an 'auto' is encountered in a function declaration ...
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
void completeExprArrayBound(Expr *E)
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
bool hasExplicitCallingConv(QualType T)
bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value)
Checks a regparm attribute, returning true if it is ill-formed and otherwise setting numParams to the...
FileNullabilityMap NullabilityMap
A mapping that describes the nullability we've seen in each header file.
sema::FunctionScopeInfo * getCurFunction() const
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
ExprResult DefaultLvalueConversion(Expr *E)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
QualType BuiltinDecay(QualType BaseType, SourceLocation Loc)
IdentifierInfo * getNullabilityKeyword(NullabilityKind nullability)
Retrieve the keyword associated.
@ TAH_IgnoreTrivialABI
The triviality of a method unaffected by "trivial_abi".
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
bool isAcceptable(const NamedDecl *D, AcceptableKind Kind)
Determine whether a declaration is acceptable (visible/reachable).
QualType getDecltypeForExpr(Expr *E)
getDecltypeForExpr - Given an expr, will return the decltype for that expression, according to the ru...
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
QualType BuiltinAddReference(QualType BaseType, UTTKind UKind, SourceLocation Loc)
bool hasVisibleMergedDefinition(const NamedDecl *Def)
QualType BuildPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc, bool FullySubstituted=false, ArrayRef< QualType > Expansions={})
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
QualType BuildAtomicType(QualType T, SourceLocation Loc)
void diagnoseMissingImport(SourceLocation Loc, const NamedDecl *Decl, MissingImportKind MIK, bool Recover=true)
Diagnose that the specified declaration needs to be visible but isn't, and suggest a module import th...
TypeSourceInfo * ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, QualType Replacement)
TypeResult ActOnTypeName(Declarator &D)
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
void checkUnusedDeclAttributes(Declarator &D)
checkUnusedDeclAttributes - Given a declarator which is not being used to build a declaration,...
QualType BuildPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a pointer type.
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
bool CheckAttrTarget(const ParsedAttr &CurrAttr)
QualType BuiltinAddPointer(QualType BaseType, SourceLocation Loc)
@ CCEK_ArrayBound
Array bound in array declarator or new-expression.
bool CheckImplicitNullabilityTypeSpecifier(QualType &Type, NullabilityKind Nullability, SourceLocation DiagLoc, bool AllowArrayTypes, bool OverrideExisting)
Check whether a nullability type specifier can be added to the given type through some means not writ...
void CheckConstrainedAuto(const AutoType *AutoT, SourceLocation Loc)
bool CheckDistantExceptionSpec(QualType T)
CheckDistantExceptionSpec - Check if the given type is a pointer or pointer to member to a function w...
QualType BuildDecltypeType(Expr *E, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
QualType BuildUnaryTransformType(QualType BaseType, UTTKind UKind, SourceLocation Loc)
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
TypeSourceInfo * GetTypeForDeclaratorCast(Declarator &D, QualType FromTy)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
QualType getCapturedDeclRefType(ValueDecl *Var, SourceLocation Loc)
Given a variable, determine the type that a reference to that variable will have in the given scope.
QualType BuiltinRemoveExtent(QualType BaseType, UTTKind UKind, SourceLocation Loc)
QualType getCompletedType(Expr *E)
Get the type of expression E, triggering instantiation to complete the type if necessary – that is,...
QualType BuiltinChangeCVRQualifiers(QualType BaseType, UTTKind UKind, SourceLocation Loc)
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
SourceManager & SourceMgr
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
QualType BuiltinRemovePointer(QualType BaseType, SourceLocation Loc)
QualType BuildArrayType(QualType T, ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity)
Build an array type.
bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc)
QualType BuildReadPipeType(QualType T, SourceLocation Loc)
Build a Read-only Pipe type.
void diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, SourceLocation FallbackLoc, SourceLocation ConstQualLoc=SourceLocation(), SourceLocation VolatileQualLoc=SourceLocation(), SourceLocation RestrictQualLoc=SourceLocation(), SourceLocation AtomicQualLoc=SourceLocation(), SourceLocation UnalignedQualLoc=SourceLocation())
LangOptions::PragmaMSPointersToMembersKind MSPointerToMemberRepresentationMethod
Controls member pointer representation format under the MS ABI.
llvm::BumpPtrAllocator BumpAlloc
QualType BuildWritePipeType(QualType T, SourceLocation Loc)
Build a Write-only Pipe type.
QualType ActOnPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc)
QualType BuildTypeofExprType(Expr *E, TypeOfKind Kind)
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
QualType BuildMatrixType(QualType T, Expr *NumRows, Expr *NumColumns, SourceLocation AttrLoc)
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)
bool hasAcceptableDefinition(NamedDecl *D, NamedDecl **Suggested, AcceptableKind Kind, bool OnlyNeedComplete=false)
QualType BuiltinChangeSignedness(QualType BaseType, UTTKind UKind, SourceLocation Loc)
void adjustMemberFunctionCC(QualType &T, bool HasThisPointer, bool IsCtorOrDtor, SourceLocation Loc)
Adjust the calling convention of a method to be the ABI default if it wasn't specified explicitly.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, TrivialABIHandling TAH=TAH_IgnoreTrivialABI, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
bool checkStringLiteralArgumentAttr(const AttributeCommonInfo &CI, const Expr *E, StringRef &Str, SourceLocation *ArgLocation=nullptr)
Check if the argument E is a ASCII string literal.
QualType BuildMemberPointerType(QualType T, QualType Class, SourceLocation Loc, DeclarationName Entity)
Build a member pointer type T Class::*.
QualType BuildBlockPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a block pointer type.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Information about a FileID, basically just the logical file that it represents and include stack info...
CharacteristicKind getFileCharacteristic() const
Return whether this is a system header or not.
SourceLocation getIncludeLoc() const
This is a discriminated union of FileInfo and ExpansionInfo.
const FileInfo & getFile() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
Represents the declaration of a struct/union/class/enum.
void setEmbeddedInDeclarator(bool isInDeclarator)
True if this tag declaration is "embedded" (i.e., defined or declared for the very first time) in the...
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
TagKind getTagKind() const
Wrapper for source info for tag types.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Exposes information about the current target.
virtual bool hasBitIntType() const
Determine whether the _BitInt type is supported on this target.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
virtual size_t getMaxBitIntWidth() const
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
virtual bool allowHalfArgsAndReturns() const
Whether half args and returns are supported.
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
virtual bool hasFloat16Type() const
Determine whether the _Float16 type is supported on this target.
bool isVLASupported() const
Whether target supports variable-length arrays.
virtual bool hasIbm128Type() const
Determine whether the __ibm128 type is supported on this target.
virtual bool hasFloat128Type() const
Determine whether the __float128 type is supported on this target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool hasBFloat16Type() const
Determine whether the _BFloat16 type is supported on this target.
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
virtual std::optional< std::pair< unsigned, unsigned > > getVScaleRange(const LangOptions &LangOpts) const
Returns target-specific min and max values VScale_Range.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Location wrapper for a TemplateArgument.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
UsingShadowDecl * getAsUsingShadowDecl() const
Retrieve the using shadow declaration through which the underlying template declaration is introduced...
SourceLocation getRAngleLoc() const
void copy(TemplateSpecializationTypeLoc Loc)
Declaration of a template type parameter.
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
[BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by a...
const Type * getTypeForDecl() const
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
Base wrapper for a particular "section" of type source info.
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same type.
unsigned getFullDataSize() const
Returns the size of the type source info data block.
AutoTypeLoc getContainedAutoTypeLoc() const
Get the typeloc of an AutoType whose type will be deduced for a variable with an initializer of this ...
void * getOpaqueData() const
Get the pointer where source information is stored.
void copy(TypeLoc other)
Copies the other type loc into this one.
void initialize(ASTContext &Context, SourceLocation Loc) const
Initializes this to state that every location in this type is the given location.
SourceLocation getEndLoc() const
Get the end source location.
SourceLocation getBeginLoc() const
Get the begin source location.
void setUnmodifiedTInfo(TypeSourceInfo *TI) const
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
void setNameLoc(SourceLocation Loc)
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 isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isBooleanType() const
QualType getRVVEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an RVV builtin type.
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isIncompleteArrayType() const
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isUndeducedAutoType() const
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isVariableArrayType() const
bool isSizelessBuiltinType() const
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
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.
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.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isBitIntType() const
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isChar16Type() 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...
QualType getCanonicalTypeInternal() const
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
bool isMemberPointerType() const
bool isAtomicType() const
bool isFunctionProtoType() const
bool isObjCIdType() const
bool isChar32Type() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isObjectType() const
Determine whether this type is an object type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() 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 isWideCharType() const
bool isAnyPointerType() const
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
bool isRecordType() const
bool isObjCRetainableType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Base class for declarations which introduce a typedef-name.
Wrapper for source info for typedefs.
void setParensRange(SourceRange range)
void setTypeofLoc(SourceLocation Loc)
Wrapper of type source information for a type with no direct qualifiers.
TypeLocClass getTypeLocClass() const
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 ...
void setType(QualType newType)
Represents a variable declaration or definition.
void setNameLoc(SourceLocation Loc)
Represents a GCC generic vector type.
VectorKind getVectorKind() const
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
Retains information about a function, method, or block that is currently being parsed.
Defines the clang::TargetInfo interface.
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefDecl > typedefDecl
Matches typedef declarations.
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
const internal::VariadicDynCastAllOfMatcher< Decl, RecordDecl > recordDecl
Matches class, struct, and union declarations.
The JSON file list parser is used to communicate input to InstallAPI.
TypeSpecifierType
Specifies the kind of type.
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
@ ExpectedFunctionWithProtoType
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
@ GNUAutoType
__auto_type (GNU extension)
@ DecltypeAuto
decltype(auto)
llvm::StringRef getParameterABISpelling(ParameterABI kind)
FunctionEffectMode
Used with attributes/effects with a boolean condition, e.g. nonblocking.
LLVM_READONLY bool isAsciiIdentifierContinue(unsigned char c)
NullabilityKind
Describes the nullability of a particular type.
@ 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.
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
llvm::PointerUnion< Expr *, IdentifierLoc * > ArgsUnion
A union of the various pointer types that can be passed to an ParsedAttr as an argument.
@ IK_DeductionGuideName
A deduction-guide name (a template-name)
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_ConstructorTemplateId
A constructor named via a template-id.
@ IK_ConstructorName
A constructor name.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_DestructorName
A destructor name.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
@ IK_ConversionFunctionId
A conversion function name, e.g., operator int.
TypeOfKind
The kind of 'typeof' expression we're after.
@ AANT_ArgumentIntegerConstant
@ Result
The result type of a method or function.
llvm::StringRef getNullabilitySpelling(NullabilityKind kind, bool isContextSensitive=false)
Retrieve the spelling of the given nullability kind.
ArraySizeModifier
Capture whether this is a normal array (e.g.
@ SwiftAsyncContext
This parameter (which must have pointer type) uses the special Swift asynchronous context-pointer ABI...
@ SwiftErrorResult
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
@ Ordinary
This parameter uses ordinary ABI rules for its type.
@ SwiftIndirectResult
This parameter (which must have pointer type) is a Swift indirect result parameter.
@ SwiftContext
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment.
bool supportsVariadicCall(CallingConv CC)
Checks whether the given calling convention supports variadic calls.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
static bool isBlockPointer(Expr *Arg)
ActionResult< Expr * > ExprResult
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.
LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword.
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ FirstTargetAddressSpace
const FunctionProtoType * T
MSInheritanceModel
Assigned inheritance model for a class in the MS C++ ABI.
@ Incomplete
Template argument deduction did not deduce a value for every template parameter.
@ Success
Template argument deduction was successful.
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ SveFixedLengthData
is AArch64 SVE fixed-length data vector
@ Generic
not a target-specific vector type
@ RVVFixedLengthData
is RISC-V RVV fixed-length data vector
@ RVVFixedLengthMask
is RISC-V RVV fixed-length mask vector
@ NeonPoly
is ARM Neon polynomial vector
@ SveFixedLengthPredicate
is AArch64 SVE fixed-length predicate vector
LangAS getLangASFromTargetAS(unsigned TargetAS)
@ None
The alignment was not explicit in code.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ None
No keyword precedes the qualified type name.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Parens
New-expression has a C++98 paren-delimited initializer.
@ 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)
@ Implicit
An implicit conversion.
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
unsigned isStar
True if this dimension was [*]. In this case, NumElts is null.
unsigned TypeQuals
The type qualifiers for the array: const/volatile/restrict/__unaligned/_Atomic.
unsigned hasStatic
True if this dimension included the 'static' keyword.
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
unsigned TypeQuals
For now, sema will catch these as invalid.
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with ',...)',...
SourceLocation getTrailingReturnTypeLoc() const
Get the trailing-return-type location for this function declarator.
SourceLocation getLParenLoc() const
bool hasTrailingReturnType() const
Determine whether this function declarator had a trailing-return-type.
TypeAndRange * Exceptions
Pointer to a new[]'d array of TypeAndRange objects that contain the types in the function's dynamic e...
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
ParsedType getTrailingReturnType() const
Get the trailing-return-type for this function declarator.
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
SourceLocation getExceptionSpecLocBeg() const
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
SourceLocation getRParenLoc() const
SourceLocation getEllipsisLoc() const
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
unsigned getNumExceptions() const
Get the number of dynamic exception specifications.
bool hasMethodTypeQualifiers() const
Determine whether this method has qualifiers.
unsigned isAmbiguous
Can this declaration be a constructor-style initializer?
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
SourceRange getExceptionSpecRange() const
ExceptionSpecificationType getExceptionSpecType() const
Get the type of exception specification this function has.
Expr * NoexceptExpr
Pointer to the expression in the noexcept-specifier of this function, if it has one.
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
SourceLocation StarLoc
Location of the '*' token.
const IdentifierInfo * Ident
SourceLocation RestrictQualLoc
The location of the restrict-qualifier, if any.
SourceLocation ConstQualLoc
The location of the const-qualifier, if any.
SourceLocation VolatileQualLoc
The location of the volatile-qualifier, if any.
SourceLocation UnalignedQualLoc
The location of the __unaligned-qualifier, if any.
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/unaligned/atomic.
SourceLocation AtomicQualLoc
The location of the _Atomic-qualifier, if any.
bool LValueRef
True if this is an lvalue reference, false if it's an rvalue reference.
bool HasRestrict
The type qualifier: restrict. [GNU] C++ extension.
One instance of this struct is used for each type in a declarator that is parsed.
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
SourceLocation EndLoc
EndLoc - If valid, the place where this chunck ends.
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), SourceLocation TrailingReturnTypeLoc=SourceLocation(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
enum clang::DeclaratorChunk::@223 Kind
MemberPointerTypeInfo Mem
SourceLocation Loc
Loc - The place where this type was defined.
Describes whether we've seen any nullability information for the given file.
SourceLocation PointerEndLoc
The end location for the first pointer declarator in the file.
SourceLocation PointerLoc
The first pointer declarator (of any pointer kind) in the file that does not have a corresponding nul...
bool SawTypeNullability
Whether we saw any type nullability annotations in the given file.
uint8_t PointerKind
Which kind of pointer declarator we saw.
A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e....
Holds information about the various types of exception specification.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
unsigned AArch64SMEAttributes
SourceLocation EllipsisLoc
FunctionEffectsRef FunctionEffects
const ExtParameterInfo * ExtParameterInfos
RefQualifierKind RefQualifier
unsigned HasTrailingReturn
void setArmSMEAttribute(AArch64SMETypeAttributes Kind, bool Enable=true)
FunctionType::ExtInfo ExtInfo
Wraps an identifier and optional source location for the identifier.
SmallVector< NamedDecl *, 4 > TemplateParams
Store the list of the template parameters for a generic lambda or an abbreviated function template.
unsigned AutoTemplateParameterDepth
If this is a generic lambda or abbreviated function template, use this as the depth of each 'auto' pa...
Describes how types, statements, expressions, and declarations should be printed.
@ Memoization
Added for Template instantiation observation.
Abstract class used to diagnose incomplete types.
virtual void diagnose(Sema &S, SourceLocation Loc, QualType T)=0
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
SplitQualType getSingleStepDesugaredType() const
const Type * Ty
The locally-unqualified type.
Qualifiers Quals
The local qualifiers.
bool IsEquivalent(Decl *D1, Decl *D2)
Determine whether the two declarations are structurally equivalent.
Information about a template-id annotation token.
const IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
unsigned NumArgs
NumArgs - The number of template arguments.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
SourceLocation TemplateKWLoc
TemplateKWLoc - The location of the template keyword.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.