42#include "llvm/ADT/ArrayRef.h"
43#include "llvm/ADT/STLForwardCompat.h"
44#include "llvm/ADT/SmallPtrSet.h"
45#include "llvm/ADT/SmallString.h"
46#include "llvm/ADT/StringExtras.h"
47#include "llvm/IR/DerivedTypes.h"
48#include "llvm/Support/Casting.h"
49#include "llvm/Support/ErrorHandling.h"
64 if (D.
getContext() != DeclaratorContext::BlockLiteral ||
83 bool useExpansionLoc =
true;
84 switch (
attr.getKind()) {
85 case ParsedAttr::AT_ObjCGC:
88 case ParsedAttr::AT_ObjCOwnership:
94 useExpansionLoc =
false;
99 StringRef name =
attr.getAttrName()->getName();
104 if (useExpansionLoc && loc.
isMacroID() && II) {
105 if (II->
isStr(
"strong")) {
107 }
else if (II->
isStr(
"weak")) {
112 S.
Diag(loc,
attr.isRegularKeywordAttribute()
113 ? diag::err_type_attribute_wrong_type
114 : diag::warn_type_attribute_wrong_type)
115 << name << WhichType <<
type;
120#define OBJC_POINTER_TYPE_ATTRS_CASELIST \
121 case ParsedAttr::AT_ObjCGC: \
122 case ParsedAttr::AT_ObjCOwnership
125#define CALLING_CONV_ATTRS_CASELIST \
126 case ParsedAttr::AT_CDecl: \
127 case ParsedAttr::AT_FastCall: \
128 case ParsedAttr::AT_StdCall: \
129 case ParsedAttr::AT_ThisCall: \
130 case ParsedAttr::AT_RegCall: \
131 case ParsedAttr::AT_Pascal: \
132 case ParsedAttr::AT_SwiftCall: \
133 case ParsedAttr::AT_SwiftAsyncCall: \
134 case ParsedAttr::AT_VectorCall: \
135 case ParsedAttr::AT_AArch64VectorPcs: \
136 case ParsedAttr::AT_AArch64SVEPcs: \
137 case ParsedAttr::AT_AMDGPUKernelCall: \
138 case ParsedAttr::AT_MSABI: \
139 case ParsedAttr::AT_SysVABI: \
140 case ParsedAttr::AT_Pcs: \
141 case ParsedAttr::AT_IntelOclBicc: \
142 case ParsedAttr::AT_PreserveMost: \
143 case ParsedAttr::AT_PreserveAll: \
144 case ParsedAttr::AT_M68kRTD: \
145 case ParsedAttr::AT_PreserveNone: \
146 case ParsedAttr::AT_RISCVVectorCC
149#define FUNCTION_TYPE_ATTRS_CASELIST \
150 case ParsedAttr::AT_NSReturnsRetained: \
151 case ParsedAttr::AT_NoReturn: \
152 case ParsedAttr::AT_Regparm: \
153 case ParsedAttr::AT_CmseNSCall: \
154 case ParsedAttr::AT_ArmStreaming: \
155 case ParsedAttr::AT_ArmStreamingCompatible: \
156 case ParsedAttr::AT_ArmPreserves: \
157 case ParsedAttr::AT_ArmIn: \
158 case ParsedAttr::AT_ArmOut: \
159 case ParsedAttr::AT_ArmInOut: \
160 case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: \
161 case ParsedAttr::AT_AnyX86NoCfCheck: \
162 CALLING_CONV_ATTRS_CASELIST
165#define MS_TYPE_ATTRS_CASELIST \
166 case ParsedAttr::AT_Ptr32: \
167 case ParsedAttr::AT_Ptr64: \
168 case ParsedAttr::AT_SPtr: \
169 case ParsedAttr::AT_UPtr
172#define NULLABILITY_TYPE_ATTRS_CASELIST \
173 case ParsedAttr::AT_TypeNonNull: \
174 case ParsedAttr::AT_TypeNullable: \
175 case ParsedAttr::AT_TypeNullableResult: \
176 case ParsedAttr::AT_TypeNullUnspecified
181 class TypeProcessingState {
205 using TypeAttrPair = std::pair<const AttributedType*, const Attr*>;
207 bool AttrsForTypesSorted =
true;
211 llvm::DenseMap<const MacroQualifiedType *, SourceLocation> LocsForMacros;
219 : sema(sema), declarator(declarator),
222 Sema &getSema()
const {
230 bool isProcessingDeclSpec()
const {
234 unsigned getCurrentChunkIndex()
const {
238 void setCurrentChunkIndex(
unsigned idx) {
244 if (isProcessingDeclSpec())
245 return getMutableDeclSpec().getAttributes();
250 void saveDeclSpecAttrs() {
252 if (!savedAttrs.empty())
255 DeclSpec &spec = getMutableDeclSpec();
256 llvm::append_range(savedAttrs,
263 ignoredTypeAttrs.push_back(&
attr);
269 for (
auto *
Attr : ignoredTypeAttrs)
279 AttrsForTypes.push_back({cast<AttributedType>(
T.getTypePtr()), A});
280 AttrsForTypesSorted =
false;
285 QualType getBTFTagAttributedType(
const BTFTypeTagAttr *BTFAttr,
297 auto *NewAttrTy = cast<AttributedType>(
T.getTypePtr());
298 for (TypeAttrPair &A : AttrsForTypes) {
299 if (A.first == AttrTy)
302 AttrsForTypesSorted =
false;
309 if (!AttrsForTypesSorted) {
310 llvm::stable_sort(AttrsForTypes, llvm::less_first());
311 AttrsForTypesSorted =
true;
316 for (
auto It = std::partition_point(
317 AttrsForTypes.begin(), AttrsForTypes.end(),
318 [=](
const TypeAttrPair &A) { return A.first < AT; });
319 It != AttrsForTypes.end() && It->first == AT; ++It) {
321 const Attr *Result = It->second;
322 It->second =
nullptr;
327 llvm_unreachable(
"no Attr* for AttributedType*");
332 auto FoundLoc = LocsForMacros.find(MQT);
333 assert(FoundLoc != LocsForMacros.end() &&
334 "Unable to find macro expansion location for MacroQualifedType");
335 return FoundLoc->second;
340 LocsForMacros[MQT] =
Loc;
343 void setParsedNoDeref(
bool parsed) { parsedNoDeref = parsed; }
345 bool didParseNoDeref()
const {
return parsedNoDeref; }
347 ~TypeProcessingState() {
348 if (savedAttrs.empty())
351 getMutableDeclSpec().getAttributes().clearListOnly();
353 getMutableDeclSpec().getAttributes().addAtEnd(AL);
357 DeclSpec &getMutableDeclSpec()
const {
399 if (
attr.getKind() == ParsedAttr::AT_ObjCGC)
401 assert(
attr.getKind() == ParsedAttr::AT_ObjCOwnership);
416 bool onlyBlockPointers) {
422 for (; i != 0; --i) {
424 switch (fnChunk.
Kind) {
440 for (--i; i != 0; --i) {
442 switch (ptrChunk.
Kind) {
452 if (onlyBlockPointers)
461 llvm_unreachable(
"bad declarator chunk kind");
467 llvm_unreachable(
"bad declarator chunk kind");
484 Declarator &declarator = state.getDeclarator();
487 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
489 switch (chunk.
Kind) {
495 if (state.isProcessingDeclSpec() &&
496 attr.getKind() == ParsedAttr::AT_ObjCOwnership)
499 if (!destChunk) destChunk = &chunk;
512 if (state.isProcessingDeclSpec() &&
513 attr.getKind() == ParsedAttr::AT_ObjCOwnership) {
540 Declarator &declarator = state.getDeclarator();
544 unsigned innermost = -1U;
545 bool considerDeclSpec =
true;
548 switch (chunk.
Kind) {
562 considerDeclSpec =
false;
570 if (considerDeclSpec) {
575 state.saveDeclSpecAttrs();
584 if (innermost != -1U) {
592 state.addIgnoredTypeAttr(
attr);
601 Declarator &declarator = state.getDeclarator();
605 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
607 switch (chunk.
Kind) {
634 Declarator &declarator = state.getDeclarator();
654 state.saveDeclSpecAttrs();
658 state,
attr, state.getCurrentAttributes(), declSpecType, CFT))
663 state.addIgnoredTypeAttr(
attr);
674 Declarator &declarator = state.getDeclarator();
684 state.addIgnoredTypeAttr(
attr);
709 if (
attr.isStandardAttributeSyntax() ||
attr.isRegularKeywordAttribute())
712 switch (
attr.getKind()) {
729 case ParsedAttr::AT_ObjCKindOf:
742 Declarator &declarator = state.getDeclarator();
788 std::nullopt, loc, loc, declarator));
803 typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc;
808 if (!(RemoveTQs & Qual.first))
812 if (TypeQuals & Qual.first)
813 S.
Diag(Qual.second, DiagID)
818 TypeQuals &= ~Qual.first;
832 if (AL.isInvalid() || !AL.isTypeAttr())
835 diag::warn_block_literal_attributes_on_omitted_return_type)
837 ToBeRemoved.push_back(&AL);
847 diag::warn_block_literal_qualifiers_on_omitted_return_type);
853static OpenCLAccessAttr::Spelling
856 if (AL.getKind() == ParsedAttr::AT_OpenCLAccess)
857 return static_cast<OpenCLAccessAttr::Spelling
>(AL.getSemanticSpelling());
858 return OpenCLAccessAttr::Keyword_read_only;
864#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait) \
866 return UnaryTransformType::Enum;
867#include "clang/Basic/TransformTypeTraits.def"
869 llvm_unreachable(
"attempted to parse a non-unary transform builtin");
883 Sema &S = state.getSema();
884 Declarator &declarator = state.getDeclarator();
904 "Unknown TSS value");
918 "Unknown TSS value");
927 "Unknown TSS value");
932 "Unknown TSS value");
937 "Unknown TSS value");
946 declarator.
getContext() == DeclaratorContext::LambdaExpr) {
950 }
else if (declarator.
getContext() == DeclaratorContext::LambdaExpr ||
965 S.
Diag(DeclLoc, diag::warn_missing_type_specifier)
974 S.
Diag(DeclLoc, diag::err_missing_type_specifier)
983 S.
Diag(DeclLoc, diag::err_missing_actual_pipe_type)
988 "implicit int is disabled?");
989 S.
Diag(DeclLoc, diag::ext_missing_type_specifier)
999 case TypeSpecifierWidth::Unspecified:
1000 Result = Context.
IntTy;
1002 case TypeSpecifierWidth::Short:
1005 case TypeSpecifierWidth::Long:
1008 case TypeSpecifierWidth::LongLong:
1016 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1024 case TypeSpecifierWidth::Unspecified:
1027 case TypeSpecifierWidth::Short:
1030 case TypeSpecifierWidth::Long:
1033 case TypeSpecifierWidth::LongLong:
1041 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1056 if (Result.isNull()) {
1057 Result = Context.
IntTy;
1064 case TypeSpecifierWidth::Short:
1067 case TypeSpecifierWidth::Unspecified:
1070 case TypeSpecifierWidth::Long:
1073 case TypeSpecifierWidth::LongLong:
1074 llvm_unreachable(
"Unable to specify long long as _Accum width");
1087 case TypeSpecifierWidth::Short:
1090 case TypeSpecifierWidth::Unspecified:
1093 case TypeSpecifierWidth::Long:
1096 case TypeSpecifierWidth::LongLong:
1097 llvm_unreachable(
"Unable to specify long long as _Fract width");
1148 ?
"cl_khr_fp64 and __opencl_c_fp64"
1176 Result = Context.
IntTy;
1187 Result = Context.
IntTy;
1198 "No qualifiers on tag names!");
1214 "Can't handle qualifiers on typedef names yet!");
1216 if (Result.isNull()) {
1227 assert(!Result.isNull() &&
"Didn't get a type for typeof?");
1228 if (!Result->isDependentType())
1234 ? TypeOfKind::Unqualified
1235 : TypeOfKind::Qualified);
1240 assert(E &&
"Didn't get an expression for typeof?");
1244 ? TypeOfKind::Unqualified
1245 : TypeOfKind::Qualified);
1246 if (Result.isNull()) {
1247 Result = Context.
IntTy;
1254 assert(E &&
"Didn't get an expression for decltype?");
1257 if (Result.isNull()) {
1258 Result = Context.
IntTy;
1265 assert(E &&
"Didn't get an expression for pack indexing");
1269 if (Result.isNull()) {
1271 Result = Context.
IntTy;
1276#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
1277#include "clang/Basic/TransformTypeTraits.def"
1279 assert(!Result.isNull() &&
"Didn't get a type for the transformation?");
1283 if (Result.isNull()) {
1284 Result = Context.
IntTy;
1292 ? AutoTypeKeyword::DecltypeAuto
1293 : AutoTypeKeyword::Auto;
1299 TypeConstraintConcept =
1300 cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl());
1305 TemplateId->NumArgs);
1307 for (
const auto &ArgLoc : TemplateArgsInfo.
arguments())
1308 TemplateArgs.push_back(ArgLoc.getArgument());
1315 TypeConstraintConcept, TemplateArgs);
1329 assert(!Result.isNull() &&
"Didn't get a type for _Atomic?");
1331 if (Result.isNull()) {
1332 Result = Context.
IntTy;
1337#define GENERIC_IMAGE_TYPE(ImgType, Id) \
1338 case DeclSpec::TST_##ImgType##_t: \
1339 switch (getImageAccess(DS.getAttributes())) { \
1340 case OpenCLAccessAttr::Keyword_write_only: \
1341 Result = Context.Id##WOTy; \
1343 case OpenCLAccessAttr::Keyword_read_write: \
1344 Result = Context.Id##RWTy; \
1346 case OpenCLAccessAttr::Keyword_read_only: \
1347 Result = Context.Id##ROTy; \
1349 case OpenCLAccessAttr::SpellingNotCalculated: \
1350 llvm_unreachable("Spelling not yet calculated"); \
1353#include "clang/Basic/OpenCLImageTypes.def"
1356 Result = Context.
IntTy;
1364 if (Result->containsErrors())
1369 bool IsOpenCLC30Compatible =
1378 if ((Result->isImageType() || Result->isSamplerT()) &&
1379 (IsOpenCLC30Compatible &&
1382 << 0 << Result <<
"__opencl_c_images";
1384 }
else if (Result->isOCLImage3dWOType() &&
1389 << (IsOpenCLC30Compatible
1390 ?
"cl_khr_3d_image_writes and __opencl_c_3d_image_writes"
1391 :
"cl_khr_3d_image_writes");
1411 unsigned typeSize =
static_cast<unsigned>(Context.
getTypeSize(Result));
1412 assert(typeSize > 0 &&
"type size for vector must be greater than 0 bits");
1413 VectorKind VecKind = VectorKind::AltiVecVector;
1415 VecKind = VectorKind::AltiVecPixel;
1417 VecKind = VectorKind::AltiVecBool;
1418 Result = Context.
getVectorType(Result, 128/typeSize, VecKind);
1427 if (declarator.
getContext() == DeclaratorContext::BlockLiteral)
1441 if (AL.slidesFromDeclToDeclSpecLegacyBehavior()) {
1452 if (AL.isStandardAttributeSyntax() && AL.isClangScope() &&
1453 !(AL.getKind() == ParsedAttr::AT_MatrixType &&
1455 S.
Diag(AL.getLoc(), diag::warn_type_attribute_deprecated_on_decl)
1481 if (Result->isFunctionType()) {
1485 ? diag::warn_typecheck_function_qualifiers_ignored
1486 : diag::warn_typecheck_function_qualifiers_unspecified);
1499 if (TypeQuals && Result->isReferenceType()) {
1501 S, DS, TypeQuals, Result,
1503 diag::warn_typecheck_reference_qualifiers);
1510 && TypeQuals & Result.getCVRQualifiers()) {
1534 assert(!Result.isNull() &&
"This function should not return a null type");
1549 const auto *AT = dyn_cast<AutoType>(
T);
1550 return AT && AT->isGNUAutoType();
1567 unsigned DiagID = 0;
1583 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
1590 DiagID = diag::err_typecheck_invalid_restrict_not_pointer;
1604 unsigned CVRAU,
const DeclSpec *DS) {
1638 Split.Quals.addCVRQualifiers(CVR);
1657 if (!
type->isObjCLifetimeType() ||
1667 if (
type.isConstQualified()) {
1673 }
else if (
type->isObjCARCImplicitlyUnretainedType()) {
1691 diag::err_arc_indirect_no_ownership,
type, isReference));
1693 S.
Diag(loc, diag::err_arc_indirect_no_ownership) <<
type << isReference;
1697 assert(implicitLifetime &&
"didn't infer any lifetime!");
1738enum QualifiedFunctionKind { QFK_BlockPointer, QFK_Pointer, QFK_Reference };
1744 QualifiedFunctionKind QFK) {
1751 S.
Diag(
Loc, diag::err_compound_qualified_function_type)
1752 << QFK << isa<FunctionType>(
T.IgnoreParens()) <<
T
1763 Diag(
Loc, diag::err_qualified_function_typeid)
1795 Diag(
Loc, diag::err_illegal_decl_pointer_to_reference)
1803 Diag(
Loc, diag::err_opencl_function_pointer) << 0;
1808 Diag(
Loc, diag::err_hlsl_pointers_unsupported) << 0;
1827 if (
T.isWebAssemblyReferenceType()) {
1828 Diag(
Loc, diag::err_wasm_reference_pr) << 0;
1834 Diag(
Loc, diag::err_wasm_table_pr) << 0;
1860 "Unresolved overloaded function type");
1888 Diag(
Loc, diag::err_reference_to_void);
1893 Diag(
Loc, diag::err_hlsl_pointers_unsupported) << 1;
1903 Diag(
Loc, diag::err_opencl_function_pointer) << 1;
1916 T.isWebAssemblyReferenceType()) {
1917 Diag(
Loc, diag::err_wasm_reference_pr) << 1;
1921 Diag(
Loc, diag::err_wasm_table_pr) << 1;
1968 llvm::APSInt Bits(32);
1975 size_t NumBits = Bits.getZExtValue();
1976 if (!IsUnsigned && NumBits < 2) {
1977 Diag(
Loc, diag::err_bit_int_bad_size) << 0;
1981 if (IsUnsigned && NumBits < 1) {
1982 Diag(
Loc, diag::err_bit_int_bad_size) << 1;
1988 Diag(
Loc, diag::err_bit_int_max_size)
2002 llvm::APSInt &SizeVal,
unsigned VLADiag,
2027 VLADiagnoser(
unsigned VLADiag,
bool VLAIsError)
2028 : VLADiag(VLADiag), VLAIsError(VLAIsError) {}
2032 return S.
Diag(
Loc, diag::err_array_size_non_int) <<
T;
2037 IsVLA = !VLAIsError;
2043 return S.
Diag(
Loc, diag::ext_vla_folded_to_constant);
2045 } Diagnoser(VLADiag, VLAIsError);
2049 if (Diagnoser.IsVLA)
2063 if (Size.isMultipleOf(Alignment))
2066 Diag(
Loc, diag::err_array_element_alignment)
2067 << EltTy << Size.getQuantity() << Alignment.
getQuantity();
2087 Expr *ArraySize,
unsigned Quals,
2104 Diag(
Loc, diag::err_illegal_decl_array_of_references)
2110 Diag(
Loc, diag::err_array_incomplete_or_sizeless_type) << 0 <<
T;
2115 diag::err_array_of_abstract_type))
2122 if (!MPTy->getClass()->isDependentType())
2128 if (!
T.isWebAssemblyReferenceType() &&
2130 diag::err_array_incomplete_or_sizeless_type))
2136 const auto *ATy = dyn_cast<ArrayType>(
T);
2137 if (ATy && ATy->getElementType().isWebAssemblyReferenceType()) {
2138 Diag(
Loc, diag::err_wasm_reftype_multidimensional_array);
2144 Diag(
Loc, diag::err_array_incomplete_or_sizeless_type) << 1 <<
T;
2149 Diag(
Loc, diag::err_illegal_decl_array_of_functions)
2157 if (EltTy->getDecl()->hasFlexibleArrayMember())
2158 Diag(
Loc, diag::ext_flexible_array_in_array) <<
T;
2160 Diag(
Loc, diag::err_objc_array_of_interfaces) <<
T;
2171 ArraySize =
Result.get();
2175 if (ArraySize && !ArraySize->
isPRValue()) {
2180 ArraySize =
Result.get();
2203 if (
const auto *CondExpr = dyn_cast_if_present<ConditionalOperator>(
2205 std::optional<llvm::APSInt> LHS =
2206 CondExpr->getLHS()->getIntegerConstantExpr(
Context);
2207 std::optional<llvm::APSInt> RHS =
2208 CondExpr->getRHS()->getIntegerConstantExpr(
Context);
2209 return LHS && RHS && LHS->isNegative() != RHS->isNegative();
2219 VLADiag = diag::err_opencl_vla;
2222 VLADiag = diag::warn_vla_used;
2225 VLADiag = diag::err_vla_in_sfinae;
2228 VLADiag = diag::err_openmp_vla_in_task_untied;
2233 ? diag::ext_vla_cxx_in_gnu_mode_static_assert
2234 : diag::ext_vla_cxx_static_assert;
2236 VLADiag =
getLangOpts().GNUMode ? diag::ext_vla_cxx_in_gnu_mode
2237 : diag::ext_vla_cxx;
2240 VLADiag = diag::ext_vla;
2281 if (ConstVal.isSigned() && ConstVal.isNegative()) {
2288 diag::err_typecheck_negative_array_size)
2292 if (ConstVal == 0 && !
T.isWebAssemblyReferenceType()) {
2297 : diag::ext_typecheck_zero_array_size)
2302 unsigned ActiveSizeBits =
2306 : ConstVal.getActiveBits();
2322 IsCUDADevice ? diag::err_cuda_vla : diag::err_vla_unsupported)
2323 << (IsCUDADevice ? llvm::to_underlying(
CUDA().CurrentTarget()) : 0);
2327 FSI->setHasVLA(
Loc);
2335 : diag::ext_c99_array_usage)
2336 << llvm::to_underlying(ASM);
2346 Diag(
Loc, diag::err_opencl_invalid_type_array) << ArrType;
2363 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << CurType;
2368 unsigned NumBits = BIT->getNumBits();
2369 if (!llvm::isPowerOf2_32(NumBits) || NumBits < 8) {
2370 Diag(AttrLoc, diag::err_attribute_invalid_bitint_vector_type)
2380 std::optional<llvm::APSInt> VecSize =
2383 Diag(AttrLoc, diag::err_attribute_argument_type)
2394 if (!VecSize->isIntN(61)) {
2396 Diag(AttrLoc, diag::err_attribute_size_too_large)
2400 uint64_t VectorSizeBits = VecSize->getZExtValue() * 8;
2403 if (VectorSizeBits == 0) {
2404 Diag(AttrLoc, diag::err_attribute_zero_size)
2409 if (!TypeSize || VectorSizeBits % TypeSize) {
2410 Diag(AttrLoc, diag::err_attribute_invalid_size)
2415 if (VectorSizeBits / TypeSize > std::numeric_limits<uint32_t>::max()) {
2416 Diag(AttrLoc, diag::err_attribute_size_too_large)
2443 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) <<
T;
2450 if (!llvm::isPowerOf2_32(NumBits) || NumBits < 8) {
2451 Diag(AttrLoc, diag::err_attribute_invalid_bitint_vector_type)
2458 std::optional<llvm::APSInt> vecSize =
2461 Diag(AttrLoc, diag::err_attribute_argument_type)
2467 if (!vecSize->isIntN(32)) {
2468 Diag(AttrLoc, diag::err_attribute_size_too_large)
2474 unsigned vectorSize =
static_cast<unsigned>(vecSize->getZExtValue());
2476 if (vectorSize == 0) {
2477 Diag(AttrLoc, diag::err_attribute_zero_size)
2491 "Should never build a matrix type when it is disabled");
2496 Diag(AttrLoc, diag::err_attribute_invalid_matrix_type) << ElementTy;
2505 std::optional<llvm::APSInt> ValueRows =
2507 std::optional<llvm::APSInt> ValueColumns =
2514 if (!ValueRows && !ValueColumns) {
2515 Diag(AttrLoc, diag::err_attribute_argument_type)
2523 Diag(AttrLoc, diag::err_attribute_argument_type)
2529 if (!ValueColumns) {
2530 Diag(AttrLoc, diag::err_attribute_argument_type)
2536 unsigned MatrixRows =
static_cast<unsigned>(ValueRows->getZExtValue());
2537 unsigned MatrixColumns =
static_cast<unsigned>(ValueColumns->getZExtValue());
2538 if (MatrixRows == 0 && MatrixColumns == 0) {
2539 Diag(AttrLoc, diag::err_attribute_zero_size)
2540 <<
"matrix" << RowRange << ColRange;
2543 if (MatrixRows == 0) {
2544 Diag(AttrLoc, diag::err_attribute_zero_size) <<
"matrix" << RowRange;
2547 if (MatrixColumns == 0) {
2548 Diag(AttrLoc, diag::err_attribute_zero_size) <<
"matrix" << ColRange;
2552 Diag(AttrLoc, diag::err_attribute_size_too_large)
2553 << RowRange <<
"matrix row";
2557 Diag(AttrLoc, diag::err_attribute_size_too_large)
2558 << ColRange <<
"matrix column";
2566 Diag(
Loc, diag::err_func_returning_array_function)
2574 Diag(
Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 <<
2582 Diag(
Loc, diag::err_object_cannot_be_passed_returned_by_value)
2587 if (
T.hasNonTrivialToPrimitiveDestructCUnion() ||
2588 T.hasNonTrivialToPrimitiveCopyCUnion())
2595 Diag(
Loc, diag::warn_deprecated_volatile_return) <<
T;
2610 bool emittedError =
false;
2612 enum class RequiredCC { OnlySwift, SwiftOrSwiftAsync };
2613 auto checkCompatible = [&](
unsigned paramIndex, RequiredCC required) {
2615 (required == RequiredCC::OnlySwift)
2618 if (isCompatible || emittedError)
2620 S.
Diag(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall)
2622 << (required == RequiredCC::OnlySwift);
2623 emittedError =
true;
2625 for (
size_t paramIndex = 0, numParams = paramTypes.size();
2626 paramIndex != numParams; ++paramIndex) {
2635 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
2636 if (paramIndex != 0 &&
2639 S.
Diag(getParamLoc(paramIndex),
2640 diag::err_swift_indirect_result_not_first);
2645 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
2654 checkCompatible(paramIndex, RequiredCC::OnlySwift);
2655 if (paramIndex == 0 ||
2658 S.
Diag(getParamLoc(paramIndex),
2659 diag::err_swift_error_result_not_after_swift_context);
2663 llvm_unreachable(
"bad ABI kind");
2675 for (
unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) {
2679 Diag(
Loc, diag::err_param_with_void_type);
2684 Diag(
Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<
2688 Diag(
Loc, diag::err_wasm_table_as_function_parameter);
2695 Diag(
Loc, diag::warn_deprecated_volatile_param) << ParamType;
2697 ParamTypes[Idx] = ParamType;
2702 [=](
unsigned i) {
return Loc; });
2731 Diag(
Loc, diag::err_distant_exception_spec);
2738 Diag(
Loc, diag::err_illegal_decl_mempointer_to_reference)
2744 Diag(
Loc, diag::err_illegal_decl_mempointer_to_void)
2749 if (!
Class->isDependentType() && !
Class->isRecordType()) {
2750 Diag(
Loc, diag::err_mempointer_in_nonclass_type) <<
Class;
2757 Diag(
Loc, diag::err_opencl_function_pointer) << 0;
2762 Diag(
Loc, diag::err_hlsl_pointers_unsupported) << 0;
2792 Diag(
Loc, diag::err_nonfunction_block_type);
2808 if (TInfo) *TInfo =
nullptr;
2813 if (
const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
2814 QT = LIT->getType();
2815 DI = LIT->getTypeSourceInfo();
2818 if (TInfo) *TInfo = DI;
2824 unsigned chunkIndex);
2831 Sema &S = state.getSema();
2832 Declarator &declarator = state.getDeclarator();
2838 unsigned outermostPointerIndex = 0;
2840 unsigned numPointers = 0;
2842 unsigned chunkIndex = i;
2844 switch (chunk.
Kind) {
2854 outermostPointerIndex = chunkIndex;
2862 if (numPointers != 1)
return;
2864 outermostPointerIndex = chunkIndex;
2882 if (numPointers == 1) {
2900 }
else if (numPointers == 2) {
2913 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership)
2917 outermostPointerIndex);
2939 }
const QualKinds[5] = {
2948 unsigned NumQuals = 0;
2953 for (
auto &E : QualKinds) {
2954 if (Quals & E.Mask) {
2955 if (!QualStr.empty()) QualStr +=
' ';
2972 << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];
2978 unsigned FunctionChunkIndex) {
2988 for (
unsigned OuterChunkIndex = FunctionChunkIndex + 1,
2990 OuterChunkIndex != End; ++OuterChunkIndex) {
2992 switch (OuterChunk.
Kind) {
2999 diag::warn_qual_return_type,
3025 llvm_unreachable(
"unknown declarator chunk kind");
3046static std::pair<QualType, TypeSourceInfo *>
3050 Sema &S = state.getSema();
3054 const unsigned AutoParameterPosition = Info.
TemplateParams.size();
3068 TemplateParameterDepth, AutoParameterPosition,
3071 IsParameterPack,
Auto->isConstrained());
3076 if (
Auto->isConstrained()) {
3083 for (
unsigned Idx = 0; Idx < AutoLoc.
getNumArgs(); ++Idx) {
3131 USD ? cast<NamedDecl>(USD) : CD,
3143 QualType NewT = state.ReplaceAutoType(
T, Replacement);
3147 return {NewT, NewTSI};
3156 Sema &SemaRef = state.getSema();
3159 ReturnTypeInfo =
nullptr;
3162 TagDecl *OwnedTagDecl =
nullptr;
3213 bool DeducedIsTrailingReturnType =
false;
3217 DeducedIsTrailingReturnType =
true;
3227 bool IsCXXAutoType =
3229 bool IsDeducedReturnType =
false;
3270 assert(Info &&
"No LambdaScopeInfo on the stack!");
3276 if (!DeducedIsTrailingReturnType)
3285 if (isa<ObjCContainerDecl>(SemaRef.
CurContext)) {
3288 switch (cast<TagDecl>(SemaRef.
CurContext)->getTagKind()) {
3290 llvm_unreachable(
"unhandled tag kind");
3292 Error = Cxx ? 1 : 2;
3295 Error = Cxx ? 3 : 4;
3314 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
3326 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
3340 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3342 IsDeducedReturnType =
true;
3345 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3347 IsDeducedReturnType =
true;
3350 if (isa<DeducedTemplateSpecializationType>(Deduced))
3352 if (SemaRef.
getLangOpts().CPlusPlus23 && IsCXXAutoType &&
3353 !
Auto->isDecltypeAuto())
3372 if (!IsCXXAutoType && !isa<DeducedTemplateSpecializationType>(Deduced))
3386 (!SemaRef.
getLangOpts().CPlusPlus11 || !IsCXXAutoType))
3396 switch (
Auto->getKeyword()) {
3402 assert(isa<DeducedTemplateSpecializationType>(Deduced) &&
3403 "unknown auto type");
3407 auto *DTST = dyn_cast<DeducedTemplateSpecializationType>(Deduced);
3410 SemaRef.
Diag(AutoRange.
getBegin(), diag::err_auto_not_allowed)
3412 <<
QualType(Deduced, 0) << AutoRange;
3423 ? diag::warn_cxx11_compat_generic_lambda
3424 : IsDeducedReturnType
3425 ? diag::warn_cxx11_compat_deduced_return_type
3426 : diag::warn_cxx98_compat_auto_type_specifier)
3435 unsigned DiagID = 0;
3441 llvm_unreachable(
"parser should not have allowed this");
3457 DiagID = diag::err_type_defined_in_alias_template;
3469 DiagID = diag::err_type_defined_in_type_specifier;
3479 DiagID = diag::err_type_defined_in_param_type;
3485 DiagID = diag::err_type_defined_in_condition;
3496 assert(!
T.isNull() &&
"This function should not return a null type");
3505 assert(FTI.
isAmbiguous &&
"no direct-initializer / function ambiguity");
3535 FTI.
NumParams ? diag::warn_parens_disambiguated_as_function_declaration
3536 : diag::warn_empty_parens_are_function_decl)
3547 if (Comma.getFileID() != Name.getFileID() ||
3548 Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) {
3555 Result.suppressDiagnostics();
3568 S.
Diag(B, diag::note_additional_parens_for_variable_declaration)
3583 S.
Diag(DeclType.
Loc, diag::note_empty_parens_default_ctor)
3591 S.
Diag(DeclType.
Loc, diag::note_empty_parens_zero_initialize)
3602 "do not have redundant top-level parentheses");
3611 bool CouldBeTemporaryObject =
3618 bool StartsWithDeclaratorId =
true;
3626 StartsWithDeclaratorId =
false;
3631 CouldBeTemporaryObject =
false;
3639 CouldBeTemporaryObject =
false;
3640 StartsWithDeclaratorId =
false;
3650 CouldBeTemporaryObject =
false;
3657 CouldBeTemporaryObject =
false;
3658 StartsWithDeclaratorId =
false;
3668 if (CouldBeTemporaryObject) {
3672 CouldBeTemporaryObject =
false;
3673 Result.suppressDiagnostics();
3678 if (!CouldBeTemporaryObject) {
3691 S.
Diag(
Paren.Loc, diag::warn_redundant_parens_around_declarator)
3697 S.
Diag(
Paren.Loc, diag::warn_parens_disambiguated_as_variable_declaration)
3700 if (!RD || !RD->hasDefinition() || RD->hasNonTrivialDestructor())
3701 S.
Diag(
Paren.Loc, diag::note_raii_guard_add_name)
3706 S.
Diag(D.
getBeginLoc(), diag::note_function_style_cast_add_parentheses)
3709 S.
Diag(
Paren.Loc, diag::note_remove_parens_for_variable_declaration)
3725 switch (AL.getKind()) {
3744 bool IsCXXInstanceMethod =
false;
3750 unsigned I = ChunkIndex;
3751 bool FoundNonParen =
false;
3752 while (I && !FoundNonParen) {
3755 FoundNonParen =
true;
3758 if (FoundNonParen) {
3761 IsCXXInstanceMethod =
3766 IsCXXInstanceMethod =
3774 IsCXXInstanceMethod =
3782 IsCXXInstanceMethod);
3790 if (AL.getKind() == ParsedAttr::AT_OpenCLKernel) {
3800 if (Triple.getArch() == llvm::Triple::spirv32 ||
3801 Triple.getArch() == llvm::Triple::spirv64) {
3803 if (AL.getKind() == ParsedAttr::AT_CUDAGlobal) {
3817 enum class SimplePointerKind {
3826 switch (nullability) {
3828 if (!Ident__Nonnull)
3830 return Ident__Nonnull;
3833 if (!Ident__Nullable)
3835 return Ident__Nullable;
3838 if (!Ident__Nullable_result)
3840 return Ident__Nullable_result;
3843 if (!Ident__Null_unspecified)
3845 return Ident__Null_unspecified;
3847 llvm_unreachable(
"Unknown nullability kind.");
3854 if (AL.getKind() == ParsedAttr::AT_TypeNonNull ||
3855 AL.getKind() == ParsedAttr::AT_TypeNullable ||
3856 AL.getKind() == ParsedAttr::AT_TypeNullableResult ||
3857 AL.getKind() == ParsedAttr::AT_TypeNullUnspecified)
3866 enum class PointerDeclaratorKind {
3874 MaybePointerToCFRef,
3878 NSErrorPointerPointer,
3884 enum class PointerWrappingDeclaratorKind {
3898static PointerDeclaratorKind
3900 PointerWrappingDeclaratorKind &wrappingKind) {
3901 unsigned numNormalPointers = 0;
3904 if (
type->isDependentType())
3905 return PointerDeclaratorKind::NonPointer;
3910 switch (chunk.
Kind) {
3912 if (numNormalPointers == 0)
3913 wrappingKind = PointerWrappingDeclaratorKind::Array;
3922 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3923 : PointerDeclaratorKind::SingleLevelPointer;
3929 if (numNormalPointers == 0)
3930 wrappingKind = PointerWrappingDeclaratorKind::Reference;
3934 ++numNormalPointers;
3935 if (numNormalPointers > 2)
3936 return PointerDeclaratorKind::MultiLevelPointer;
3942 unsigned numTypeSpecifierPointers = 0;
3946 ++numNormalPointers;
3948 if (numNormalPointers > 2)
3949 return PointerDeclaratorKind::MultiLevelPointer;
3951 type = ptrType->getPointeeType();
3952 ++numTypeSpecifierPointers;
3958 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3959 : PointerDeclaratorKind::SingleLevelPointer;
3964 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3965 : PointerDeclaratorKind::SingleLevelPointer;
3970 ++numNormalPointers;
3971 ++numTypeSpecifierPointers;
3974 if (
auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) {
3976 numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3977 return PointerDeclaratorKind::NSErrorPointerPointer;
3986 if (objcClass->getInterface()->getIdentifier() ==
3988 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2)
3989 return PointerDeclaratorKind::NSErrorPointerPointer;
3996 if (numNormalPointers == 0)
3997 return PointerDeclaratorKind::NonPointer;
4003 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2 &&
4005 return PointerDeclaratorKind::CFErrorRefPointer;
4013 switch (numNormalPointers) {
4015 return PointerDeclaratorKind::NonPointer;
4018 return PointerDeclaratorKind::SingleLevelPointer;
4021 return PointerDeclaratorKind::MaybePointerToCFRef;
4024 return PointerDeclaratorKind::MultiLevelPointer;
4033 if (ctx->isFunctionOrMethod())
4036 if (ctx->isFileContext())
4047 bool invalid =
false;
4049 if (invalid || !sloc.
isFile())
4067template <
typename DiagBuilderT>
4076 if (!FixItLoc.
isValid() || FixItLoc == PointerLoc)
4085 InsertionTextBuf +=
" ";
4086 StringRef InsertionText = InsertionTextBuf.str();
4089 InsertionText = InsertionText.drop_back();
4090 }
else if (NextChar[-1] ==
'[') {
4091 if (NextChar[0] ==
']')
4092 InsertionText = InsertionText.drop_back().drop_front();
4094 InsertionText = InsertionText.drop_front();
4097 InsertionText = InsertionText.drop_back().drop_front();
4104 SimplePointerKind PointerKind,
4109 if (PointerKind == SimplePointerKind::Array) {
4110 S.
Diag(PointerLoc, diag::warn_nullability_missing_array);
4112 S.
Diag(PointerLoc, diag::warn_nullability_missing)
4113 <<
static_cast<unsigned>(PointerKind);
4116 auto FixItLoc = PointerEndLoc.
isValid() ? PointerEndLoc : PointerLoc;
4117 if (FixItLoc.isMacroID())
4121 auto Diag = S.
Diag(FixItLoc, diag::note_nullability_fix_it);
4122 Diag << static_cast<unsigned>(Nullability);
4123 Diag << static_cast<unsigned>(PointerKind);
4152 if (pointerKind == SimplePointerKind::Array)
4153 diagKind = diag::warn_nullability_missing_array;
4155 diagKind = diag::warn_nullability_missing;
4161 fileNullability.
PointerKind =
static_cast<unsigned>(pointerKind);
4193 auto kind =
static_cast<SimplePointerKind
>(fileNullability.
PointerKind);
4208 unsigned i = endIndex;
4236template<
typename AttrT>
4239 return ::new (Ctx) AttrT(Ctx, AL);
4246 return createSimpleAttr<TypeNonNullAttr>(Ctx,
Attr);
4249 return createSimpleAttr<TypeNullableAttr>(Ctx,
Attr);
4252 return createSimpleAttr<TypeNullableResultAttr>(Ctx,
Attr);
4255 return createSimpleAttr<TypeNullUnspecifiedAttr>(Ctx,
Attr);
4257 llvm_unreachable(
"unknown NullabilityKind");
4268 if (ASOld != ASNew) {
4269 S.
Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
4274 diag::warn_attribute_address_multiple_identical_qualifiers);
4288 !isa<RecordType, TemplateSpecializationType>(
4299 Sema &S = state.getSema();
4309 bool IsTypedefName =
4325 bool IsClassTemplateDeduction = isa<DeducedTemplateSpecializationType>(DT);
4328 unsigned Index = E - I - 1;
4330 unsigned DiagId = IsClassTemplateDeduction
4331 ? diag::err_deduced_class_template_compound_type
4332 : diag::err_decltype_auto_compound_type;
4333 unsigned DiagKind = 0;
4334 switch (DeclChunk.
Kind) {
4337 if (IsClassTemplateDeduction) {
4343 if (IsClassTemplateDeduction) {
4351 DiagId = diag::err_decltype_auto_function_declarator_not_declaration;
4369 S.
Diag(DeclChunk.
Loc, DiagId) << DiagKind;
4377 std::optional<NullabilityKind> inferNullability;
4378 bool inferNullabilityCS =
false;
4379 bool inferNullabilityInnerOnly =
false;
4380 bool inferNullabilityInnerOnlyComplete =
false;
4383 bool inAssumeNonNullRegion =
false;
4385 if (assumeNonNullLoc.
isValid()) {
4386 inAssumeNonNullRegion =
true;
4400 } complainAboutMissingNullability = CAMN_No;
4401 unsigned NumPointersRemaining = 0;
4402 auto complainAboutInferringWithinChunk = PointerWrappingDeclaratorKind::None;
4404 if (IsTypedefName) {
4408 complainAboutMissingNullability = CAMN_InnerPointers;
4412 ++NumPointersRemaining;
4417 switch (chunk.
Kind) {
4425 ++NumPointersRemaining;
4433 ++NumPointersRemaining;
4439 switch (
auto context = state.getDeclarator().getContext()) {
4450 complainAboutMissingNullability = CAMN_No;
4455 if (state.getDeclarator().isObjCWeakProperty()) {
4458 complainAboutMissingNullability = CAMN_No;
4459 if (inAssumeNonNullRegion) {
4469 complainAboutMissingNullability = CAMN_Yes;
4472 auto wrappingKind = PointerWrappingDeclaratorKind::None;
4474 case PointerDeclaratorKind::NonPointer:
4475 case PointerDeclaratorKind::MultiLevelPointer:
4479 case PointerDeclaratorKind::SingleLevelPointer:
4481 if (inAssumeNonNullRegion) {
4482 complainAboutInferringWithinChunk = wrappingKind;
4489 case PointerDeclaratorKind::CFErrorRefPointer:
4490 case PointerDeclaratorKind::NSErrorPointerPointer:
4497 case PointerDeclaratorKind::MaybePointerToCFRef:
4502 auto hasCFReturnsAttr =
4504 return AttrList.hasAttribute(ParsedAttr::AT_CFReturnsRetained) ||
4505 AttrList.hasAttribute(ParsedAttr::AT_CFReturnsNotRetained);
4510 hasCFReturnsAttr(InnermostChunk->getAttrs()) ||
4513 inferNullabilityInnerOnly =
true;
4523 complainAboutMissingNullability = CAMN_Yes;
4551 auto isVaList = [&S](
QualType T) ->
bool {
4557 if (typedefTy->getDecl() == vaListTypedef)
4559 if (
auto *name = typedefTy->getDecl()->getIdentifier())
4560 if (name->isStr(
"va_list"))
4562 typedefTy = typedefTy->desugar()->getAs<
TypedefType>();
4563 }
while (typedefTy);
4569 auto inferPointerNullability =
4574 if (NumPointersRemaining > 0)
4575 --NumPointersRemaining;
4582 if (inferNullability && !inferNullabilityInnerOnlyComplete) {
4585 ? ParsedAttr::Form::ContextSensitiveKeyword()
4586 : ParsedAttr::Form::Keyword(
false ,
4592 attrs.addAtEnd(nullabilityAttr);
4594 if (inferNullabilityCS) {
4595 state.getDeclarator().getMutableDeclSpec().getObjCQualifiers()
4599 if (pointerLoc.isValid() &&
4600 complainAboutInferringWithinChunk !=
4601 PointerWrappingDeclaratorKind::None) {
4603 S.
Diag(pointerLoc, diag::warn_nullability_inferred_on_nested_type);
4604 Diag << static_cast<int>(complainAboutInferringWithinChunk);
4608 if (inferNullabilityInnerOnly)
4609 inferNullabilityInnerOnlyComplete =
true;
4610 return nullabilityAttr;
4615 switch (complainAboutMissingNullability) {
4619 case CAMN_InnerPointers:
4620 if (NumPointersRemaining == 0)
4636 if (NumPointersRemaining > 0)
4637 --NumPointersRemaining;
4639 SimplePointerKind pointerKind = SimplePointerKind::Pointer;
4641 pointerKind = SimplePointerKind::BlockPointer;
4643 pointerKind = SimplePointerKind::MemberPointer;
4645 if (
auto *
attr = inferPointerNullability(
4650 T = state.getAttributedType(
4656 if (complainAboutMissingNullability == CAMN_Yes &&
T->
isArrayType() &&
4664 bool ExpectNoDerefChunk =
4665 state.getCurrentAttributes().hasAttribute(ParsedAttr::AT_NoDeref);
4675 bool AreDeclaratorChunksValid =
true;
4677 unsigned chunkIndex = e - i - 1;
4678 state.setCurrentChunkIndex(chunkIndex);
4681 switch (DeclType.
Kind) {
4689 if (!LangOpts.Blocks)
4690 S.
Diag(DeclType.
Loc, diag::err_blocks_disable) << LangOpts.OpenCL;
4693 inferPointerNullability(SimplePointerKind::BlockPointer, DeclType.
Loc,
4695 state.getDeclarator().getAttributePool());
4701 if (LangOpts.OpenCL)
4716 inferPointerNullability(SimplePointerKind::Pointer, DeclType.
Loc,
4718 state.getDeclarator().getAttributePool());
4730 if (LangOpts.OpenCL) {
4771 if (chunkIndex != 0 && !ArraySize &&
4790 S.
Diag(DeclType.
Loc, diag::err_array_star_outside_prototype);
4801 S.
Diag(DeclType.
Loc, diag::err_array_static_outside_prototype)
4803 :
"type qualifier");
4814 S.
Diag(DeclType.
Loc, diag::err_array_static_not_outermost)
4816 :
"type qualifier");
4826 if (complainAboutMissingNullability == CAMN_Yes &&
4842 IsQualifiedFunction =
4855 ? diag::err_auto_missing_trailing_return
4856 : diag::err_deduced_return_type);
4859 AreDeclaratorChunksValid =
false;
4862 diag::warn_cxx11_compat_deduced_return_type);
4866 if (isa<ParenType>(
T)) {
4871 AreDeclaratorChunksValid =
false;
4876 diag::err_deduction_guide_with_complex_decl)
4880 AreDeclaratorChunksValid =
false;
4883 (
T.hasQualifiers() || !isa<AutoType>(
T) ||
4884 cast<AutoType>(
T)->getKeyword() !=
4886 cast<AutoType>(
T)->isConstrained())) {
4888 diag::err_trailing_return_without_auto)
4892 AreDeclaratorChunksValid =
false;
4908 if (InventedParamInfo) {
4910 state,
T, TInfo,
Auto, *InventedParamInfo);
4924 unsigned diagID = diag::err_func_returning_array_function;
4927 if (chunkIndex == 0 &&
4929 diagID = diag::err_block_returning_array_function;
4933 AreDeclaratorChunksValid =
false;
4946 }
else if (!S.
getLangOpts().NativeHalfArgsAndReturns &&
4949 diag::err_parameters_retval_cannot_have_fp16_type) << 1;
4954 if (LangOpts.OpenCL) {
4968 "__cl_clang_variadic_functions", S.
getLangOpts()) &&
4989 S.
Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value)
5001 AreDeclaratorChunksValid =
false;
5018 S.
Diag(DeclType.
Loc, diag::err_func_returning_qualified_void) <<
T;
5024 if (
T.isVolatileQualified() && S.
getLangOpts().CPlusPlus20)
5025 S.
Diag(DeclType.
Loc, diag::warn_deprecated_volatile_return) <<
T;
5031 if (
T.getQualifiers().hasObjCLifetime()) {
5036 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5037 AttrLoc = AL.getLoc();
5044 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5045 AttrLoc = AL.getLoc();
5059 S.
Diag(AttrLoc, diag::warn_arc_lifetime_result_type)
5060 <<
T.getQualifiers().getObjCLifetime();
5076 diag::err_exception_spec_in_typedef)
5102 diag::warn_c17_compat_ellipsis_only_parameter);
5104 ParsedAttr::AT_Overloadable) &&
5106 ParsedAttr::AT_Overloadable) &&
5108 ParsedAttr::AT_Overloadable))
5116 diag::err_ident_list_in_fn_declaration);
5122 AreDeclaratorChunksValid =
false;
5145 bool HasAnyInterestingExtParameterInfos =
false;
5147 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
5150 assert(!ParamTy.
isNull() &&
"Couldn't parse type?");
5161 ParamTy = Context.
IntTy;
5166 ParamTy = Context.
IntTy;
5171 S.
Diag(DeclType.
Loc, diag::err_void_param_qualified);
5187 }
else if (!S.
getLangOpts().NativeHalfArgsAndReturns &&
5190 diag::err_parameters_retval_cannot_have_fp16_type) << 0;
5198 if (BTy->getKind() == BuiltinType::Float) {
5210 if (LangOpts.ObjCAutoRefCount && Param->
hasAttr<NSConsumedAttr>()) {
5211 ExtParameterInfos[i] = ExtParameterInfos[i].withIsConsumed(
true);
5212 HasAnyInterestingExtParameterInfos =
true;
5216 ExtParameterInfos[i] =
5217 ExtParameterInfos[i].withABI(
attr->getABI());
5218 HasAnyInterestingExtParameterInfos =
true;
5221 if (Param->
hasAttr<PassObjectSizeAttr>()) {
5222 ExtParameterInfos[i] = ExtParameterInfos[i].withHasPassObjectSize();
5223 HasAnyInterestingExtParameterInfos =
true;
5226 if (Param->
hasAttr<NoEscapeAttr>()) {
5227 ExtParameterInfos[i] = ExtParameterInfos[i].withIsNoEscape(
true);
5228 HasAnyInterestingExtParameterInfos =
true;
5231 ParamTys.push_back(ParamTy);
5234 if (HasAnyInterestingExtParameterInfos) {
5243 Expr *NoexceptExpr =
nullptr;
5249 DynamicExceptions.reserve(N);
5250 DynamicExceptionRanges.reserve(N);
5251 for (
unsigned I = 0; I != N; ++I) {
5262 DynamicExceptionRanges,
5269 auto IsClassMember = [&]() {
5270 return (!state.getDeclarator().getCXXScopeSpec().isEmpty() &&
5271 state.getDeclarator()
5275 state.getDeclarator().getContext() ==
5277 state.getDeclarator().getContext() ==
5281 if (state.getSema().getLangOpts().OpenCLCPlusPlus && IsClassMember()) {
5311 inferPointerNullability(SimplePointerKind::MemberPointer, DeclType.
Loc,
5313 state.getDeclarator().getAttributePool());
5332 llvm_unreachable(
"Nested-name-specifier must name a type");
5342 if (isa<TemplateSpecializationType>(NNS->
getAsType()))
5344 NNSPrefix, ClsType);
5349 diag::err_illegal_decl_mempointer_in_nonclass)
5359 AreDeclaratorChunksValid =
false;
5364 AreDeclaratorChunksValid =
false;
5382 AreDeclaratorChunksValid =
false;
5391 S.
Diag(DeclType.
Loc, diag::warn_noderef_on_non_pointer_or_array);
5393 ExpectNoDerefChunk = state.didParseNoDeref();
5397 if (ExpectNoDerefChunk)
5398 S.
Diag(state.getDeclarator().getBeginLoc(),
5399 diag::warn_noderef_on_non_pointer_or_array);
5412 bool IsBlock =
false;
5414 switch (DeclType.Kind) {
5426 S.
Diag(DeclType.Loc, diag::warn_strict_prototypes)
5438 assert(!
T.isNull() &&
"T must not be null after this point");
5442 assert(FnTy &&
"Why oh why is there not a FunctionProtoType here?");
5455 ExplicitObjectMember,
5459 Kind = DeductionGuide;
5477 if (
P &&
P->isExplicitObjectParameter())
5478 Kind = ExplicitObjectMember;
5504 if (IsQualifiedFunction &&
5529 if (!RemovalLocs.empty()) {
5530 llvm::sort(RemovalLocs,
5532 RemovalRange =
SourceRange(RemovalLocs.front(), RemovalLocs.back());
5533 Loc = RemovalLocs.front();
5537 S.
Diag(
Loc, diag::err_invalid_qualified_function_type)
5561 if (!AL.slidesFromDeclToDeclSpecLegacyBehavior()) {
5569 state.diagnoseIgnoredTypeAttrs(
T);
5580 if (
T.isVolatileQualified() && S.
getLangOpts().CPlusPlus20 &&
5608 diag::err_function_parameter_pack_without_parameter_packs)
5629 LangOpts.CPlusPlus11
5630 ? diag::warn_cxx98_compat_variadic_templates
5631 : diag::ext_variadic_templates);
5661 diag::err_ellipsis_in_declarator_not_parameter);
5667 assert(!
T.isNull() &&
"T must not be null at the end of this function");
5668 if (!AreDeclaratorChunksValid)
5682 TypeProcessingState state(*
this, D);
5705 unsigned chunkIndex) {
5706 Sema &S = state.getSema();
5714 const char *attrStr =
nullptr;
5715 switch (ownership) {
5734 &Args, 1, ParsedAttr::Form::GNU());
5743 Sema &S = state.getSema();
5747 bool hasIndirection =
false;
5750 switch (chunk.
Kind) {
5759 hasIndirection =
true;
5792 TypeProcessingState state(*
this, D);
5807 TypeProcessingState &State) {
5814 if (AL.getKind() == ParsedAttr::AT_MatrixType) {
5823 llvm_unreachable(
"no matrix_type attribute found at the expected location!");
5827 class TypeSpecLocFiller :
public TypeLocVisitor<TypeSpecLocFiller> {
5830 TypeProcessingState &State;
5834 TypeSpecLocFiller(
Sema &S,
ASTContext &Context, TypeProcessingState &State,
5836 : SemaRef(S), Context(Context), State(State), DS(DS) {}
5848 State.getExpansionLocForMacroQualifiedType(TL.
getTypePtr()));
5971 void VisitDependentTemplateSpecializationTypeLoc(
6000 if (TemplateId->
NumArgs > 0) {
6011 TN.getKind() == TemplateName::NameKind::UsingTemplate
6012 ? cast<NamedDecl>(TN.getAsUsingShadowDecl())
6013 : cast_if_present<NamedDecl>(TN.getAsTemplateDecl()),
6056 void VisitTypeLoc(
TypeLoc TL) {
6062 class DeclaratorLocFiller :
public TypeLocVisitor<DeclaratorLocFiller> {
6064 TypeProcessingState &State;
6068 DeclaratorLocFiller(
ASTContext &Context, TypeProcessingState &State,
6070 : Context(Context), State(State), Chunk(Chunk) {}
6073 llvm_unreachable(
"qualified type locs not expected here!");
6076 llvm_unreachable(
"decayed type locs not expected here!");
6079 llvm_unreachable(
"array parameter type locs not expected here!");
6118 assert(isa<DependentNameType>(ClsTy) &&
"Unexpected TypeLoc");
6129 if (isa<ElaboratedType>(ClsTy)) {
6144 llvm_unreachable(
"Nested-name-specifier must name a type");
6176 for (
unsigned i = 0, e = TL.
getNumParams(), tpi = 0; i != e; ++i) {
6212 void VisitTypeLoc(
TypeLoc TL) {
6213 llvm_unreachable(
"unsupported TypeLoc kind in declarator!");
6220 switch (Chunk.
Kind) {
6225 llvm_unreachable(
"cannot be _Atomic qualified");
6246 if (AL.getKind() == ParsedAttr::AT_AddressSpace) {
6255 "no address_space attribute found at the expected location!");
6269 Sema &S = State.getSema();
6276 if (isa<PackExpansionType>(
T)) {
6295 bool HasDesugaredTypeLoc =
true;
6296 while (HasDesugaredTypeLoc) {
6298 case TypeLoc::MacroQualified: {
6301 State.getExpansionLocForMacroQualifiedType(TL.
getTypePtr()));
6306 case TypeLoc::Attributed: {
6313 case TypeLoc::Adjusted:
6314 case TypeLoc::BTFTagAttributed: {
6319 case TypeLoc::DependentAddressSpace: {
6327 HasDesugaredTypeLoc =
false;
6338 if (ReturnTypeInfo) {
6358 "LocInfoType's TypeClass conflicts with an existing Type class");
6364 llvm_unreachable(
"LocInfoType leaked into the type system; an opaque TypeTy*"
6365 " was used directly instead of getting the QualType through"
6366 " GetTypeFromParser");
6373 "Type name should have no identifier!");
6411 const Expr *AddrSpace,
6414 std::optional<llvm::APSInt> OptAddrSpace =
6416 if (!OptAddrSpace) {
6417 S.
Diag(AttrLoc, diag::err_attribute_argument_type)
6422 llvm::APSInt &addrSpace = *OptAddrSpace;
6425 if (addrSpace.isSigned()) {
6426 if (addrSpace.isNegative()) {
6427 S.
Diag(AttrLoc, diag::err_attribute_address_space_negative)
6431 addrSpace.setIsSigned(
false);
6434 llvm::APSInt
max(addrSpace.getBitWidth());
6438 if (addrSpace >
max) {
6439 S.
Diag(AttrLoc, diag::err_attribute_address_space_too_high)
6474 Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
6490 TypeProcessingState &State) {
6491 Sema &S = State.getSema();
6494 if (
Attr.getNumArgs() != 1) {
6495 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
6502 auto *StrLiteral = dyn_cast<StringLiteral>(
Attr.getArgAsExpr(0));
6511 StringRef BTFTypeTag = StrLiteral->getString();
6512 Type = State.getBTFTagAttributedType(
6513 ::new (Ctx) BTFTypeTagAttr(Ctx,
Attr, BTFTypeTag),
Type);
6521 TypeProcessingState &State) {
6522 Sema &S = State.getSema();
6527 S.
Diag(
Attr.
getLoc(), diag::err_attribute_address_function_type);
6533 if (
Attr.
getKind() == ParsedAttr::AT_AddressSpace) {
6536 if (
Attr.getNumArgs() != 1) {
6543 Expr *ASArgExpr =
static_cast<Expr *
>(
Attr.getArgAsExpr(0));
6552 ::new (Ctx) AddressSpaceAttr(Ctx,
Attr,
static_cast<unsigned>(ASIdx));
6564 if (EquivType.
isNull()) {
6568 T = State.getAttributedType(ASAttr,
Type, EquivType);
6570 T = State.getAttributedType(ASAttr,
Type,
Type);
6581 :
Attr.asOpenCLLangAS();
6583 ASIdx =
Attr.asHLSLLangAS();
6586 llvm_unreachable(
"Invalid address space");
6604 bool NonObjCPointer =
false;
6606 if (!
type->isDependentType() && !
type->isUndeducedType()) {
6614 NonObjCPointer =
true;
6615 }
else if (!
type->isObjCRetainableType()) {
6621 if (state.isProcessingDeclSpec()) {
6629 Sema &S = state.getSema();
6635 if (!
attr.isArgIdent(0)) {
6636 S.
Diag(AttrLoc, diag::err_attribute_argument_type) <<
attr
6644 if (II->
isStr(
"none"))
6646 else if (II->
isStr(
"strong"))
6648 else if (II->
isStr(
"weak"))
6650 else if (II->
isStr(
"autoreleasing"))
6653 S.
Diag(AttrLoc, diag::warn_attribute_type_not_supported) <<
attr << II;
6670 =
type.getQualifiers().getObjCLifetime()) {
6673 S.
Diag(AttrLoc, diag::err_attr_objc_ownership_redundant)
6680 if (previousLifetime != lifetime) {
6683 const Type *prevTy =
nullptr;
6684 while (!prevTy || prevTy != underlyingType.
Ty) {
6685 prevTy = underlyingType.
Ty;
6694 if (NonObjCPointer) {
6695 StringRef name =
attr.getAttrName()->getName();
6704 S.
Diag(AttrLoc, diag::warn_type_attribute_wrong_type) << name
6721 type = state.getAttributedType(
6722 createSimpleAttr<ObjCInertUnsafeUnretainedAttr>(S.
Context,
attr),
6728 if (!NonObjCPointer)
6745 diagnostic,
type, 0));
6747 S.
Diag(loc, diagnostic);
6756 unsigned diagnostic =
6757 (S.
getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled
6758 : diag::err_arc_weak_no_runtime);
6761 diagnoseOrDelay(S, AttrLoc, diagnostic,
type);
6773 if (
Class->isArcWeakrefUnavailable()) {
6774 S.
Diag(AttrLoc, diag::err_arc_unsupported_weak_class);
6775 S.
Diag(ObjT->getInterfaceDecl()->getLocation(),
6776 diag::note_class_declared);
6791 Sema &S = state.getSema();
6794 if (!
type->isPointerType() &&
6795 !
type->isObjCObjectPointerType() &&
6796 !
type->isBlockPointerType())
6800 S.
Diag(
attr.getLoc(), diag::err_attribute_multiple_objc_gc);
6806 if (!
attr.isArgIdent(0)) {
6807 S.
Diag(
attr.getLoc(), diag::err_attribute_argument_type)
6813 if (
attr.getNumArgs() > 1) {
6814 S.
Diag(
attr.getLoc(), diag::err_attribute_wrong_number_arguments) <<
attr
6821 if (II->
isStr(
"weak"))
6823 else if (II->
isStr(
"strong"))
6826 S.
Diag(
attr.getLoc(), diag::warn_attribute_type_not_supported)
6836 if (
attr.getLoc().isValid())
6837 type = state.getAttributedType(
6854 struct FunctionTypeUnwrapper {
6873 const Type *Ty =
T.getTypePtr();
6874 if (isa<FunctionType>(Ty)) {
6875 Fn = cast<FunctionType>(Ty);
6877 }
else if (isa<ParenType>(Ty)) {
6878 T = cast<ParenType>(Ty)->getInnerType();
6880 }
else if (isa<ConstantArrayType>(Ty) || isa<VariableArrayType>(Ty) ||
6881 isa<IncompleteArrayType>(Ty)) {
6882 T = cast<ArrayType>(Ty)->getElementType();
6883 Stack.push_back(Array);
6884 }
else if (isa<PointerType>(Ty)) {
6887 }
else if (isa<BlockPointerType>(Ty)) {
6889 Stack.push_back(BlockPointer);
6890 }
else if (isa<MemberPointerType>(Ty)) {
6892 Stack.push_back(MemberPointer);
6893 }
else if (isa<ReferenceType>(Ty)) {
6895 Stack.push_back(Reference);
6896 }
else if (isa<AttributedType>(Ty)) {
6897 T = cast<AttributedType>(Ty)->getEquivalentType();
6898 Stack.push_back(Attributed);
6899 }
else if (isa<MacroQualifiedType>(Ty)) {
6900 T = cast<MacroQualifiedType>(Ty)->getUnderlyingType();
6901 Stack.push_back(MacroQualified);
6910 Stack.push_back(Desugar);
6915 bool isFunctionType()
const {
return (Fn !=
nullptr); }
6920 if (New == get())
return Original;
6923 return wrap(S.
Context, Original, 0);
6928 if (I == Stack.size())
6937 return wrap(
C, SplitOld.
Ty, I);
6938 return C.getQualifiedType(wrap(
C, SplitOld.
Ty, I), SplitOld.
Quals);
6942 if (I == Stack.size())
return QualType(Fn, 0);
6944 switch (
static_cast<WrapKind
>(Stack[I++])) {
6951 return wrap(
C, cast<AttributedType>(Old)->getEquivalentType(), I);
6954 QualType New = wrap(
C, cast<ParenType>(Old)->getInnerType(), I);
6955 return C.getParenType(New);
6958 case MacroQualified:
6962 if (
const auto *CAT = dyn_cast<ConstantArrayType>(Old)) {
6963 QualType New = wrap(
C, CAT->getElementType(), I);
6964 return C.getConstantArrayType(New, CAT->getSize(), CAT->getSizeExpr(),
6965 CAT->getSizeModifier(),
6966 CAT->getIndexTypeCVRQualifiers());
6969 if (
const auto *VAT = dyn_cast<VariableArrayType>(Old)) {
6970 QualType New = wrap(
C, VAT->getElementType(), I);
6971 return C.getVariableArrayType(
6972 New, VAT->getSizeExpr(), VAT->getSizeModifier(),
6973 VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange());
6976 const auto *IAT = cast<IncompleteArrayType>(Old);
6977 QualType New = wrap(
C, IAT->getElementType(), I);
6978 return C.getIncompleteArrayType(New, IAT->getSizeModifier(),
6979 IAT->getIndexTypeCVRQualifiers());
6983 QualType New = wrap(
C, cast<PointerType>(Old)->getPointeeType(), I);
6984 return C.getPointerType(New);
6987 case BlockPointer: {
6988 QualType New = wrap(
C, cast<BlockPointerType>(Old)->getPointeeType(),I);
6989 return C.getBlockPointerType(New);
6992 case MemberPointer: {
6995 return C.getMemberPointerType(New, OldMPT->
getClass());
7001 if (isa<LValueReferenceType>(OldRef))
7004 return C.getRValueReferenceType(New);
7008 llvm_unreachable(
"unknown wrapping kind");
7015 Sema &S = State.getSema();
7019 default: llvm_unreachable(
"Unknown attribute kind");
7020 case ParsedAttr::AT_Ptr32:
7021 A = createSimpleAttr<Ptr32Attr>(S.
Context, PAttr);
7023 case ParsedAttr::AT_Ptr64:
7024 A = createSimpleAttr<Ptr64Attr>(S.
Context, PAttr);
7026 case ParsedAttr::AT_SPtr:
7027 A = createSimpleAttr<SPtrAttr>(S.
Context, PAttr);
7029 case ParsedAttr::AT_UPtr:
7030 A = createSimpleAttr<UPtrAttr>(S.
Context, PAttr);
7034 std::bitset<attr::LastAttr> Attrs;
7037 if (
const TypedefType *TT = dyn_cast<TypedefType>(Desugared)) {
7038 Desugared = TT->desugar();
7040 }
else if (
const ElaboratedType *ET = dyn_cast<ElaboratedType>(Desugared)) {
7041 Desugared = ET->desugar();
7054 if (Attrs[NewAttrKind]) {
7055 S.
Diag(PAttr.
getLoc(), diag::warn_duplicate_attribute_exact) << PAttr;
7058 Attrs[NewAttrKind] =
true;
7062 if (Attrs[attr::Ptr32] && Attrs[attr::Ptr64]) {
7063 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
7065 <<
"'__ptr64'" << 0;
7067 }
else if (Attrs[attr::SPtr] && Attrs[attr::UPtr]) {
7068 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
7076 if (!isa<PointerType>(Desugared)) {
7080 S.
Diag(PAttr.
getLoc(), diag::err_attribute_no_member_pointers) << PAttr;
7082 S.
Diag(PAttr.
getLoc(), diag::err_attribute_pointers_only) << PAttr << 0;
7090 if (PtrWidth == 32) {
7091 if (Attrs[attr::Ptr64])
7093 else if (Attrs[attr::UPtr])
7095 }
else if (PtrWidth == 64 && Attrs[attr::Ptr32]) {
7096 if (Attrs[attr::UPtr])
7112 assert(PAttr.
getKind() == ParsedAttr::AT_WebAssemblyFuncref);
7114 Sema &S = State.getSema();
7115 Attr *A = createSimpleAttr<WebAssemblyFuncrefAttr>(S.
Context, PAttr);
7117 std::bitset<attr::LastAttr> Attrs;
7119 const auto *AT = dyn_cast<AttributedType>(QT);
7121 Attrs[AT->getAttrKind()] =
true;
7122 AT = dyn_cast<AttributedType>(AT->getModifiedType());
7127 if (Attrs[NewAttrKind]) {
7128 S.
Diag(PAttr.
getLoc(), diag::warn_duplicate_attribute_exact) << PAttr;
7144 auto Attributed = dyn_cast<AttributedType>(
Type.getTypePtr());
7149 if (Attributed->getImmediateNullability())
7150 return Attributed->getModifiedType();
7154 Ctx, Attributed->getModifiedType());
7155 assert(Modified.
getTypePtr() != Attributed->getModifiedType().getTypePtr());
7157 Attributed->getEquivalentType());
7163 case ParsedAttr::AT_TypeNonNull:
7166 case ParsedAttr::AT_TypeNullable:
7169 case ParsedAttr::AT_TypeNullableResult:
7172 case ParsedAttr::AT_TypeNullUnspecified:
7176 llvm_unreachable(
"not a nullability attribute kind");
7183 bool IsContextSensitive,
bool AllowOnArrayType,
bool OverrideExisting) {
7184 bool Implicit = (State ==
nullptr);
7190 while (
auto *Attributed = dyn_cast<AttributedType>(Desugared.
getTypePtr())) {
7192 if (
auto ExistingNullability = Attributed->getImmediateNullability()) {
7194 if (Nullability == *ExistingNullability) {
7198 S.
Diag(NullabilityLoc, diag::warn_nullability_duplicate)
7205 if (!OverrideExisting) {
7207 S.
Diag(NullabilityLoc, diag::err_nullability_conflicting)
7217 Desugared = Attributed->getModifiedType();
7225 if (Nullability != *ExistingNullability && !
Implicit) {
7226 S.
Diag(NullabilityLoc, diag::err_nullability_conflicting)
7234 if (
auto typedefNullability =
7236 if (*typedefNullability == *ExistingNullability) {
7249 !(AllowOnArrayType && Desugared->
isArrayType())) {
7251 S.
Diag(NullabilityLoc, diag::err_nullability_nonpointer)
7259 if (IsContextSensitive) {
7261 const Type *pointeeType =
nullptr;
7270 S.
Diag(NullabilityLoc, diag::err_nullability_cs_multilevel)
7272 S.
Diag(NullabilityLoc, diag::note_nullability_type_specifier)
7284 QT = State->getAttributedType(A, QT, QT);
7294 bool AllowOnArrayType) {
7300 Nullability, NullabilityLoc,
7301 IsContextSensitive, AllowOnArrayType,
7308 bool AllowArrayTypes,
7309 bool OverrideExisting) {
7311 *
this,
nullptr,
nullptr,
Type, Nullability, DiagLoc,
7312 false, AllowArrayTypes, OverrideExisting);
7319 Sema &S = state.getSema();
7321 if (isa<ObjCTypeParamType>(
type)) {
7323 type = state.getAttributedType(
7336 S.
Diag(
attr.getLoc(), diag::err_objc_kindof_nonobject)
7345 objType->getBaseType(), objType->getTypeArgsAsWritten(),
7346 objType->getProtocols(),
7347 objType->isObjCUnqualifiedId() ?
false :
true);
7352 if (
auto nullability =
type->getNullability()) {
7355 assert(
attr.getAttributeSpellingListIndex() == 0 &&
7356 "multiple spellings for __kindof?");
7359 equivType = state.getAttributedType(A, equivType, equivType);
7364 type = state.getAttributedType(
7377 Declarator &declarator = state.getDeclarator();
7380 auto moveToChunk = [&](
DeclaratorChunk &chunk,
bool inFunction) ->
bool {
7393 PK_MemberFunctionPointer,
7398 : inFunction? PK_MemberFunctionPointer : PK_MemberPointer;
7400 auto diag = state.getSema().Diag(
attr.getLoc(),
7401 diag::warn_nullability_declspec)
7403 attr.isContextSensitiveKeywordAttribute())
7405 <<
static_cast<unsigned>(pointerKind);
7411 state.getSema().getPreprocessor().getLocForEndOfToken(
7413 " " +
attr.getAttrName()->getName().str() +
" ");
7423 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
7425 switch (chunk.
Kind) {
7429 return moveToChunk(chunk,
false);
7441 return moveToChunk(*dest,
true);
7457 assert(!
Attr.isInvalid());
7460 llvm_unreachable(
"not a calling convention attribute");
7461 case ParsedAttr::AT_CDecl:
7462 return createSimpleAttr<CDeclAttr>(Ctx,
Attr);
7463 case ParsedAttr::AT_FastCall:
7464 return createSimpleAttr<FastCallAttr>(Ctx,
Attr);
7465 case ParsedAttr::AT_StdCall:
7466 return createSimpleAttr<StdCallAttr>(Ctx,
Attr);
7467 case ParsedAttr::AT_ThisCall:
7468 return createSimpleAttr<ThisCallAttr>(Ctx,
Attr);
7469 case ParsedAttr::AT_RegCall:
7470 return createSimpleAttr<RegCallAttr>(Ctx,
Attr);
7471 case ParsedAttr::AT_Pascal:
7472 return createSimpleAttr<PascalAttr>(Ctx,
Attr);
7473 case ParsedAttr::AT_SwiftCall:
7474 return createSimpleAttr<SwiftCallAttr>(Ctx,
Attr);
7475 case ParsedAttr::AT_SwiftAsyncCall:
7476 return createSimpleAttr<SwiftAsyncCallAttr>(Ctx,
Attr);
7477 case ParsedAttr::AT_VectorCall:
7478 return createSimpleAttr<VectorCallAttr>(Ctx,
Attr);
7479 case ParsedAttr::AT_AArch64VectorPcs:
7480 return createSimpleAttr<AArch64VectorPcsAttr>(Ctx,
Attr);
7481 case ParsedAttr::AT_AArch64SVEPcs:
7482 return createSimpleAttr<AArch64SVEPcsAttr>(Ctx,
Attr);
7483 case ParsedAttr::AT_ArmStreaming:
7484 return createSimpleAttr<ArmStreamingAttr>(Ctx,
Attr);
7485 case ParsedAttr::AT_AMDGPUKernelCall:
7486 return createSimpleAttr<AMDGPUKernelCallAttr>(Ctx,
Attr);
7487 case ParsedAttr::AT_Pcs: {
7492 if (
Attr.isArgExpr(0))
7493 Str = cast<StringLiteral>(
Attr.getArgAsExpr(0))->getString();
7495 Str =
Attr.getArgAsIdent(0)->Ident->getName();
7496 PcsAttr::PCSType
Type;
7497 if (!PcsAttr::ConvertStrToPCSType(Str,
Type))
7498 llvm_unreachable(
"already validated the attribute");
7499 return ::new (Ctx) PcsAttr(Ctx,
Attr,
Type);
7501 case ParsedAttr::AT_IntelOclBicc:
7502 return createSimpleAttr<IntelOclBiccAttr>(Ctx,
Attr);
7503 case ParsedAttr::AT_MSABI:
7504 return createSimpleAttr<MSABIAttr>(Ctx,
Attr);
7505 case ParsedAttr::AT_SysVABI:
7506 return createSimpleAttr<SysVABIAttr>(Ctx,
Attr);
7507 case ParsedAttr::AT_PreserveMost:
7508 return createSimpleAttr<PreserveMostAttr>(Ctx,
Attr);
7509 case ParsedAttr::AT_PreserveAll:
7510 return createSimpleAttr<PreserveAllAttr>(Ctx,
Attr);
7511 case ParsedAttr::AT_M68kRTD:
7512 return createSimpleAttr<M68kRTDAttr>(Ctx,
Attr);
7513 case ParsedAttr::AT_PreserveNone:
7514 return createSimpleAttr<PreserveNoneAttr>(Ctx,
Attr);
7515 case ParsedAttr::AT_RISCVVectorCC:
7516 return createSimpleAttr<RISCVVectorCCAttr>(Ctx,
Attr);
7518 llvm_unreachable(
"unexpected attribute kind!");
7525 auto OtherAttr = std::find_if(
7526 state.getCurrentAttributes().begin(), state.getCurrentAttributes().end(),
7527 [OtherKind](
const ParsedAttr &A) { return A.getKind() == OtherKind; });
7528 if (OtherAttr == state.getCurrentAttributes().end() || OtherAttr->isInvalid())
7531 Sema &S = state.getSema();
7533 << *OtherAttr <<
Attr
7534 << (OtherAttr->isRegularKeywordAttribute() ||
7536 S.
Diag(OtherAttr->getLoc(), diag::note_conflicting_attribute);
7545 if (!
Attr.getNumArgs()) {
7551 for (
unsigned I = 0; I <
Attr.getNumArgs(); ++I) {
7552 StringRef StateName;
7559 if (StateName ==
"za") {
7562 }
else if (StateName ==
"zt0") {
7566 S.
Diag(LiteralLoc, diag::err_unknown_arm_state) << StateName;
7575 S.
Diag(LiteralLoc, diag::err_conflicting_attributes_arm_state)
7591 Sema &S = state.getSema();
7593 FunctionTypeUnwrapper unwrapped(S,
type);
7595 if (
attr.getKind() == ParsedAttr::AT_NoReturn) {
7600 if (!unwrapped.isFunctionType())
7609 if (
attr.getKind() == ParsedAttr::AT_CmseNSCall) {
7611 if (!unwrapped.isFunctionType())
7616 S.
Diag(
attr.getLoc(), diag::warn_attribute_ignored) <<
attr;
7623 unwrapped.get()->getExtInfo().withCmseNSCall(
true);
7630 if (
attr.getKind() == ParsedAttr::AT_NSReturnsRetained) {
7631 if (
attr.getNumArgs())
return true;
7634 if (!unwrapped.isFunctionType())
7639 unwrapped.get()->getReturnType()))
7644 if (state.getSema().getLangOpts().ObjCAutoRefCount) {
7646 = unwrapped.get()->getExtInfo().withProducesResult(
true);
7649 type = state.getAttributedType(
7650 createSimpleAttr<NSReturnsRetainedAttr>(S.
Context,
attr),
7655 if (
attr.getKind() == ParsedAttr::AT_AnyX86NoCallerSavedRegisters) {
7660 if (!unwrapped.isFunctionType())
7664 unwrapped.get()->getExtInfo().withNoCallerSavedRegs(
true);
7669 if (
attr.getKind() == ParsedAttr::AT_AnyX86NoCfCheck) {
7671 S.
Diag(
attr.getLoc(), diag::warn_nocf_check_attribute_ignored);
7681 if (!unwrapped.isFunctionType())
7685 unwrapped.get()->getExtInfo().withNoCfCheck(
true);
7690 if (
attr.getKind() == ParsedAttr::AT_Regparm) {
7696 if (!unwrapped.isFunctionType())
7703 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
7705 <<
attr.isRegularKeywordAttribute();
7711 unwrapped.get()->getExtInfo().withRegParm(value);
7716 if (
attr.getKind() == ParsedAttr::AT_ArmStreaming ||
7717 attr.getKind() == ParsedAttr::AT_ArmStreamingCompatible ||
7718 attr.getKind() == ParsedAttr::AT_ArmPreserves ||
7719 attr.getKind() == ParsedAttr::AT_ArmIn ||
7720 attr.getKind() == ParsedAttr::AT_ArmOut ||
7721 attr.getKind() == ParsedAttr::AT_ArmInOut) {
7725 if (
attr.getKind() == ParsedAttr::AT_ArmStreaming ||
7726 attr.getKind() == ParsedAttr::AT_ArmStreamingCompatible)
7730 if (!unwrapped.isFunctionType())
7737 S.
Diag(
attr.getLoc(), diag::warn_attribute_wrong_decl_type) <<
7744 switch (
attr.getKind()) {
7745 case ParsedAttr::AT_ArmStreaming:
7747 ParsedAttr::AT_ArmStreamingCompatible))
7751 case ParsedAttr::AT_ArmStreamingCompatible:
7756 case ParsedAttr::AT_ArmPreserves:
7760 case ParsedAttr::AT_ArmIn:
7764 case ParsedAttr::AT_ArmOut:
7768 case ParsedAttr::AT_ArmInOut:
7773 llvm_unreachable(
"Unsupported attribute");
7777 FnTy->getParamTypes(), EPI);
7782 if (
attr.getKind() == ParsedAttr::AT_NoThrow) {
7784 if (!unwrapped.isFunctionType())
7797 if (Proto->hasExceptionSpec()) {
7798 switch (Proto->getExceptionSpecType()) {
7800 llvm_unreachable(
"This doesn't have an exception spec!");
7818 S.
Diag(
attr.getLoc(), diag::warn_nothrow_attribute_ignored);
7824 type = unwrapped.wrap(
7834 if (!unwrapped.isFunctionType())
return false;
7849 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
7852 <<
attr.isRegularKeywordAttribute();
7871 return S.
Diag(
attr.getLoc(), diag::warn_cconv_unsupported)
7876 return S.
Diag(
attr.getLoc(), diag::err_cconv_varargs)
7883 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
7885 <<
attr.isRegularKeywordAttribute();
7897 auto EI = unwrapped.get()->getExtInfo().withCallingConv(CC);
7921 FunctionTypeUnwrapper Unwrapped(*
this,
T);
7923 bool IsVariadic = (isa<FunctionProtoType>(FT) &&
7924 cast<FunctionProtoType>(FT)->isVariadic());
7938 Diag(
Loc, diag::warn_cconv_unsupported)
7949 if (CurCC != DefaultCC)
7957 QualType Wrapped = Unwrapped.wrap(*
this, FT);
7971 if (
Attr.getNumArgs() != 1) {
7978 Expr *SizeExpr =
Attr.getArgAsExpr(0);
7991 if (
Attr.getNumArgs() != 1) {
7997 Expr *SizeExpr =
Attr.getArgAsExpr(0);
8012 bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 ||
8013 Triple.getArch() == llvm::Triple::aarch64_32 ||
8014 Triple.getArch() == llvm::Triple::aarch64_be;
8016 if (IsPolyUnsigned) {
8018 return BTy->
getKind() == BuiltinType::UChar ||
8019 BTy->
getKind() == BuiltinType::UShort ||
8020 BTy->
getKind() == BuiltinType::ULong ||
8021 BTy->
getKind() == BuiltinType::ULongLong;
8024 return BTy->
getKind() == BuiltinType::SChar ||
8025 BTy->
getKind() == BuiltinType::Short ||
8026 BTy->
getKind() == BuiltinType::LongLong;
8032 if ((Triple.isArch64Bit() || Triple.getArch() == llvm::Triple::aarch64_32) &&
8033 BTy->
getKind() == BuiltinType::Double)
8036 return BTy->
getKind() == BuiltinType::SChar ||
8037 BTy->
getKind() == BuiltinType::UChar ||
8038 BTy->
getKind() == BuiltinType::Short ||
8039 BTy->
getKind() == BuiltinType::UShort ||
8040 BTy->
getKind() == BuiltinType::Int ||
8041 BTy->
getKind() == BuiltinType::UInt ||
8042 BTy->
getKind() == BuiltinType::Long ||
8043 BTy->
getKind() == BuiltinType::ULong ||
8044 BTy->
getKind() == BuiltinType::LongLong ||
8045 BTy->
getKind() == BuiltinType::ULongLong ||
8046 BTy->
getKind() == BuiltinType::Float ||
8047 BTy->
getKind() == BuiltinType::Half ||
8048 BTy->
getKind() == BuiltinType::BFloat16;
8053 const auto *AttrExpr =
Attr.getArgAsExpr(0);
8054 if (!AttrExpr->isTypeDependent()) {
8055 if (std::optional<llvm::APSInt> Res =
8056 AttrExpr->getIntegerConstantExpr(S.
Context)) {
8076 bool IsTargetCUDAAndHostARM =
false;
8079 IsTargetCUDAAndHostARM =
8089 IsTargetCUDAAndHostARM) &&
8092 <<
Attr <<
"'neon', 'mve', 'sve' or 'sme'";
8098 IsTargetCUDAAndHostARM) &&
8101 <<
Attr <<
"'neon' or 'mve'";
8107 if (
Attr.getNumArgs() != 1) {
8108 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8114 llvm::APSInt numEltsInt(32);
8120 !IsTargetCUDAAndHostARM) {
8121 S.
Diag(
Attr.
getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
8128 unsigned numElts =
static_cast<unsigned>(numEltsInt.getZExtValue());
8129 unsigned vecSize = typeSize * numElts;
8130 if (vecSize != 64 && vecSize != 128) {
8131 S.
Diag(
Attr.
getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType;
8155 S.
Diag(
Attr.
getLoc(), diag::err_attribute_arm_feature_sve_bits_unsupported)
8162 if (
Attr.getNumArgs() != 1) {
8163 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8170 llvm::APSInt SveVectorSizeInBits(32);
8174 unsigned VecSize =
static_cast<unsigned>(SveVectorSizeInBits.getZExtValue());
8197 if (BT->getKind() == BuiltinType::SveBool) {
8202 VecSize /= TypeSize;
8209 const VectorType *VT = dyn_cast<VectorType>(CurType);
8212 diag::err_attribute_arm_mve_polymorphism);
8218 State.getAttributedType(createSimpleAttr<ArmMveStrictPolymorphismAttr>(
8219 State.getSema().Context,
Attr),
8231 <<
Attr <<
"'zve32x'";
8237 if (!VScale || !VScale->first || VScale->first != VScale->second) {
8238 S.
Diag(
Attr.
getLoc(), diag::err_attribute_riscv_rvv_bits_unsupported)
8245 if (
Attr.getNumArgs() != 1) {
8246 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8253 llvm::APSInt RVVVectorSizeInBits(32);
8265 unsigned VecSize =
static_cast<unsigned>(RVVVectorSizeInBits.getZExtValue());
8269 unsigned MinElts = Info.
EC.getKnownMinValue();
8272 unsigned ExpectedSize = VScale->first * MinElts;
8280 ExpectedSize *= EltSize;
8281 NumElts = VecSize / EltSize;
8285 if (ExpectedSize % 8 != 0 || VecSize != ExpectedSize) {
8287 << VecSize << ExpectedSize;
8300 S.
Diag(
Attr.
getLoc(), diag::err_opencl_invalid_access_qualifier);
8306 QualType BaseTy = TypedefTy->desugar();
8308 std::string PrevAccessQual;
8310 if (TypedefTy->getDecl()->hasAttr<OpenCLAccessAttr>()) {
8311 OpenCLAccessAttr *
Attr =
8312 TypedefTy->getDecl()->getAttr<OpenCLAccessAttr>();
8315 PrevAccessQual =
"read_only";
8319 switch (ImgType->getKind()) {
8320 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8321 case BuiltinType::Id: \
8322 PrevAccessQual = #Access; \
8324 #include "clang/Basic/OpenCLImageTypes.def"
8326 llvm_unreachable(
"Unable to find corresponding image type.");
8329 llvm_unreachable(
"unexpected type");
8332 if (PrevAccessQual == AttrName.ltrim(
"_")) {
8338 S.
Diag(
Attr.
getLoc(), diag::err_opencl_multiple_access_qualifiers);
8341 S.
Diag(TypedefTy->getDecl()->getBeginLoc(),
8342 diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;
8344 if (
Attr.getSemanticSpelling() == OpenCLAccessAttr::Keyword_write_only) {
8359 if (
Attr.getNumArgs() != 2) {
8360 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8365 Expr *RowsExpr =
Attr.getArgAsExpr(0);
8366 Expr *ColsExpr =
Attr.getArgAsExpr(1);
8374 Sema &S = State.getSema();
8377 S.
Diag(PA.
getLoc(), diag::err_attribute_too_few_arguments) << PA << 1;
8389 for (
unsigned Idx = 1; Idx < PA.
getNumArgs(); Idx++) {
8395 auto *AnnotateTypeAttr =
8396 AnnotateTypeAttr::Create(S.
Context, Str, Args.data(), Args.size(), PA);
8397 CurType = State.getAttributedType(AnnotateTypeAttr, CurType, CurType);
8403 if (State.getDeclarator().isDeclarationOfFunction()) {
8404 CurType = State.getAttributedType(
8405 createSimpleAttr<LifetimeBoundAttr>(State.getSema().Context,
Attr),
8416 if (
Attr.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_inout ||
8417 Attr.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_out)
8426 state.setParsedNoDeref(
false);
8442 if (
attr.isInvalid())
8445 if (
attr.isStandardAttributeSyntax() ||
attr.isRegularKeywordAttribute()) {
8450 if (
attr.isGNUScope()) {
8451 assert(
attr.isStandardAttributeSyntax());
8452 bool IsTypeAttr =
attr.isTypeAttr();
8454 state.getSema().Diag(
attr.getLoc(),
8456 ? diag::warn_gcc_ignores_type_attr
8457 : diag::warn_cxx11_gnu_attribute_on_type)
8463 !
attr.isTypeAttr()) {
8476 switch (
attr.getKind()) {
8479 if ((
attr.isStandardAttributeSyntax() ||
8480 attr.isRegularKeywordAttribute()) &&
8482 state.getSema().Diag(
attr.getLoc(), diag::err_attribute_not_type_attr)
8483 <<
attr <<
attr.isRegularKeywordAttribute();
8484 attr.setUsedAsTypeAttr();
8489 if (
attr.isStandardAttributeSyntax()) {
8490 state.getSema().Diag(
attr.getLoc(),
8491 diag::warn_unknown_attribute_ignored)
8502 case ParsedAttr::AT_BTFTypeTag:
8504 attr.setUsedAsTypeAttr();
8507 case ParsedAttr::AT_MayAlias:
8510 attr.setUsedAsTypeAttr();
8512 case ParsedAttr::AT_OpenCLPrivateAddressSpace:
8513 case ParsedAttr::AT_OpenCLGlobalAddressSpace:
8514 case ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace:
8515 case ParsedAttr::AT_OpenCLGlobalHostAddressSpace:
8516 case ParsedAttr::AT_OpenCLLocalAddressSpace:
8517 case ParsedAttr::AT_OpenCLConstantAddressSpace:
8518 case ParsedAttr::AT_OpenCLGenericAddressSpace:
8519 case ParsedAttr::AT_HLSLGroupSharedAddressSpace:
8520 case ParsedAttr::AT_AddressSpace:
8522 attr.setUsedAsTypeAttr();
8527 attr.setUsedAsTypeAttr();
8529 case ParsedAttr::AT_VectorSize:
8531 attr.setUsedAsTypeAttr();
8533 case ParsedAttr::AT_ExtVectorType:
8535 attr.setUsedAsTypeAttr();
8537 case ParsedAttr::AT_NeonVectorType:
8539 attr.setUsedAsTypeAttr();
8541 case ParsedAttr::AT_NeonPolyVectorType:
8544 attr.setUsedAsTypeAttr();
8546 case ParsedAttr::AT_ArmSveVectorBits:
8548 attr.setUsedAsTypeAttr();
8550 case ParsedAttr::AT_ArmMveStrictPolymorphism: {
8552 attr.setUsedAsTypeAttr();
8555 case ParsedAttr::AT_RISCVRVVVectorBits:
8557 attr.setUsedAsTypeAttr();
8559 case ParsedAttr::AT_OpenCLAccess:
8561 attr.setUsedAsTypeAttr();
8563 case ParsedAttr::AT_LifetimeBound:
8568 case ParsedAttr::AT_NoDeref: {
8573 if (
attr.isStandardAttributeSyntax()) {
8574 state.getSema().Diag(
attr.getLoc(), diag::warn_attribute_ignored)
8579 type = state.getAttributedType(createSimpleAttr<NoDerefAttr>(Ctx,
attr),
8581 attr.setUsedAsTypeAttr();
8582 state.setParsedNoDeref(
true);
8586 case ParsedAttr::AT_MatrixType:
8588 attr.setUsedAsTypeAttr();
8591 case ParsedAttr::AT_WebAssemblyFuncref: {
8593 attr.setUsedAsTypeAttr();
8597 case ParsedAttr::AT_HLSLParamModifier: {
8599 attr.setUsedAsTypeAttr();
8605 attr.setUsedAsTypeAttr();
8613 if (
type->canHaveNullability() ||
type->isDependentType() ||
8614 type->isArrayType() ||
8618 endIndex = state.getCurrentChunkIndex();
8620 endIndex = state.getDeclarator().getNumTypeObjects();
8621 bool allowOnArrayType =
8622 state.getDeclarator().isPrototypeContext() &&
8625 allowOnArrayType)) {
8629 attr.setUsedAsTypeAttr();
8633 case ParsedAttr::AT_ObjCKindOf:
8641 state.getSema().Diag(
attr.getLoc(),
8642 diag::err_objc_kindof_wrong_position)
8645 state.getDeclarator().getDeclSpec().getBeginLoc(),
8655 case ParsedAttr::AT_NoThrow:
8658 if (!state.getSema().getLangOpts().CPlusPlus)
8662 attr.setUsedAsTypeAttr();
8666 if (
attr.isStandardAttributeSyntax() ||
8667 attr.isRegularKeywordAttribute()) {
8684 case ParsedAttr::AT_AcquireHandle: {
8685 if (!
type->isFunctionType())
8688 if (
attr.getNumArgs() != 1) {
8689 state.getSema().Diag(
attr.getLoc(),
8690 diag::err_attribute_wrong_number_arguments)
8696 StringRef HandleType;
8697 if (!state.getSema().checkStringLiteralArgumentAttr(
attr, 0, HandleType))
8699 type = state.getAttributedType(
8700 AcquireHandleAttr::Create(state.getSema().Context, HandleType,
attr),
8702 attr.setUsedAsTypeAttr();
8705 case ParsedAttr::AT_AnnotateType: {
8707 attr.setUsedAsTypeAttr();
8714 if (isa<AttributedType>(
type) &&
attr.hasMacroIdentifier() &&
8715 !
type.getQualifiers().hasObjCLifetime() &&
8716 !
type.getQualifiers().hasObjCGCAttr() &&
8717 attr.getKind() != ParsedAttr::AT_ObjCGC &&
8718 attr.getKind() != ParsedAttr::AT_ObjCOwnership) {
8720 type = state.getSema().Context.getMacroQualifiedType(
type, MacroII);
8721 state.setExpansionLocForMacroQualifiedType(
8722 cast<MacroQualifiedType>(
type.getTypePtr()),
8723 attr.getMacroExpansionLoc());
8730 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
8732 auto *Def = Var->getDefinition();
8738 Def = Var->getDefinition();
8745 if (Var->getPointOfInstantiation().isInvalid() && Def) {
8746 assert(Var->getTemplateSpecializationKind() ==
8748 "explicit instantiation with no point of instantiation");
8749 Var->setTemplateSpecializationKind(
8750 Var->getTemplateSpecializationKind(), PointOfInstantiation);
8834 if (RequireCompleteTypeImpl(
Loc,
T, Kind, &Diagnoser))
8837 if (!Tag->getDecl()->isCompleteDefinitionRequired()) {
8838 Tag->getDecl()->setCompleteDefinitionRequired();
8868 if (isa<TagDecl>(D) && cast<TagDecl>(D)->isBeingDefined()) {
8872 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
8873 if (
auto *Pattern = RD->getTemplateInstantiationPattern())
8875 D = RD->getDefinition();
8876 }
else if (
auto *ED = dyn_cast<EnumDecl>(D)) {
8877 if (
auto *Pattern = ED->getTemplateInstantiationPattern())
8879 if (OnlyNeedComplete && (ED->isFixed() ||
getLangOpts().MSVCCompat)) {
8885 *Suggested =
nullptr;
8886 for (
auto *Redecl : ED->redecls()) {
8889 if (Redecl->isThisDeclarationADefinition() ||
8890 (Redecl->isCanonicalDecl() && !*Suggested))
8891 *Suggested = Redecl;
8896 D = ED->getDefinition();
8897 }
else if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
8898 if (
auto *Pattern = FD->getTemplateInstantiationPattern())
8900 D = FD->getDefinition();
8901 }
else if (
auto *VD = dyn_cast<VarDecl>(D)) {
8902 if (
auto *Pattern = VD->getTemplateInstantiationPattern())
8904 D = VD->getDefinition();
8907 assert(D &&
"missing definition for pattern of instantiated definition");
8911 auto DefinitionIsAcceptable = [&] {
8931 if (DefinitionIsAcceptable())
8937 Source->CompleteRedeclChain(D);
8938 return DefinitionIsAcceptable();
8954 bool OnlyNeedComplete) {
8971 bool OnlyNeedComplete) {
8979 if (!RD->
hasAttr<MSInheritanceAttr>()) {
8981 bool BestCase =
false;
9001 RD->
addAttr(MSInheritanceAttr::CreateImplicit(
9009 CompleteTypeKind Kind,
9010 TypeDiagnoser *Diagnoser) {
9020 if (!MPTy->getClass()->isDependentType()) {
9022 !MPTy->getClass()->getAsCXXRecordDecl()->isBeingDefined() &&
9024 diag::err_memptr_incomplete))
9043 if (Def && !isa<EnumDecl>(Def))
9054 if (Diagnoser && Suggested)
9057 return !TreatAsComplete;
9059 CodeSynthesisContext TempInst;
9061 TempInst.Template = Def;
9062 TempInst.Entity = Def;
9063 TempInst.PointOfInstantiation =
Loc;
9071 TagDecl *Tag = dyn_cast_or_null<TagDecl>(Def);
9086 Source->CompleteType(Tag);
9088 Source->CompleteType(IFace);
9092 return RequireCompleteTypeImpl(
Loc,
T, Kind, Diagnoser);
9099 if (
auto *RD = dyn_cast_or_null<CXXRecordDecl>(Tag)) {
9100 bool Instantiated =
false;
9101 bool Diagnosed =
false;
9102 if (RD->isDependentContext()) {
9106 }
else if (
auto *ClassTemplateSpec =
9107 dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
9108 if (ClassTemplateSpec->getSpecializationKind() ==
TSK_Undeclared) {
9114 Instantiated =
true;
9118 if (!RD->isBeingDefined() && Pattern) {
9120 assert(MSI &&
"Missing member specialization information?");
9130 Instantiated =
true;
9138 if (Diagnoser && Diagnosed)
9144 return RequireCompleteTypeImpl(
Loc,
T, Kind, Diagnoser);
9154 Diagnoser->diagnose(*
this,
Loc,
T);
9161 : diag::note_forward_declaration)
9195 default: llvm_unreachable(
"Invalid tag kind for literal type diagnostic!");
9257 for (
const auto &I : RD->
vbases())
9258 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
9259 << I.getSourceRange();
9262 Diag(RD->
getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD;
9264 for (
const auto &I : RD->
bases()) {
9265 if (!I.getType()->isLiteralType(
Context)) {
9266 Diag(I.getBeginLoc(), diag::note_non_literal_base_class)
9267 << RD << I.getType() << I.getSourceRange();
9271 for (
const auto *I : RD->
fields()) {
9272 if (!I->getType()->isLiteralType(
Context) ||
9273 I->getType().isVolatileQualified()) {
9274 Diag(I->getLocation(), diag::note_non_literal_field)
9275 << RD << I << I->getType()
9276 << I->getType().isVolatileQualified();
9286 assert(Dtor &&
"class has literal fields and bases but no dtor?");
9295 ? diag::note_non_literal_user_provided_dtor
9296 : diag::note_non_literal_nontrivial_dtor)
9344 auto *CountDecl = cast<DeclRefExpr>(E)->getDecl();
9357 WrappedTy, CountExpr,
false,
false, Decls);
9366 if (
auto *ImplCastExpr = dyn_cast<ImplicitCastExpr>(E))
9367 IDExpr = ImplCastExpr->getSubExpr();
9369 if (
auto *PackExpr = dyn_cast<PackIndexingExpr>(E)) {
9371 IDExpr = PackExpr->getPackIdExpression();
9373 IDExpr = PackExpr->getSelectedExpr();
9389 if (
const auto *SNTTPE = dyn_cast<SubstNonTypeTemplateParmExpr>(IDExpr))
9390 return SNTTPE->getParameterType(
Context);
9398 if (
const auto *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
9401 return isa<TemplateParamObjectDecl>(VD) ?
T.getUnqualifiedType() :
T;
9403 if (
const auto *ME = dyn_cast<MemberExpr>(IDExpr)) {
9404 if (
const auto *VD = ME->getMemberDecl())
9405 if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
9406 return VD->getType();
9407 }
else if (
const auto *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
9408 return IR->getDecl()->getType();
9409 }
else if (
const auto *PR = dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {
9410 if (PR->isExplicitProperty())
9411 return PR->getExplicitProperty()->getType();
9412 }
else if (
const auto *PE = dyn_cast<PredefinedExpr>(IDExpr)) {
9413 return PE->getType();
9424 if (
auto *DRE = dyn_cast<DeclRefExpr>(IDExpr->
IgnoreParens())) {
9425 if (
auto *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
9445 Diag(E->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
9458 Diag(
Loc, diag::err_expected_name_of_pack) << Pattern;
9464 : diag::ext_pack_indexing);
9471 bool FullySubstituted,
9474 std::optional<int64_t> Index;
9482 Index =
Value.getExtValue();
9483 IndexExpr = Res.
get();
9486 if (FullySubstituted && Index) {
9487 if (*Index < 0 || *Index >= int64_t(Expansions.size())) {
9489 << *Index << Pattern << Expansions.size();
9495 Expansions, Index.value_or(-1));
9502 assert(ED &&
"EnumType has no EnumDecl");
9507 assert(!Underlying.
isNull());
9515 Diag(
Loc, diag::err_only_enums_have_underlying_types);
9523 Diag(
Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
9524 Diag(FwdDecl->
getLocation(), diag::note_forward_declaration) << FwdDecl;
9560 Split.Quals.removeCVRQualifiers();
9570 UKind == UnaryTransformType::AddLvalueReference,
9573 return Reference.isNull() ?
QualType() : Reference;
9578 if (UKind == UnaryTransformType::RemoveAllExtents)
9582 return AT->getElementType();
9591 if (UKind == UTTKind::RemoveCVRef &&
9592 (
T.isConstQualified() ||
T.isVolatileQualified())) {
9604 if ((BaseType->
isReferenceType() && UKind != UTTKind::RemoveRestrict) ||
9611 if (UKind == UTTKind::RemoveConst || UKind == UTTKind::RemoveCV)
9613 if (UKind == UTTKind::RemoveVolatile || UKind == UTTKind::RemoveCV)
9615 if (UKind == UTTKind::RemoveRestrict)
9626 if (
auto *
BitInt = dyn_cast<BitIntType>(Underlying)) {
9627 unsigned int Bits =
BitInt->getNumBits();
9631 S.
Diag(
Loc, diag::err_make_signed_integral_only)
9632 << IsMakeSigned <<
true << BaseType << 1 << Underlying;
9636 S.
Diag(
Loc, diag::err_make_signed_integral_only)
9637 << IsMakeSigned <<
false << BaseType << 1
9644 std::array<CanQualType *, 6> AllSignedIntegers = {
9648 AllSignedIntegers.data(), AllSignedIntegers.size() - Int128Unsupported);
9649 std::array<CanQualType *, 6> AllUnsignedIntegers = {
9654 AllUnsignedIntegers.size() -
9657 IsMakeSigned ? &AvailableSignedIntegers : &AvailableUnsignedIntegers;
9661 llvm::find_if(*Consider, [&S, BaseSize](
const CanQual<Type> *
T) {
9665 assert(
Result != Consider->end());
9666 return QualType((*Result)->getTypePtr(), 0);
9671 bool IsMakeSigned = UKind == UnaryTransformType::MakeSigned;
9676 Diag(
Loc, diag::err_make_signed_integral_only)
9677 << IsMakeSigned << BaseType->
isBitIntType() << BaseType << 0;
9681 bool IsNonIntIntegral =
9701 case UnaryTransformType::EnumUnderlyingType: {
9705 case UnaryTransformType::AddPointer: {
9709 case UnaryTransformType::RemovePointer: {
9713 case UnaryTransformType::Decay: {
9717 case UnaryTransformType::AddLvalueReference:
9718 case UnaryTransformType::AddRvalueReference: {
9722 case UnaryTransformType::RemoveAllExtents:
9723 case UnaryTransformType::RemoveExtent: {
9727 case UnaryTransformType::RemoveCVRef:
9728 case UnaryTransformType::RemoveReference: {
9732 case UnaryTransformType::RemoveConst:
9733 case UnaryTransformType::RemoveCV:
9734 case UnaryTransformType::RemoveRestrict:
9735 case UnaryTransformType::RemoveVolatile: {
9739 case UnaryTransformType::MakeSigned:
9740 case UnaryTransformType::MakeUnsigned: {
9758 int DisallowedKind = -1;
9767 else if (
T.hasQualifiers())
9780 if (DisallowedKind != -1) {
9781 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.
static bool isBlockPointer(Expr *Arg)
static bool isFunctionOrMethod(const Decl *D)
isFunctionOrMethod - Return true if the given decl has function type (function or function-typed vari...
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 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.
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.
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 getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
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 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
ParsedAttr * create(IdentifierInfo *attrName, SourceRange attrRange, IdentifierInfo *scopeName, SourceLocation scopeLoc, ArgsUnion *args, unsigned numArgs, ParsedAttr::Form form, SourceLocation ellipsisLoc=SourceLocation())
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)
SourceLocation getConceptNameLoc() const
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
bool isSet() const
Deprecated.
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
bool hasAutoTypeSpec() 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
AttributePool & getAttributePool() const
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
bool hasTagDefinition() const
static const TST TST_decimal64
unsigned getParsedSpecifiers() const
Return a bitmask of which flavors of specifiers this DeclSpec includes.
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
SourceLocation getUnalignedSpecLoc() const
static const TST TST_int128
SourceLocation getVolatileSpecLoc() const
FriendSpecified isFriendSpecified() const
static const TST TST_typeofType
static const TST TST_auto
ConstexprSpecKind getConstexprSpecifier() const
static const TST TST_struct
Decl - This represents one declaration (or definition), e.g.
ASTContext & getASTContext() const LLVM_READONLY
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setImplicit(bool I=true)
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.
const DeclaratorChunk * getInnermostNonParenChunk() const
Return the innermost (closest to the declarator) chunk of this declarator that is not a parens chunk,...
void AddInnermostTypeInfo(const DeclaratorChunk &TI)
Add a new innermost chunk to this declarator.
bool isFunctionDeclarationContext() const
Return true if this declaration appears in a context where a function declarator would be a function ...
FunctionDefinitionKind getFunctionDefinitionKind() const
const ParsedAttributes & getAttributes() const
SourceLocation getIdentifierLoc() const
bool hasTrailingReturnType() const
Determine whether a trailing return type was written (at any level) within this declarator.
SourceLocation getEndLoc() const LLVM_READONLY
bool isExpressionContext() const
Determine whether this declaration appears in a context where an expression could appear.
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
void setInvalidType(bool Val=true)
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
const ParsedAttributesView & getDeclarationAttributes() const
SourceLocation getEllipsisLoc() const
DeclaratorContext getContext() const
SourceLocation getBeginLoc() const LLVM_READONLY
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
bool isFirstDeclarator() const
SourceLocation getCommaLoc() const
AttributePool & getAttributePool() const
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
ParsedType getTrailingReturnType() const
Get the trailing return type appearing (at any level) within this declarator.
bool isInvalidType() const
bool isExplicitObjectMemberFunction()
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
bool isFirstDeclarationOfMember()
Returns true if this declares a real member and not a friend.
bool isPrototypeContext() const
bool isStaticMember()
Returns true if this declares a static member.
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 setEllipsisLoc(SourceLocation EL)
const IdentifierInfo * getIdentifier() const
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
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.
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 withCallingConv(CallingConv cc) const
CallingConv getCC() const
bool getProducesResult() 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.
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined.
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.
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 hasMSPropertyAttr() const
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)
@ MaxAddressSpace
The maximum supported address space number.
static Qualifiers fromCVRMask(unsigned CVR)
void setUnaligned(bool flag)
std::string getAsString() const
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 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)
@ 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.
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.
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={})
bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type)
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.
QualType BuildCountAttributedArrayOrPointerType(QualType WrappedTy, Expr *CountExpr)
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.
bool isBeingDefined() const
Return true if this decl is currently being defined.
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
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
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)
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)
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.
@ 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.
enum clang::DeclaratorChunk::@221 Kind
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.
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.
Holds information about the various types of exception specification.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
unsigned AArch64SMEAttributes
SourceLocation EllipsisLoc
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.