45#include "llvm/ADT/ArrayRef.h"
46#include "llvm/ADT/STLForwardCompat.h"
47#include "llvm/ADT/StringExtras.h"
48#include "llvm/IR/DerivedTypes.h"
49#include "llvm/Support/ErrorHandling.h"
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();
103 attr.isArgIdent(0) ?
attr.getArgAsIdent(0)->getIdentifierInfo() :
nullptr;
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_MSABI: \
138 case ParsedAttr::AT_SysVABI: \
139 case ParsedAttr::AT_Pcs: \
140 case ParsedAttr::AT_IntelOclBicc: \
141 case ParsedAttr::AT_PreserveMost: \
142 case ParsedAttr::AT_PreserveAll: \
143 case ParsedAttr::AT_M68kRTD: \
144 case ParsedAttr::AT_PreserveNone: \
145 case ParsedAttr::AT_RISCVVectorCC: \
146 case ParsedAttr::AT_RISCVVLSCC
149#define FUNCTION_TYPE_ATTRS_CASELIST \
150 case ParsedAttr::AT_NSReturnsRetained: \
151 case ParsedAttr::AT_NoReturn: \
152 case ParsedAttr::AT_NonBlocking: \
153 case ParsedAttr::AT_NonAllocating: \
154 case ParsedAttr::AT_Blocking: \
155 case ParsedAttr::AT_Allocating: \
156 case ParsedAttr::AT_Regparm: \
157 case ParsedAttr::AT_CFIUncheckedCallee: \
158 case ParsedAttr::AT_CFISalt: \
159 case ParsedAttr::AT_CmseNSCall: \
160 case ParsedAttr::AT_ArmStreaming: \
161 case ParsedAttr::AT_ArmStreamingCompatible: \
162 case ParsedAttr::AT_ArmPreserves: \
163 case ParsedAttr::AT_ArmIn: \
164 case ParsedAttr::AT_ArmOut: \
165 case ParsedAttr::AT_ArmInOut: \
166 case ParsedAttr::AT_ArmAgnostic: \
167 case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: \
168 case ParsedAttr::AT_AnyX86NoCfCheck: \
169 CALLING_CONV_ATTRS_CASELIST
172#define MS_TYPE_ATTRS_CASELIST \
173 case ParsedAttr::AT_Ptr32: \
174 case ParsedAttr::AT_Ptr64: \
175 case ParsedAttr::AT_SPtr: \
176 case ParsedAttr::AT_UPtr
179#define NULLABILITY_TYPE_ATTRS_CASELIST \
180 case ParsedAttr::AT_TypeNonNull: \
181 case ParsedAttr::AT_TypeNullable: \
182 case ParsedAttr::AT_TypeNullableResult: \
183 case ParsedAttr::AT_TypeNullUnspecified
188 class TypeProcessingState {
212 using TypeAttrPair = std::pair<const AttributedType*, const Attr*>;
214 bool AttrsForTypesSorted =
true;
218 llvm::DenseMap<const MacroQualifiedType *, SourceLocation> LocsForMacros;
226 bool ParsedHLSLParamMod;
230 :
sema(
sema), declarator(declarator),
232 ParsedHLSLParamMod(
false) {}
234 Sema &getSema()
const {
242 bool isProcessingDeclSpec()
const {
246 unsigned getCurrentChunkIndex()
const {
250 void setCurrentChunkIndex(
unsigned idx) {
256 if (isProcessingDeclSpec())
257 return getMutableDeclSpec().getAttributes();
262 void saveDeclSpecAttrs() {
264 if (!savedAttrs.empty())
267 DeclSpec &spec = getMutableDeclSpec();
268 llvm::append_range(savedAttrs,
275 ignoredTypeAttrs.push_back(&
attr);
281 for (
auto *
Attr : ignoredTypeAttrs)
290 sema.Context.getAttributedType(A, ModifiedType, EquivType);
292 AttrsForTypesSorted =
false;
297 QualType getBTFTagAttributedType(
const BTFTypeTagAttr *BTFAttr,
299 return sema.Context.getBTFTagAttributedType(BTFAttr, WrappedType);
306 QualType T =
sema.ReplaceAutoType(TypeWithAuto, Replacement);
307 if (
auto *AttrTy = TypeWithAuto->
getAs<AttributedType>()) {
310 for (TypeAttrPair &A : AttrsForTypes) {
311 if (A.first == AttrTy)
314 AttrsForTypesSorted =
false;
320 const Attr *takeAttrForAttributedType(
const AttributedType *AT) {
321 if (!AttrsForTypesSorted) {
322 llvm::stable_sort(AttrsForTypes, llvm::less_first());
323 AttrsForTypesSorted =
true;
328 for (
auto It = llvm::partition_point(
330 [=](
const TypeAttrPair &A) {
return A.first < AT; });
331 It != AttrsForTypes.end() && It->first == AT; ++It) {
333 const Attr *Result = It->second;
334 It->second =
nullptr;
339 llvm_unreachable(
"no Attr* for AttributedType*");
344 auto FoundLoc = LocsForMacros.find(MQT);
345 assert(FoundLoc != LocsForMacros.end() &&
346 "Unable to find macro expansion location for MacroQualifedType");
347 return FoundLoc->second;
352 LocsForMacros[MQT] = Loc;
355 void setParsedNoDeref(
bool parsed) { parsedNoDeref = parsed; }
357 bool didParseNoDeref()
const {
return parsedNoDeref; }
359 void setParsedHLSLParamMod(
bool Parsed) { ParsedHLSLParamMod = Parsed; }
361 bool didParseHLSLParamMod()
const {
return ParsedHLSLParamMod; }
363 ~TypeProcessingState() {
364 if (savedAttrs.empty())
367 getMutableDeclSpec().getAttributes().clearListOnly();
369 getMutableDeclSpec().getAttributes().addAtEnd(AL);
373 DeclSpec &getMutableDeclSpec()
const {
415 if (
attr.getKind() == ParsedAttr::AT_ObjCGC)
417 assert(
attr.getKind() == ParsedAttr::AT_ObjCOwnership);
432 bool onlyBlockPointers) {
438 for (; i != 0; --i) {
440 switch (fnChunk.
Kind) {
456 for (--i; i != 0; --i) {
458 switch (ptrChunk.
Kind) {
468 if (onlyBlockPointers)
477 llvm_unreachable(
"bad declarator chunk kind");
483 llvm_unreachable(
"bad declarator chunk kind");
500 Declarator &declarator = state.getDeclarator();
503 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
505 switch (chunk.
Kind) {
511 if (state.isProcessingDeclSpec() &&
512 attr.getKind() == ParsedAttr::AT_ObjCOwnership)
515 if (!destChunk) destChunk = &chunk;
528 if (state.isProcessingDeclSpec() &&
529 attr.getKind() == ParsedAttr::AT_ObjCOwnership) {
556 Declarator &declarator = state.getDeclarator();
560 unsigned innermost = -1U;
561 bool considerDeclSpec =
true;
564 switch (chunk.
Kind) {
578 considerDeclSpec =
false;
586 if (considerDeclSpec) {
591 state.saveDeclSpecAttrs();
600 if (innermost != -1U) {
608 state.addIgnoredTypeAttr(
attr);
617 Declarator &declarator = state.getDeclarator();
621 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
623 switch (chunk.
Kind) {
650 Declarator &declarator = state.getDeclarator();
670 state.saveDeclSpecAttrs();
674 state,
attr, state.getCurrentAttributes(), declSpecType, CFT))
679 state.addIgnoredTypeAttr(
attr);
690 Declarator &declarator = state.getDeclarator();
700 state.addIgnoredTypeAttr(
attr);
725 if (
attr.isStandardAttributeSyntax() ||
attr.isRegularKeywordAttribute())
728 switch (
attr.getKind()) {
745 case ParsedAttr::AT_ObjCKindOf:
758 Declarator &declarator = state.getDeclarator();
804 {}, loc, loc, declarator));
819 typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc;
824 if (!(RemoveTQs & Qual.first))
828 if (TypeQuals & Qual.first)
829 S.
Diag(Qual.second, DiagID)
834 TypeQuals &= ~Qual.first;
848 if (AL.isInvalid() || !AL.isTypeAttr())
851 diag::warn_block_literal_attributes_on_omitted_return_type)
853 ToBeRemoved.push_back(&AL);
863 diag::warn_block_literal_qualifiers_on_omitted_return_type);
869static OpenCLAccessAttr::Spelling
872 if (AL.getKind() == ParsedAttr::AT_OpenCLAccess)
873 return static_cast<OpenCLAccessAttr::Spelling
>(AL.getSemanticSpelling());
874 return OpenCLAccessAttr::Keyword_read_only;
877static UnaryTransformType::UTTKind
880#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait) \
882 return UnaryTransformType::Enum;
883#include "clang/Basic/TransformTypeTraits.def"
885 llvm_unreachable(
"attempted to parse a non-unary transform builtin");
899 Sema &S = state.getSema();
900 Declarator &declarator = state.getDeclarator();
911 Result = Context.VoidTy;
915 Result = Context.CharTy;
917 Result = Context.SignedCharTy;
920 "Unknown TSS value");
921 Result = Context.UnsignedCharTy;
926 Result = Context.WCharTy;
930 Context.getPrintingPolicy());
931 Result = Context.getSignedWCharType();
934 "Unknown TSS value");
937 Context.getPrintingPolicy());
938 Result = Context.getUnsignedWCharType();
943 "Unknown TSS value");
944 Result = Context.Char8Ty;
948 "Unknown TSS value");
949 Result = Context.Char16Ty;
953 "Unknown TSS value");
954 Result = Context.Char32Ty;
964 Result = Context.getAutoDeductType();
968 Context.DependentTy)) {
969 Result = Context.DependentTy;
981 S.
Diag(DeclLoc, diag::warn_missing_type_specifier)
990 S.
Diag(DeclLoc, diag::err_missing_type_specifier)
999 S.
Diag(DeclLoc, diag::err_missing_actual_pipe_type)
1004 "implicit int is disabled?");
1005 S.
Diag(DeclLoc, diag::ext_missing_type_specifier)
1016 Result = Context.IntTy;
1019 Result = Context.ShortTy;
1022 Result = Context.LongTy;
1025 Result = Context.LongLongTy;
1032 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1041 Result = Context.UnsignedIntTy;
1044 Result = Context.UnsignedShortTy;
1047 Result = Context.UnsignedLongTy;
1050 Result = Context.UnsignedLongLongTy;
1057 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1072 if (Result.isNull()) {
1073 Result = Context.IntTy;
1081 Result = Context.ShortAccumTy;
1084 Result = Context.AccumTy;
1087 Result = Context.LongAccumTy;
1090 llvm_unreachable(
"Unable to specify long long as _Accum width");
1094 Result = Context.getCorrespondingUnsignedType(Result);
1097 Result = Context.getCorrespondingSaturatedType(Result);
1104 Result = Context.ShortFractTy;
1107 Result = Context.FractTy;
1110 Result = Context.LongFractTy;
1113 llvm_unreachable(
"Unable to specify long long as _Fract width");
1117 Result = Context.getCorrespondingUnsignedType(Result);
1120 Result = Context.getCorrespondingSaturatedType(Result);
1130 Result = Context.UnsignedInt128Ty;
1132 Result = Context.Int128Ty;
1142 Result = Context.Float16Ty;
1150 Result = Context.BFloat16Ty;
1155 Result = Context.LongDoubleTy;
1157 Result = Context.DoubleTy;
1162 << (S.
getLangOpts().getOpenCLCompatibleVersion() == 300
1163 ?
"cl_khr_fp64 and __opencl_c_fp64"
1174 Result = Context.Float128Ty;
1181 Result = Context.Ibm128Ty;
1184 Result = Context.BoolTy;
1190 Result = Context.IntTy;
1201 Result = Context.IntTy;
1212 "No qualifiers on tag names!");
1225 "Can't handle qualifiers on typedef names yet!");
1227 if (Result.isNull()) {
1238 assert(!Result.isNull() &&
"Didn't get a type for typeof?");
1239 if (!Result->isDependentType())
1240 if (
const auto *TT = Result->getAs<TagType>())
1243 Result = Context.getTypeOfType(
1251 assert(E &&
"Didn't get an expression for typeof?");
1257 if (Result.isNull()) {
1258 Result = Context.IntTy;
1265 assert(E &&
"Didn't get an expression for decltype?");
1268 if (Result.isNull()) {
1269 Result = Context.IntTy;
1276 assert(E &&
"Didn't get an expression for pack indexing");
1280 if (Result.isNull()) {
1282 Result = Context.IntTy;
1287#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
1288#include "clang/Basic/TransformTypeTraits.def"
1290 assert(!Result.isNull() &&
"Didn't get a type for the transformation?");
1294 if (Result.isNull()) {
1295 Result = Context.IntTy;
1310 TypeConstraintConcept =
1316 TemplateId->NumArgs);
1318 for (
const auto &ArgLoc : TemplateArgsInfo.
arguments())
1319 TemplateArgs.push_back(ArgLoc.getArgument());
1326 TypeConstraintConcept, TemplateArgs);
1335 Result = Context.UnknownAnyTy;
1340 assert(!Result.isNull() &&
"Didn't get a type for _Atomic?");
1342 if (Result.isNull()) {
1343 Result = Context.IntTy;
1348#define GENERIC_IMAGE_TYPE(ImgType, Id) \
1349 case DeclSpec::TST_##ImgType##_t: \
1350 switch (getImageAccess(DS.getAttributes())) { \
1351 case OpenCLAccessAttr::Keyword_write_only: \
1352 Result = Context.Id##WOTy; \
1354 case OpenCLAccessAttr::Keyword_read_write: \
1355 Result = Context.Id##RWTy; \
1357 case OpenCLAccessAttr::Keyword_read_only: \
1358 Result = Context.Id##ROTy; \
1360 case OpenCLAccessAttr::SpellingNotCalculated: \
1361 llvm_unreachable("Spelling not yet calculated"); \
1364#include "clang/Basic/OpenCLImageTypes.def"
1366#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
1367 case DeclSpec::TST_##Name: \
1368 Result = Context.SingletonId; \
1370#include "clang/Basic/HLSLIntangibleTypes.def"
1373 Result = Context.IntTy;
1381 if (Result->containsErrors())
1386 bool IsOpenCLC30Compatible =
1395 if ((Result->isImageType() || Result->isSamplerT()) &&
1396 (IsOpenCLC30Compatible &&
1399 << 0 << Result <<
"__opencl_c_images";
1401 }
else if (Result->isOCLImage3dWOType() &&
1406 << (IsOpenCLC30Compatible
1407 ?
"cl_khr_3d_image_writes and __opencl_c_3d_image_writes"
1408 :
"cl_khr_3d_image_writes");
1420 Context.getPrintingPolicy());
1426 Result = Context.getComplexType(Result);
1428 unsigned typeSize =
static_cast<unsigned>(Context.getTypeSize(Result));
1429 assert(typeSize > 0 &&
"type size for vector must be greater than 0 bits");
1435 Result = Context.getVectorType(Result, 128/typeSize, VecKind);
1460 if (AL.slidesFromDeclToDeclSpecLegacyBehavior()) {
1471 if (AL.isStandardAttributeSyntax() && AL.isClangScope() &&
1472 !(AL.getKind() == ParsedAttr::AT_MatrixType &&
1474 S.
Diag(AL.getLoc(), diag::warn_type_attribute_deprecated_on_decl)
1502 if (Result->isFunctionType()) {
1503 unsigned DiagId = diag::warn_typecheck_function_qualifiers_ignored;
1505 DiagId = diag::ext_typecheck_function_qualifiers_unspecified;
1521 if (TypeQuals && Result->isReferenceType()) {
1523 S, DS, TypeQuals, Result,
1525 diag::warn_typecheck_reference_qualifiers);
1532 && TypeQuals & Result.getCVRQualifiers()) {
1559 assert(!Result.isNull() &&
"This function should not return a null type");
1571 if (
T->isDependentType())
1574 const auto *AT = dyn_cast<AutoType>(
T);
1575 return AT && AT->isGNUAutoType();
1584 if (
T->isReferenceType()) {
1592 unsigned DiagID = 0;
1606 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
1612 DiagID = diag::err_typecheck_invalid_restrict_not_pointer;
1618 Diag(Loc, DiagID) << EltTy;
1621 if (
T->isArrayType())
1623 ? diag::warn_c23_compat_restrict_on_array_of_pointers
1624 : diag::ext_restrict_on_array_of_pointers_c23);
1628 return Context.getQualifiedType(
T, Qs);
1632 unsigned CVRAU,
const DeclSpec *DS) {
1637 if (
T->isReferenceType())
1666 Split.Quals.addCVRQualifiers(CVR);
1684 if (!
type->isObjCLifetimeType() ||
1694 if (
type.isConstQualified()) {
1700 }
else if (
type->isObjCARCImplicitlyUnretainedType()) {
1718 diag::err_arc_indirect_no_ownership,
type, isReference));
1720 S.
Diag(loc, diag::err_arc_indirect_no_ownership) <<
type << isReference;
1724 assert(implicitLifetime &&
"didn't infer any lifetime!");
1765enum QualifiedFunctionKind { QFK_BlockPointer, QFK_Pointer, QFK_Reference };
1771 QualifiedFunctionKind QFK) {
1778 S.
Diag(Loc, diag::err_compound_qualified_function_type)
1779 << QFK << isa<FunctionType>(
T.IgnoreParens()) <<
T
1790 Diag(Loc, diag::err_qualified_function_typeid)
1807 if (
T->isReferenceType()) {
1809 Diag(Loc, diag::err_illegal_decl_pointer_to_reference)
1817 Diag(Loc, diag::err_opencl_function_pointer) << 0;
1822 Diag(Loc, diag::err_hlsl_pointers_unsupported) << 0;
1829 if (
T->isObjCObjectType())
1830 return Context.getObjCObjectPointerType(
T);
1842 if (
T.isWebAssemblyReferenceType()) {
1843 Diag(Loc, diag::err_wasm_reference_pr) << 0;
1848 if (
T->getUnqualifiedDesugaredType()->isWebAssemblyTableType()) {
1849 Diag(Loc, diag::err_wasm_table_pr) << 0;
1862 "Unresolved overloaded function type");
1889 if (
T->isVoidType()) {
1890 Diag(Loc, diag::err_reference_to_void);
1895 Diag(Loc, diag::err_hlsl_pointers_unsupported) << 1;
1905 Diag(Loc, diag::err_opencl_function_pointer) << 1;
1918 T.isWebAssemblyReferenceType()) {
1919 Diag(Loc, diag::err_wasm_reference_pr) << 1;
1922 if (
T->isWebAssemblyTableType()) {
1923 Diag(Loc, diag::err_wasm_table_pr) << 1;
1929 return Context.getLValueReferenceType(
T, SpelledAsLValue);
1930 return Context.getRValueReferenceType(
T);
1938 return Context.getWritePipeType(
T);
1944 return Context.getDependentBitIntType(IsUnsigned, BitWidth);
1946 llvm::APSInt Bits(32);
1953 size_t NumBits = Bits.getZExtValue();
1954 if (!IsUnsigned && NumBits < 2) {
1955 Diag(Loc, diag::err_bit_int_bad_size) << 0;
1959 if (IsUnsigned && NumBits < 1) {
1960 Diag(Loc, diag::err_bit_int_bad_size) << 1;
1966 Diag(Loc, diag::err_bit_int_max_size)
1971 return Context.getBitIntType(IsUnsigned, NumBits);
1980 llvm::APSInt &SizeVal,
unsigned VLADiag,
2005 VLADiagnoser(
unsigned VLADiag,
bool VLAIsError)
2006 : VLADiag(VLADiag), VLAIsError(VLAIsError) {}
2010 return S.
Diag(Loc, diag::err_array_size_non_int) <<
T;
2015 IsVLA = !VLAIsError;
2016 return S.
Diag(Loc, VLADiag);
2021 return S.
Diag(Loc, diag::ext_vla_folded_to_constant);
2023 } Diagnoser(VLADiag, VLAIsError);
2027 if (Diagnoser.IsVLA)
2033 EltTy =
Context.getBaseElementType(EltTy);
2041 if (Size.isMultipleOf(Alignment))
2044 Diag(Loc, diag::err_array_element_alignment)
2045 << EltTy << Size.getQuantity() << Alignment.
getQuantity();
2050 Expr *ArraySize,
unsigned Quals,
2066 if (
T->isReferenceType()) {
2067 Diag(Loc, diag::err_illegal_decl_array_of_references)
2072 if (
T->isVoidType() ||
T->isIncompleteArrayType()) {
2073 Diag(Loc, diag::err_array_incomplete_or_sizeless_type) << 0 <<
T;
2078 diag::err_array_of_abstract_type))
2083 if (
Context.getTargetInfo().getCXXABI().isMicrosoft())
2085 if (!MPTy->getQualifier().isDependent())
2091 if (!
T.isWebAssemblyReferenceType() &&
2093 diag::err_array_incomplete_or_sizeless_type))
2098 if (
Context.getTargetInfo().getTriple().isWasm() &&
T->isArrayType()) {
2099 const auto *ATy = dyn_cast<ArrayType>(
T);
2100 if (ATy && ATy->getElementType().isWebAssemblyReferenceType()) {
2101 Diag(Loc, diag::err_wasm_reftype_multidimensional_array);
2106 if (
T->isSizelessType() && !
T.isWebAssemblyReferenceType()) {
2107 Diag(Loc, diag::err_array_incomplete_or_sizeless_type) << 1 <<
T;
2111 if (
T->isFunctionType()) {
2112 Diag(Loc, diag::err_illegal_decl_array_of_functions)
2117 if (
const auto *RD =
T->getAsRecordDecl()) {
2120 if (RD->hasFlexibleArrayMember())
2121 Diag(Loc, diag::ext_flexible_array_in_array) <<
T;
2122 }
else if (
T->isObjCObjectType()) {
2123 Diag(Loc, diag::err_objc_array_of_interfaces) <<
T;
2134 ArraySize =
Result.get();
2138 if (ArraySize && !ArraySize->
isPRValue()) {
2143 ArraySize =
Result.get();
2166 if (
const auto *CondExpr = dyn_cast_if_present<ConditionalOperator>(
2168 std::optional<llvm::APSInt> LHS =
2169 CondExpr->getLHS()->getIntegerConstantExpr(
Context);
2170 std::optional<llvm::APSInt> RHS =
2171 CondExpr->getRHS()->getIntegerConstantExpr(
Context);
2172 return LHS && RHS && LHS->isNegative() != RHS->isNegative();
2182 VLADiag = diag::err_opencl_vla;
2185 VLADiag = diag::warn_vla_used;
2188 VLADiag = diag::err_vla_in_sfinae;
2191 VLADiag = diag::err_openmp_vla_in_task_untied;
2196 ? diag::ext_vla_cxx_in_gnu_mode_static_assert
2197 : diag::ext_vla_cxx_static_assert;
2199 VLADiag =
getLangOpts().GNUMode ? diag::ext_vla_cxx_in_gnu_mode
2200 : diag::ext_vla_cxx;
2203 VLADiag = diag::ext_vla;
2207 llvm::APSInt ConstVal(
Context.getTypeSize(
Context.getSizeType()));
2214 T =
Context.getVariableArrayType(
T,
nullptr, ASM, Quals);
2216 T =
Context.getIncompleteArrayType(
T, ASM, Quals);
2219 T =
Context.getDependentSizedArrayType(
T, ArraySize, ASM, Quals);
2230 T =
Context.getVariableArrayType(
T, ArraySize, ASM, Quals);
2231 }
else if (!
T->isDependentType() && !
T->isIncompleteType() &&
2232 !
T->isConstantSizeType()) {
2239 T =
Context.getVariableArrayType(
T, ArraySize, ASM, Quals);
2244 if (ConstVal.isSigned() && ConstVal.isNegative()) {
2251 diag::err_typecheck_negative_array_size)
2255 if (ConstVal == 0 && !
T.isWebAssemblyReferenceType()) {
2260 : diag::ext_typecheck_zero_array_size)
2265 unsigned ActiveSizeBits =
2266 (!
T->isDependentType() && !
T->isVariablyModifiedType() &&
2267 !
T->isIncompleteType() && !
T->isUndeducedType())
2269 : ConstVal.getActiveBits();
2272 <<
toString(ConstVal, 10, ConstVal.isSigned(),
2279 T =
Context.getConstantArrayType(
T, ConstVal, ArraySize, ASM, Quals);
2283 if (
T->isVariableArrayType()) {
2284 if (!
Context.getTargetInfo().isVLASupported()) {
2288 IsCUDADevice ? diag::err_cuda_vla : diag::err_vla_unsupported)
2289 << (IsCUDADevice ? llvm::to_underlying(
CUDA().CurrentTarget()) : 0);
2293 FSI->setHasVLA(Loc);
2301 : diag::ext_c99_array_usage)
2312 Diag(Loc, diag::err_opencl_invalid_type_array) << ArrType;
2322 bool ForMatrixType =
false) {
2325 if (!llvm::isPowerOf2_32(NumBits))
2326 return S.
Diag(AttrLoc, diag::err_attribute_invalid_bitint_vector_type)
2340 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << CurType;
2349 return Context.getDependentVectorType(CurType, SizeExpr, AttrLoc,
2352 std::optional<llvm::APSInt> VecSize =
2355 Diag(AttrLoc, diag::err_attribute_argument_type)
2362 return Context.getDependentVectorType(CurType, SizeExpr, AttrLoc,
2366 if (!VecSize->isIntN(61)) {
2368 Diag(AttrLoc, diag::err_attribute_size_too_large)
2372 uint64_t VectorSizeBits = VecSize->getZExtValue() * 8;
2373 unsigned TypeSize =
static_cast<unsigned>(
Context.getTypeSize(CurType));
2375 if (VectorSizeBits == 0) {
2376 Diag(AttrLoc, diag::err_attribute_zero_size)
2381 if (!TypeSize || VectorSizeBits % TypeSize) {
2382 Diag(AttrLoc, diag::err_attribute_invalid_size)
2387 if (VectorSizeBits / TypeSize > std::numeric_limits<uint32_t>::max()) {
2388 Diag(AttrLoc, diag::err_attribute_size_too_large)
2393 return Context.getVectorType(CurType, VectorSizeBits / TypeSize,
2409 if ((!
T->isDependentType() && !
T->isIntegerType() &&
2410 !
T->isRealFloatingType()) ||
2411 (IsNoBoolVecLang &&
T->isBooleanType())) {
2412 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) <<
T;
2421 std::optional<llvm::APSInt> vecSize =
2424 Diag(AttrLoc, diag::err_attribute_argument_type)
2430 if (!vecSize->isIntN(32)) {
2431 Diag(AttrLoc, diag::err_attribute_size_too_large)
2437 unsigned vectorSize =
static_cast<unsigned>(vecSize->getZExtValue());
2439 if (vectorSize == 0) {
2440 Diag(AttrLoc, diag::err_attribute_zero_size)
2445 return Context.getExtVectorType(
T, vectorSize);
2448 return Context.getDependentSizedExtVectorType(
T, ArraySize, AttrLoc);
2453 assert(
Context.getLangOpts().MatrixTypes &&
2454 "Should never build a matrix type when it is disabled");
2459 Diag(AttrLoc, diag::err_attribute_invalid_matrix_type) << ElementTy;
2470 return Context.getDependentSizedMatrixType(ElementTy, NumRows, NumCols,
2473 std::optional<llvm::APSInt> ValueRows =
2475 std::optional<llvm::APSInt> ValueColumns =
2482 if (!ValueRows && !ValueColumns) {
2483 Diag(AttrLoc, diag::err_attribute_argument_type)
2491 Diag(AttrLoc, diag::err_attribute_argument_type)
2497 if (!ValueColumns) {
2498 Diag(AttrLoc, diag::err_attribute_argument_type)
2504 unsigned MatrixRows =
static_cast<unsigned>(ValueRows->getZExtValue());
2505 unsigned MatrixColumns =
static_cast<unsigned>(ValueColumns->getZExtValue());
2506 if (MatrixRows == 0 && MatrixColumns == 0) {
2507 Diag(AttrLoc, diag::err_attribute_zero_size)
2508 <<
"matrix" << RowRange << ColRange;
2511 if (MatrixRows == 0) {
2512 Diag(AttrLoc, diag::err_attribute_zero_size) <<
"matrix" << RowRange;
2515 if (MatrixColumns == 0) {
2516 Diag(AttrLoc, diag::err_attribute_zero_size) <<
"matrix" << ColRange;
2519 if (MatrixRows >
Context.getLangOpts().MaxMatrixDimension &&
2520 MatrixColumns >
Context.getLangOpts().MaxMatrixDimension) {
2521 Diag(AttrLoc, diag::err_attribute_size_too_large)
2522 << RowRange << ColRange <<
"matrix row and column";
2525 if (MatrixRows >
Context.getLangOpts().MaxMatrixDimension) {
2526 Diag(AttrLoc, diag::err_attribute_size_too_large)
2527 << RowRange <<
"matrix row";
2530 if (MatrixColumns >
Context.getLangOpts().MaxMatrixDimension) {
2531 Diag(AttrLoc, diag::err_attribute_size_too_large)
2532 << ColRange <<
"matrix column";
2535 return Context.getConstantMatrixType(ElementTy, MatrixRows, MatrixColumns);
2539 if ((
T->isArrayType() && !
getLangOpts().allowArrayReturnTypes()) ||
2540 T->isFunctionType()) {
2541 Diag(Loc, diag::err_func_returning_array_function)
2542 <<
T->isFunctionType() <<
T;
2547 if (
T->isHalfType() && !
getLangOpts().NativeHalfArgsAndReturns &&
2548 !
Context.getTargetInfo().allowHalfArgsAndReturns()) {
2549 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 <<
2556 if (
T->isObjCObjectType()) {
2557 Diag(Loc, diag::err_object_cannot_be_passed_returned_by_value)
2563 if (
T.getPointerAuth()) {
2564 Diag(Loc, diag::err_ptrauth_qualifier_invalid) <<
T << 0;
2568 if (
T.hasNonTrivialToPrimitiveDestructCUnion() ||
2569 T.hasNonTrivialToPrimitiveCopyCUnion())
2576 Diag(Loc, diag::warn_deprecated_volatile_return) <<
T;
2591 bool emittedError =
false;
2593 enum class RequiredCC { OnlySwift, SwiftOrSwiftAsync };
2594 auto checkCompatible = [&](
unsigned paramIndex, RequiredCC required) {
2596 (required == RequiredCC::OnlySwift)
2599 if (isCompatible || emittedError)
2601 S.
Diag(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall)
2603 << (required == RequiredCC::OnlySwift);
2604 emittedError =
true;
2606 for (
size_t paramIndex = 0, numParams = paramTypes.size();
2607 paramIndex != numParams; ++paramIndex) {
2618 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
2619 if (paramIndex != 0 &&
2622 S.
Diag(getParamLoc(paramIndex),
2623 diag::err_swift_indirect_result_not_first);
2628 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
2637 checkCompatible(paramIndex, RequiredCC::OnlySwift);
2638 if (paramIndex == 0 ||
2641 S.
Diag(getParamLoc(paramIndex),
2642 diag::err_swift_error_result_not_after_swift_context);
2646 llvm_unreachable(
"bad ABI kind");
2658 for (
unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) {
2660 QualType ParamType =
Context.getAdjustedParameterType(ParamTypes[Idx]);
2662 Diag(Loc, diag::err_param_with_void_type);
2665 !
Context.getTargetInfo().allowHalfArgsAndReturns()) {
2667 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<
2671 Diag(Loc, diag::err_wasm_table_as_function_parameter);
2675 Diag(Loc, diag::err_ptrauth_qualifier_invalid) <<
T << 1;
2682 Diag(Loc, diag::warn_deprecated_volatile_param) << ParamType;
2684 ParamTypes[Idx] = ParamType;
2689 [=](
unsigned i) {
return Loc; });
2700 return Context.getFunctionType(
T, ParamTypes, EPI);
2715 D <<
"member pointer";
2723 Diag(Loc, diag::err_distant_exception_spec);
2729 if (
T->isReferenceType()) {
2730 Diag(Loc, diag::err_illegal_decl_mempointer_to_reference)
2735 if (
T->isVoidType()) {
2736 Diag(Loc, diag::err_illegal_decl_mempointer_to_void)
2744 Diag(Loc, diag::err_opencl_function_pointer) << 0;
2749 Diag(Loc, diag::err_hlsl_pointers_unsupported) << 0;
2758 if (
T->isFunctionType())
2767 if (!
T->isFunctionType()) {
2768 Diag(Loc, diag::err_nonfunction_block_type);
2778 return Context.getBlockPointerType(
T);
2784 if (TInfo) *TInfo =
nullptr;
2789 if (
const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
2790 QT = LIT->getType();
2791 DI = LIT->getTypeSourceInfo();
2794 if (TInfo) *TInfo = DI;
2800 unsigned chunkIndex);
2807 Sema &S = state.getSema();
2808 Declarator &declarator = state.getDeclarator();
2814 unsigned outermostPointerIndex = 0;
2816 unsigned numPointers = 0;
2818 unsigned chunkIndex = i;
2820 switch (chunk.
Kind) {
2830 outermostPointerIndex = chunkIndex;
2838 if (numPointers != 1)
return;
2840 outermostPointerIndex = chunkIndex;
2858 if (numPointers == 1) {
2876 }
else if (numPointers == 2) {
2889 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership)
2893 outermostPointerIndex);
2915 }
const QualKinds[5] = {
2929 for (
auto &E : QualKinds) {
2930 if (Quals & E.Mask) {
2931 if (!QualStr.empty()) QualStr +=
' ';
2948 << QualStr <<
NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];
2954 unsigned FunctionChunkIndex) {
2964 for (
unsigned OuterChunkIndex = FunctionChunkIndex + 1,
2966 OuterChunkIndex != End; ++OuterChunkIndex) {
2968 switch (OuterChunk.
Kind) {
2975 diag::warn_qual_return_type,
3001 llvm_unreachable(
"unknown declarator chunk kind");
3022static std::pair<QualType, TypeSourceInfo *>
3026 Sema &S = state.getSema();
3030 const unsigned AutoParameterPosition = Info.
TemplateParams.size();
3044 TemplateParameterDepth, AutoParameterPosition,
3047 IsParameterPack,
Auto->isConstrained());
3052 if (
Auto->isConstrained()) {
3059 for (
unsigned Idx = 0; Idx < AutoLoc.
getNumArgs(); ++Idx) {
3117 QualType NewT = state.ReplaceAutoType(
T, Replacement);
3121 return {NewT, NewTSI};
3130 Sema &SemaRef = state.getSema();
3133 ReturnTypeInfo =
nullptr;
3136 TagDecl *OwnedTagDecl =
nullptr;
3186 DeducedType *Deduced =
T->getContainedDeducedType();
3187 bool DeducedIsTrailingReturnType =
false;
3190 Deduced =
T.isNull() ?
nullptr :
T->getContainedDeducedType();
3191 DeducedIsTrailingReturnType =
true;
3196 AutoType *
Auto = dyn_cast<AutoType>(Deduced);
3201 bool IsCXXAutoType =
3203 bool IsDeducedReturnType =
false;
3244 assert(Info &&
"No LambdaScopeInfo on the stack!");
3250 if (!DeducedIsTrailingReturnType)
3263 llvm_unreachable(
"unhandled tag kind");
3265 Error = Cxx ? 1 : 2;
3268 Error = Cxx ? 3 : 4;
3313 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3315 IsDeducedReturnType =
true;
3318 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3320 IsDeducedReturnType =
true;
3325 if (SemaRef.
getLangOpts().CPlusPlus23 && IsCXXAutoType &&
3326 !
Auto->isDecltypeAuto())
3359 (!SemaRef.
getLangOpts().CPlusPlus11 || !IsCXXAutoType))
3369 switch (
Auto->getKeyword()) {
3376 "unknown auto type");
3380 auto *DTST = dyn_cast<DeducedTemplateSpecializationType>(Deduced);
3383 SemaRef.
Diag(AutoRange.
getBegin(), diag::err_auto_not_allowed)
3385 <<
QualType(Deduced, 0) << AutoRange;
3396 unsigned DiagId = 0;
3398 DiagId = diag::warn_cxx11_compat_generic_lambda;
3399 else if (IsDeducedReturnType)
3400 DiagId = diag::warn_cxx11_compat_deduced_return_type;
3402 DiagId = diag::warn_cxx98_compat_auto_type_specifier;
3405 SemaRef.
Diag(AutoRange.
getBegin(), DiagId) << AutoRange;
3413 unsigned DiagID = 0;
3419 llvm_unreachable(
"parser should not have allowed this");
3435 DiagID = diag::err_type_defined_in_alias_template;
3447 DiagID = diag::err_type_defined_in_type_specifier;
3457 DiagID = diag::err_type_defined_in_param_type;
3463 DiagID = diag::err_type_defined_in_condition;
3474 assert(!
T.isNull() &&
"This function should not return a null type");
3483 assert(FTI.
isAmbiguous &&
"no direct-initializer / function ambiguity");
3513 FTI.
NumParams ? diag::warn_parens_disambiguated_as_function_declaration
3514 : diag::warn_empty_parens_are_function_decl)
3525 if (Comma.getFileID() != Name.
getFileID() ||
3533 Result.suppressDiagnostics();
3546 S.
Diag(B, diag::note_additional_parens_for_variable_declaration)
3561 S.
Diag(DeclType.
Loc, diag::note_empty_parens_default_ctor)
3569 S.
Diag(DeclType.
Loc, diag::note_empty_parens_zero_initialize)
3580 "do not have redundant top-level parentheses");
3589 bool CouldBeTemporaryObject =
3593 (
T->isRecordType() ||
T->isDependentType()) &&
3596 bool StartsWithDeclaratorId =
true;
3604 StartsWithDeclaratorId =
false;
3609 CouldBeTemporaryObject =
false;
3617 CouldBeTemporaryObject =
false;
3618 StartsWithDeclaratorId =
false;
3628 CouldBeTemporaryObject =
false;
3635 CouldBeTemporaryObject =
false;
3636 StartsWithDeclaratorId =
false;
3646 if (CouldBeTemporaryObject) {
3650 CouldBeTemporaryObject =
false;
3651 Result.suppressDiagnostics();
3656 if (!CouldBeTemporaryObject) {
3680 S.
Diag(
Paren.Loc, diag::warn_redundant_parens_around_declarator)
3686 S.
Diag(
Paren.Loc, diag::warn_parens_disambiguated_as_variable_declaration)
3688 auto *RD =
T->getAsCXXRecordDecl();
3689 if (!RD || !RD->hasDefinition() || RD->hasNonTrivialDestructor())
3690 S.
Diag(
Paren.Loc, diag::note_raii_guard_add_name)
3695 S.
Diag(D.
getBeginLoc(), diag::note_function_style_cast_add_parentheses)
3698 S.
Diag(
Paren.Loc, diag::note_remove_parens_for_variable_declaration)
3714 switch (AL.getKind()) {
3733 bool IsCXXInstanceMethod =
false;
3739 unsigned I = ChunkIndex;
3740 bool FoundNonParen =
false;
3741 while (I && !FoundNonParen) {
3744 FoundNonParen =
true;
3747 if (FoundNonParen) {
3750 IsCXXInstanceMethod =
3755 IsCXXInstanceMethod =
3763 IsCXXInstanceMethod =
3771 IsCXXInstanceMethod);
3779 if (Triple.isSPIRV() && Triple.getVendor() != llvm::Triple::AMD) {
3781 if (AL.getKind() == ParsedAttr::AT_CUDAGlobal) {
3788 for (
const ParsedAttr &AL : llvm::concat<ParsedAttr>(
3790 if (AL.getKind() == ParsedAttr::AT_DeviceKernel) {
3801 enum class SimplePointerKind {
3810 switch (nullability) {
3812 if (!Ident__Nonnull)
3813 Ident__Nonnull =
PP.getIdentifierInfo(
"_Nonnull");
3814 return Ident__Nonnull;
3817 if (!Ident__Nullable)
3818 Ident__Nullable =
PP.getIdentifierInfo(
"_Nullable");
3819 return Ident__Nullable;
3822 if (!Ident__Nullable_result)
3823 Ident__Nullable_result =
PP.getIdentifierInfo(
"_Nullable_result");
3824 return Ident__Nullable_result;
3827 if (!Ident__Null_unspecified)
3828 Ident__Null_unspecified =
PP.getIdentifierInfo(
"_Null_unspecified");
3829 return Ident__Null_unspecified;
3831 llvm_unreachable(
"Unknown nullability kind.");
3838 if (AL.getKind() == ParsedAttr::AT_TypeNonNull ||
3839 AL.getKind() == ParsedAttr::AT_TypeNullable ||
3840 AL.getKind() == ParsedAttr::AT_TypeNullableResult ||
3841 AL.getKind() == ParsedAttr::AT_TypeNullUnspecified)
3850 enum class PointerDeclaratorKind {
3858 MaybePointerToCFRef,
3862 NSErrorPointerPointer,
3868 enum class PointerWrappingDeclaratorKind {
3882static PointerDeclaratorKind
3884 PointerWrappingDeclaratorKind &wrappingKind) {
3885 unsigned numNormalPointers = 0;
3888 if (
type->isDependentType())
3889 return PointerDeclaratorKind::NonPointer;
3894 switch (chunk.
Kind) {
3896 if (numNormalPointers == 0)
3897 wrappingKind = PointerWrappingDeclaratorKind::Array;
3906 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3907 : PointerDeclaratorKind::SingleLevelPointer;
3913 if (numNormalPointers == 0)
3914 wrappingKind = PointerWrappingDeclaratorKind::Reference;
3918 ++numNormalPointers;
3919 if (numNormalPointers > 2)
3920 return PointerDeclaratorKind::MultiLevelPointer;
3926 unsigned numTypeSpecifierPointers = 0;
3930 ++numNormalPointers;
3932 if (numNormalPointers > 2)
3933 return PointerDeclaratorKind::MultiLevelPointer;
3935 type = ptrType->getPointeeType();
3936 ++numTypeSpecifierPointers;
3942 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3943 : PointerDeclaratorKind::SingleLevelPointer;
3948 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3949 : PointerDeclaratorKind::SingleLevelPointer;
3954 ++numNormalPointers;
3955 ++numTypeSpecifierPointers;
3958 if (
auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) {
3960 numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3961 return PointerDeclaratorKind::NSErrorPointerPointer;
3970 if (objcClass->getInterface()->getIdentifier() ==
3972 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2)
3973 return PointerDeclaratorKind::NSErrorPointerPointer;
3980 if (numNormalPointers == 0)
3981 return PointerDeclaratorKind::NonPointer;
3985 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2 &&
3987 return PointerDeclaratorKind::CFErrorRefPointer;
3995 switch (numNormalPointers) {
3997 return PointerDeclaratorKind::NonPointer;
4000 return PointerDeclaratorKind::SingleLevelPointer;
4003 return PointerDeclaratorKind::MaybePointerToCFRef;
4006 return PointerDeclaratorKind::MultiLevelPointer;
4015 if (ctx->isFunctionOrMethod())
4018 if (ctx->isFileContext())
4029 bool invalid =
false;
4031 if (invalid || !sloc.
isFile())
4049template <
typename DiagBuilderT>
4058 if (!FixItLoc.
isValid() || FixItLoc == PointerLoc)
4067 InsertionTextBuf +=
" ";
4068 StringRef InsertionText = InsertionTextBuf.str();
4071 InsertionText = InsertionText.drop_back();
4072 }
else if (NextChar[-1] ==
'[') {
4073 if (NextChar[0] ==
']')
4074 InsertionText = InsertionText.drop_back().drop_front();
4076 InsertionText = InsertionText.drop_front();
4079 InsertionText = InsertionText.drop_back().drop_front();
4086 SimplePointerKind PointerKind,
4091 if (PointerKind == SimplePointerKind::Array) {
4092 S.
Diag(PointerLoc, diag::warn_nullability_missing_array);
4094 S.
Diag(PointerLoc, diag::warn_nullability_missing)
4095 <<
static_cast<unsigned>(PointerKind);
4098 auto FixItLoc = PointerEndLoc.
isValid() ? PointerEndLoc : PointerLoc;
4099 if (FixItLoc.isMacroID())
4103 auto Diag = S.
Diag(FixItLoc, diag::note_nullability_fix_it);
4134 if (pointerKind == SimplePointerKind::Array)
4135 diagKind = diag::warn_nullability_missing_array;
4137 diagKind = diag::warn_nullability_missing;
4143 fileNullability.
PointerKind =
static_cast<unsigned>(pointerKind);
4175 auto kind =
static_cast<SimplePointerKind
>(fileNullability.
PointerKind);
4190 unsigned i = endIndex;
4218template<
typename AttrT>
4221 return ::new (Ctx) AttrT(Ctx, AL);
4239 llvm_unreachable(
"unknown NullabilityKind");
4250 if (ASOld != ASNew) {
4251 S.
Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
4256 diag::warn_attribute_address_multiple_identical_qualifiers);
4265 return T->canHaveNullability(
false) &&
4271 T->getCanonicalTypeInternal());
4281 Sema &S = state.getSema();
4291 bool IsTypedefName =
4297 bool IsQualifiedFunction =
T->isFunctionProtoType() &&
4305 if (
auto *DT =
T->getAs<DeducedType>()) {
4306 const AutoType *AT =
T->getAs<AutoType>();
4308 if ((AT && AT->isDecltypeAuto()) || IsClassTemplateDeduction) {
4310 unsigned Index = E - I - 1;
4312 unsigned DiagId = IsClassTemplateDeduction
4313 ? diag::err_deduced_class_template_compound_type
4314 : diag::err_decltype_auto_compound_type;
4315 unsigned DiagKind = 0;
4316 switch (DeclChunk.
Kind) {
4320 if (IsClassTemplateDeduction) {
4328 DiagId = diag::err_decltype_auto_function_declarator_not_declaration;
4346 S.
Diag(DeclChunk.
Loc, DiagId) << DiagKind;
4354 std::optional<NullabilityKind> inferNullability;
4355 bool inferNullabilityCS =
false;
4356 bool inferNullabilityInnerOnly =
false;
4357 bool inferNullabilityInnerOnlyComplete =
false;
4360 bool inAssumeNonNullRegion =
false;
4362 if (assumeNonNullLoc.
isValid()) {
4363 inAssumeNonNullRegion =
true;
4377 } complainAboutMissingNullability = CAMN_No;
4378 unsigned NumPointersRemaining = 0;
4379 auto complainAboutInferringWithinChunk = PointerWrappingDeclaratorKind::None;
4381 if (IsTypedefName) {
4385 complainAboutMissingNullability = CAMN_InnerPointers;
4389 ++NumPointersRemaining;
4394 switch (chunk.
Kind) {
4402 ++NumPointersRemaining;
4410 ++NumPointersRemaining;
4415 bool isFunctionOrMethod =
false;
4416 switch (
auto context = state.getDeclarator().getContext()) {
4422 isFunctionOrMethod =
true;
4426 if (state.getDeclarator().isObjCIvar() && !isFunctionOrMethod) {
4427 complainAboutMissingNullability = CAMN_No;
4432 if (state.getDeclarator().isObjCWeakProperty()) {
4435 complainAboutMissingNullability = CAMN_No;
4436 if (inAssumeNonNullRegion) {
4446 complainAboutMissingNullability = CAMN_Yes;
4449 auto wrappingKind = PointerWrappingDeclaratorKind::None;
4451 case PointerDeclaratorKind::NonPointer:
4452 case PointerDeclaratorKind::MultiLevelPointer:
4456 case PointerDeclaratorKind::SingleLevelPointer:
4458 if (inAssumeNonNullRegion) {
4459 complainAboutInferringWithinChunk = wrappingKind;
4466 case PointerDeclaratorKind::CFErrorRefPointer:
4467 case PointerDeclaratorKind::NSErrorPointerPointer:
4470 if (isFunctionOrMethod && inAssumeNonNullRegion)
4474 case PointerDeclaratorKind::MaybePointerToCFRef:
4475 if (isFunctionOrMethod) {
4479 auto hasCFReturnsAttr =
4481 return AttrList.hasAttribute(ParsedAttr::AT_CFReturnsRetained) ||
4482 AttrList.hasAttribute(ParsedAttr::AT_CFReturnsNotRetained);
4487 hasCFReturnsAttr(InnermostChunk->getAttrs()) ||
4490 inferNullabilityInnerOnly =
true;
4500 complainAboutMissingNullability = CAMN_Yes;
4528 auto isVaList = [&S](
QualType T) ->
bool {
4534 if (typedefTy->getDecl() == vaListTypedef)
4536 if (
auto *name = typedefTy->getDecl()->getIdentifier())
4537 if (name->isStr(
"va_list"))
4539 typedefTy = typedefTy->desugar()->getAs<
TypedefType>();
4540 }
while (typedefTy);
4546 auto inferPointerNullability =
4551 if (NumPointersRemaining > 0)
4552 --NumPointersRemaining;
4559 if (inferNullability && !inferNullabilityInnerOnlyComplete) {
4562 ? ParsedAttr::Form::ContextSensitiveKeyword()
4563 : ParsedAttr::Form::Keyword(
false ,
4569 attrs.addAtEnd(nullabilityAttr);
4571 if (inferNullabilityCS) {
4572 state.getDeclarator().getMutableDeclSpec().getObjCQualifiers()
4576 if (pointerLoc.isValid() &&
4577 complainAboutInferringWithinChunk !=
4578 PointerWrappingDeclaratorKind::None) {
4580 S.
Diag(pointerLoc, diag::warn_nullability_inferred_on_nested_type);
4585 if (inferNullabilityInnerOnly)
4586 inferNullabilityInnerOnlyComplete =
true;
4587 return nullabilityAttr;
4592 switch (complainAboutMissingNullability) {
4596 case CAMN_InnerPointers:
4597 if (NumPointersRemaining == 0)
4613 if (NumPointersRemaining > 0)
4614 --NumPointersRemaining;
4616 SimplePointerKind pointerKind = SimplePointerKind::Pointer;
4617 if (
T->isBlockPointerType())
4618 pointerKind = SimplePointerKind::BlockPointer;
4619 else if (
T->isMemberPointerType())
4620 pointerKind = SimplePointerKind::MemberPointer;
4622 if (
auto *
attr = inferPointerNullability(
4627 T = state.getAttributedType(
4633 if (complainAboutMissingNullability == CAMN_Yes &&
T->isArrayType() &&
4641 bool ExpectNoDerefChunk =
4642 state.getCurrentAttributes().hasAttribute(ParsedAttr::AT_NoDeref);
4652 bool AreDeclaratorChunksValid =
true;
4654 unsigned chunkIndex = e - i - 1;
4655 state.setCurrentChunkIndex(chunkIndex);
4658 switch (DeclType.
Kind) {
4666 if (!LangOpts.Blocks)
4667 S.
Diag(DeclType.
Loc, diag::err_blocks_disable) << LangOpts.OpenCL;
4670 inferPointerNullability(SimplePointerKind::BlockPointer, DeclType.
Loc,
4672 state.getDeclarator().getAttributePool());
4678 if (LangOpts.OpenCL)
4693 inferPointerNullability(SimplePointerKind::Pointer, DeclType.
Loc,
4695 state.getDeclarator().getAttributePool());
4698 T = Context.getObjCObjectPointerType(
T);
4707 if (LangOpts.OpenCL) {
4708 if (
T->isImageType() ||
T->isSamplerT() ||
T->isPipeType() ||
4709 T->isBlockPointerType()) {
4748 if (chunkIndex != 0 && !ArraySize &&
4767 S.
Diag(DeclType.
Loc, diag::err_array_star_outside_prototype);
4778 S.
Diag(DeclType.
Loc, diag::err_array_static_outside_prototype)
4780 :
"type qualifier");
4791 S.
Diag(DeclType.
Loc, diag::err_array_static_not_outermost)
4793 :
"type qualifier");
4803 if (complainAboutMissingNullability == CAMN_Yes &&
4819 IsQualifiedFunction =
4828 return SS.isInvalid() ||
4850 ? dyn_cast_if_present<ParmVarDecl>(FTI.
Params[0].
Param)
4854 if (
First &&
First->isExplicitObjectParameter() &&
4868 diag::err_explicit_object_parameter_nonmember)
4870 <<
First->getSourceRange();
4873 diag::err_explicit_object_parameter_invalid)
4874 <<
First->getSourceRange();
4879 AreDeclaratorChunksValid =
false;
4889 ? diag::err_auto_missing_trailing_return
4890 : diag::err_deduced_return_type);
4893 AreDeclaratorChunksValid =
false;
4896 diag::warn_cxx11_compat_deduced_return_type);
4905 AreDeclaratorChunksValid =
false;
4908 if (
T != Context.DependentTy) {
4910 diag::err_deduction_guide_with_complex_decl)
4914 AreDeclaratorChunksValid =
false;
4931 S.
Diag(Loc, diag::err_trailing_return_without_auto) <<
T << SR;
4934 AreDeclaratorChunksValid =
false;
4941 }
else if (AutoType *
Auto =
T->getContainedAutoType()) {
4950 if (InventedParamInfo) {
4952 state,
T, TInfo,
Auto, *InventedParamInfo);
4965 T->isFunctionType()) &&
4968 unsigned diagID = diag::err_func_returning_array_function;
4971 if (chunkIndex == 0 &&
4973 diagID = diag::err_block_returning_array_function;
4974 S.
Diag(DeclType.
Loc, diagID) <<
T->isFunctionType() <<
T;
4977 AreDeclaratorChunksValid =
false;
4982 if (
T->isHalfType()) {
4990 }
else if (!S.
getLangOpts().NativeHalfArgsAndReturns &&
4993 diag::err_parameters_retval_cannot_have_fp16_type) << 1;
4999 if (
T.getPointerAuth()) {
5000 S.
Diag(DeclType.
Loc, diag::err_ptrauth_qualifier_invalid) <<
T << 0;
5003 if (LangOpts.OpenCL) {
5006 if (
T->isBlockPointerType() ||
T->isImageType() ||
T->isSamplerT() ||
5017 "__cl_clang_variadic_functions", S.
getLangOpts()) &&
5029 if (
T->isObjCObjectType()) {
5038 S.
Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value)
5042 T = Context.getObjCObjectPointerType(
T);
5050 AreDeclaratorChunksValid =
false;
5058 if ((
T.getCVRQualifiers() ||
T->isAtomicType()) &&
5060 (
T->isDependentType() ||
T->isRecordType()))) {
5067 S.
Diag(DeclType.
Loc, diag::err_func_returning_qualified_void) <<
T;
5074 if (
T.isVolatileQualified() && S.
getLangOpts().CPlusPlus20)
5075 S.
Diag(DeclType.
Loc, diag::warn_deprecated_volatile_return) <<
T;
5080 if (
T.getQualifiers().hasObjCLifetime()) {
5085 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5086 AttrLoc = AL.getLoc();
5093 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5094 AttrLoc = AL.getLoc();
5108 S.
Diag(AttrLoc, diag::warn_arc_lifetime_result_type)
5109 <<
T.getQualifiers().getObjCLifetime();
5117 S.
Diag(Tag->getLocation(), diag::err_type_defined_in_result_type)
5118 << Context.getCanonicalTagType(Tag);
5125 diag::err_exception_spec_in_typedef)
5143 T = Context.getFunctionNoProtoType(
T, EI);
5151 diag::warn_c17_compat_ellipsis_only_parameter);
5153 ParsedAttr::AT_Overloadable) &&
5155 ParsedAttr::AT_Overloadable) &&
5157 ParsedAttr::AT_Overloadable))
5165 diag::err_ident_list_in_fn_declaration);
5169 ? Context.getFunctionNoProtoType(
T, EI)
5171 AreDeclaratorChunksValid =
false;
5194 bool HasAnyInterestingExtParameterInfos =
false;
5196 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
5198 QualType ParamTy = Param->getType();
5199 assert(!ParamTy.
isNull() &&
"Couldn't parse type?");
5210 ParamTy = Context.IntTy;
5211 Param->setType(ParamTy);
5215 ParamTy = Context.IntTy;
5216 Param->setType(ParamTy);
5220 S.
Diag(DeclType.
Loc, diag::err_void_param_qualified);
5222 for (
const auto *A : Param->attrs()) {
5223 S.
Diag(A->getLoc(), diag::warn_attribute_on_void_param)
5224 << A << A->getRange();
5229 if (Param->isExplicitObjectParameter()) {
5230 S.
Diag(Param->getLocation(),
5231 diag::err_void_explicit_object_param);
5244 S.
Diag(Param->getLocation(), diag::err_opencl_invalid_param)
5247 Param->setInvalidDecl();
5249 }
else if (!S.
getLangOpts().NativeHalfArgsAndReturns &&
5251 S.
Diag(Param->getLocation(),
5252 diag::err_parameters_retval_cannot_have_fp16_type) << 0;
5256 if (Context.isPromotableIntegerType(ParamTy)) {
5257 ParamTy = Context.getPromotedIntegerType(ParamTy);
5258 Param->setKNRPromoted(
true);
5260 if (BTy->getKind() == BuiltinType::Float) {
5261 ParamTy = Context.DoubleTy;
5262 Param->setKNRPromoted(
true);
5267 S.
Diag(Param->getLocation(), diag::err_opencl_invalid_param)
5272 if (LangOpts.ObjCAutoRefCount && Param->hasAttr<NSConsumedAttr>()) {
5273 ExtParameterInfos[i] = ExtParameterInfos[i].withIsConsumed(
true);
5274 HasAnyInterestingExtParameterInfos =
true;
5278 ExtParameterInfos[i] =
5279 ExtParameterInfos[i].withABI(
attr->getABI());
5280 HasAnyInterestingExtParameterInfos =
true;
5283 if (Param->hasAttr<PassObjectSizeAttr>()) {
5284 ExtParameterInfos[i] = ExtParameterInfos[i].withHasPassObjectSize();
5285 HasAnyInterestingExtParameterInfos =
true;
5288 if (Param->hasAttr<NoEscapeAttr>()) {
5289 ExtParameterInfos[i] = ExtParameterInfos[i].withIsNoEscape(
true);
5290 HasAnyInterestingExtParameterInfos =
true;
5293 ParamTys.push_back(ParamTy);
5296 if (HasAnyInterestingExtParameterInfos) {
5305 Expr *NoexceptExpr =
nullptr;
5311 DynamicExceptions.reserve(N);
5312 DynamicExceptionRanges.reserve(N);
5313 for (
unsigned I = 0; I != N; ++I) {
5324 DynamicExceptionRanges,
5331 auto IsClassMember = [&]() {
5332 return (!state.getDeclarator().getCXXScopeSpec().isEmpty() &&
5333 state.getDeclarator()
5337 state.getDeclarator().getContext() ==
5339 state.getDeclarator().getContext() ==
5343 if (state.getSema().getLangOpts().OpenCLCPlusPlus && IsClassMember()) {
5363 T = Context.getFunctionType(
T, ParamTys, EPI);
5372 inferPointerNullability(SimplePointerKind::MemberPointer, DeclType.
Loc,
5374 state.getDeclarator().getAttributePool());
5379 AreDeclaratorChunksValid =
false;
5388 AreDeclaratorChunksValid =
false;
5406 AreDeclaratorChunksValid =
false;
5415 S.
Diag(DeclType.
Loc, diag::warn_noderef_on_non_pointer_or_array);
5417 ExpectNoDerefChunk = state.didParseNoDeref();
5421 if (ExpectNoDerefChunk)
5422 S.
Diag(state.getDeclarator().getBeginLoc(),
5423 diag::warn_noderef_on_non_pointer_or_array);
5436 bool IsBlock =
false;
5438 switch (DeclType.Kind) {
5450 S.
Diag(DeclType.Loc, diag::warn_strict_prototypes)
5462 assert(!
T.isNull() &&
"T must not be null after this point");
5464 if (LangOpts.CPlusPlus &&
T->isFunctionType()) {
5466 assert(FnTy &&
"Why oh why is there not a FunctionProtoType here?");
5479 ExplicitObjectMember,
5483 Kind = DeductionGuide;
5500 auto *P = dyn_cast_or_null<ParmVarDecl>(Chunk.
Fun.
Params->
Param);
5501 if (P && P->isExplicitObjectParameter())
5502 Kind = ExplicitObjectMember;
5528 if (IsQualifiedFunction &&
5553 if (!RemovalLocs.empty()) {
5554 llvm::sort(RemovalLocs,
5556 RemovalRange =
SourceRange(RemovalLocs.front(), RemovalLocs.back());
5557 Loc = RemovalLocs.front();
5561 S.
Diag(Loc, diag::err_invalid_qualified_function_type)
5585 if (!AL.slidesFromDeclToDeclSpecLegacyBehavior()) {
5593 state.diagnoseIgnoredTypeAttrs(
T);
5604 if (
T.isVolatileQualified() && S.
getLangOpts().CPlusPlus20 &&
5629 if (!
T->containsUnexpandedParameterPack() &&
5630 (!LangOpts.CPlusPlus20 || !
T->getContainedAutoType())) {
5632 diag::err_function_parameter_pack_without_parameter_packs)
5636 T = Context.getPackExpansionType(
T, std::nullopt,
5649 if (
T->containsUnexpandedParameterPack())
5650 T = Context.getPackExpansionType(
T, std::nullopt);
5653 LangOpts.CPlusPlus11
5654 ? diag::warn_cxx98_compat_variadic_templates
5655 : diag::ext_variadic_templates);
5685 diag::err_ellipsis_in_declarator_not_parameter);
5691 assert(!
T.isNull() &&
"T must not be null at the end of this function");
5692 if (!AreDeclaratorChunksValid)
5693 return Context.getTrivialTypeSourceInfo(
T);
5695 if (state.didParseHLSLParamMod() && !
T->isConstantArrayType())
5704 TypeProcessingState state(*
this, D);
5727 unsigned chunkIndex) {
5728 Sema &S = state.getSema();
5736 const char *attrStr =
nullptr;
5737 switch (ownership) {
5755 &Args, 1, ParsedAttr::Form::GNU());
5764 Sema &S = state.getSema();
5768 bool hasIndirection =
false;
5771 switch (chunk.
Kind) {
5780 hasIndirection =
true;
5813 TypeProcessingState state(*
this, D);
5828 TypeProcessingState &State) {
5833 TypeProcessingState &State) {
5835 State.getSema().HLSL().TakeLocForHLSLAttribute(TL.
getTypePtr());
5843 if (AL.getKind() == ParsedAttr::AT_MatrixType) {
5852 llvm_unreachable(
"no matrix_type attribute found at the expected location!");
5857 switch (Chunk.
Kind) {
5862 llvm_unreachable(
"cannot be _Atomic qualified");
5880 class TypeSpecLocFiller :
public TypeLocVisitor<TypeSpecLocFiller> {
5882 ASTContext &Context;
5883 TypeProcessingState &State;
5887 TypeSpecLocFiller(Sema &S, ASTContext &Context, TypeProcessingState &State,
5889 : SemaRef(S), Context(Context), State(State), DS(DS) {}
5891 void VisitAttributedTypeLoc(AttributedTypeLoc TL) {
5895 void VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) {
5898 void VisitHLSLAttributedResourceTypeLoc(HLSLAttributedResourceTypeLoc TL) {
5902 void VisitHLSLInlineSpirvTypeLoc(HLSLInlineSpirvTypeLoc TL) {}
5903 void VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
5906 State.getExpansionLocForMacroQualifiedType(TL.
getTypePtr()));
5908 void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
5913 void VisitPointerTypeLoc(PointerTypeLoc TL) { Visit(TL.
getNextTypeLoc()); }
5914 void VisitTypedefTypeLoc(TypedefTypeLoc TL) {
5916 TypeSourceInfo *TInfo =
nullptr;
5929 void VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
5931 TypeSourceInfo *TInfo =
nullptr;
5944 void VisitUsingTypeLoc(UsingTypeLoc TL) {
5946 TypeSourceInfo *TInfo =
nullptr;
5959 void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
5966 void VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
5967 TypeSourceInfo *RepTInfo =
nullptr;
5971 void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
5972 TypeSourceInfo *RepTInfo =
nullptr;
5976 void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
5977 TypeSourceInfo *TInfo =
nullptr;
5988 TL.
copy(OldTL.
castAs<TemplateSpecializationTypeLoc>());
5990 OldTL.
castAs<TemplateSpecializationTypeLoc>().getRAngleLoc());
5992 void VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
5998 void VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
6004 TypeSourceInfo *TInfo =
nullptr;
6008 void VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
6013 void VisitPackIndexingTypeLoc(PackIndexingTypeLoc TL) {
6017 void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
6022 TypeSourceInfo *TInfo =
nullptr;
6026 void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
6039 void VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
6041 TypeSourceInfo *TInfo =
nullptr;
6046 void VisitAutoTypeLoc(AutoTypeLoc TL) {
6060 NestedNameSpecifierLoc NNS =
6063 : NestedNameSpecifierLoc());
6064 TemplateArgumentListInfo TemplateArgsInfo(TemplateId->
LAngleLoc,
6066 if (TemplateId->
NumArgs > 0) {
6071 DeclarationNameInfo DNI = DeclarationNameInfo(
6072 TL.
getTypePtr()->getTypeConstraintConcept()->getDeclName(),
6075 NamedDecl *FoundDecl;
6080 FoundDecl = cast_if_present<NamedDecl>(TN.getAsTemplateDecl());
6088 void VisitDeducedTemplateSpecializationTypeLoc(
6089 DeducedTemplateSpecializationTypeLoc TL) {
6091 TypeSourceInfo *TInfo =
nullptr;
6097 void VisitTagTypeLoc(TagTypeLoc TL) {
6099 TypeSourceInfo *TInfo =
nullptr;
6107 ElaboratedTypeKeyword::None
6109 : SourceLocation());
6113 void VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6120 TypeSourceInfo *TInfo =
nullptr;
6132 void VisitPipeTypeLoc(PipeTypeLoc TL) {
6135 TypeSourceInfo *TInfo =
nullptr;
6140 void VisitExtIntTypeLoc(BitIntTypeLoc TL) {
6144 void VisitDependentExtIntTypeLoc(DependentBitIntTypeLoc TL) {
6148 void VisitTypeLoc(TypeLoc TL) {
6154 class DeclaratorLocFiller :
public TypeLocVisitor<DeclaratorLocFiller> {
6155 ASTContext &Context;
6156 TypeProcessingState &State;
6157 const DeclaratorChunk &Chunk;
6160 DeclaratorLocFiller(ASTContext &Context, TypeProcessingState &State,
6161 const DeclaratorChunk &Chunk)
6162 : Context(Context), State(State), Chunk(Chunk) {}
6164 void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6165 llvm_unreachable(
"qualified type locs not expected here!");
6167 void VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6168 llvm_unreachable(
"decayed type locs not expected here!");
6170 void VisitArrayParameterTypeLoc(ArrayParameterTypeLoc TL) {
6171 llvm_unreachable(
"array parameter type locs not expected here!");
6174 void VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6177 void VisitCountAttributedTypeLoc(CountAttributedTypeLoc TL) {
6180 void VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) {
6183 void VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6186 void VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6190 void VisitPointerTypeLoc(PointerTypeLoc TL) {
6194 void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6198 void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6203 void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6209 void VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6214 void VisitArrayTypeLoc(ArrayTypeLoc TL) {
6220 void VisitFunctionTypeLoc(FunctionTypeLoc TL) {
6225 const DeclaratorChunk::FunctionTypeInfo &FTI = Chunk.
Fun;
6228 for (
unsigned i = 0, e = TL.
getNumParams(), tpi = 0; i != e; ++i) {
6234 void VisitParenTypeLoc(ParenTypeLoc TL) {
6239 void VisitPipeTypeLoc(PipeTypeLoc TL) {
6243 void VisitBitIntTypeLoc(BitIntTypeLoc TL) {
6246 void VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
6249 void VisitVectorTypeLoc(VectorTypeLoc TL) { TL.
setNameLoc(Chunk.
Loc); }
6250 void VisitDependentVectorTypeLoc(DependentVectorTypeLoc TL) {
6253 void VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6256 void VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6260 VisitDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL) {
6263 void VisitMatrixTypeLoc(MatrixTypeLoc TL) {
6267 void VisitTypeLoc(TypeLoc TL) {
6268 llvm_unreachable(
"unsupported TypeLoc kind in declarator!");
6277 if (AL.getKind() == ParsedAttr::AT_AddressSpace) {
6286 "no address_space attribute found at the expected location!");
6300 Sema &S = State.getSema();
6326 bool HasDesugaredTypeLoc =
true;
6327 while (HasDesugaredTypeLoc) {
6329 case TypeLoc::MacroQualified: {
6332 State.getExpansionLocForMacroQualifiedType(TL.
getTypePtr()));
6337 case TypeLoc::Attributed: {
6344 case TypeLoc::Adjusted:
6345 case TypeLoc::BTFTagAttributed: {
6350 case TypeLoc::DependentAddressSpace: {
6358 HasDesugaredTypeLoc =
false;
6369 if (ReturnTypeInfo) {
6389 "LocInfoType's TypeClass conflicts with an existing Type class");
6395 llvm_unreachable(
"LocInfoType leaked into the type system; an opaque TypeTy*"
6396 " was used directly instead of getting the QualType through"
6397 " GetTypeFromParser");
6404 "Type name should have no identifier!");
6441 const Expr *AddrSpace,
6444 std::optional<llvm::APSInt> OptAddrSpace =
6446 if (!OptAddrSpace) {
6447 S.
Diag(AttrLoc, diag::err_attribute_argument_type)
6452 llvm::APSInt &addrSpace = *OptAddrSpace;
6455 if (addrSpace.isSigned()) {
6456 if (addrSpace.isNegative()) {
6457 S.
Diag(AttrLoc, diag::err_attribute_address_space_negative)
6461 addrSpace.setIsSigned(
false);
6464 llvm::APSInt
max(addrSpace.getBitWidth());
6468 if (addrSpace >
max) {
6469 S.
Diag(AttrLoc, diag::err_attribute_address_space_too_high)
6491 return Context.getAddrSpaceQualType(
T, ASIdx);
6500 Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
6504 return Context.getDependentAddressSpaceType(
T, AddrSpace, AttrLoc);
6516 TypeProcessingState &State) {
6517 Sema &S = State.getSema();
6523 if (!
Attr.diagnoseLangOpts(S)) {
6529 if (
Attr.getNumArgs() != 1) {
6530 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
6537 auto *StrLiteral = dyn_cast<StringLiteral>(
Attr.getArgAsExpr(0));
6546 StringRef BTFTypeTag = StrLiteral->getString();
6547 Type = State.getBTFTagAttributedType(
6548 ::new (Ctx) BTFTypeTagAttr(Ctx,
Attr, BTFTypeTag),
Type);
6556 TypeProcessingState &State) {
6557 Sema &S = State.getSema();
6562 S.
Diag(
Attr.
getLoc(), diag::err_attribute_address_function_type);
6568 if (
Attr.
getKind() == ParsedAttr::AT_AddressSpace) {
6571 if (
Attr.getNumArgs() != 1) {
6578 Expr *ASArgExpr =
Attr.getArgAsExpr(0);
6587 ::new (Ctx) AddressSpaceAttr(Ctx,
Attr,
static_cast<unsigned>(ASIdx));
6599 if (EquivType.
isNull()) {
6603 T = State.getAttributedType(ASAttr,
Type, EquivType);
6605 T = State.getAttributedType(ASAttr,
Type,
Type);
6616 :
Attr.asOpenCLLangAS();
6618 ASIdx =
Attr.asHLSLLangAS();
6621 llvm_unreachable(
"Invalid address space");
6639 bool NonObjCPointer =
false;
6641 if (!
type->isDependentType() && !
type->isUndeducedType()) {
6649 NonObjCPointer =
true;
6650 }
else if (!
type->isObjCRetainableType()) {
6656 if (state.isProcessingDeclSpec()) {
6664 Sema &S = state.getSema();
6670 if (!
attr.isArgIdent(0)) {
6671 S.
Diag(AttrLoc, diag::err_attribute_argument_type) <<
attr
6679 if (II->
isStr(
"none"))
6681 else if (II->
isStr(
"strong"))
6683 else if (II->
isStr(
"weak"))
6685 else if (II->
isStr(
"autoreleasing"))
6688 S.
Diag(AttrLoc, diag::warn_attribute_type_not_supported) <<
attr << II;
6705 =
type.getQualifiers().getObjCLifetime()) {
6708 S.
Diag(AttrLoc, diag::err_attr_objc_ownership_redundant)
6715 if (previousLifetime != lifetime) {
6718 const Type *prevTy =
nullptr;
6719 while (!prevTy || prevTy != underlyingType.
Ty) {
6720 prevTy = underlyingType.
Ty;
6729 if (NonObjCPointer) {
6730 StringRef name =
attr.getAttrName()->getName();
6739 S.
Diag(AttrLoc, diag::warn_type_attribute_wrong_type) << name
6756 type = state.getAttributedType(
6763 if (!NonObjCPointer)
6780 diagnostic,
type, 0));
6782 S.
Diag(loc, diagnostic);
6791 unsigned diagnostic =
6792 (S.
getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled
6793 : diag::err_arc_weak_no_runtime);
6796 diagnoseOrDelay(S, AttrLoc, diagnostic,
type);
6808 if (Class->isArcWeakrefUnavailable()) {
6809 S.
Diag(AttrLoc, diag::err_arc_unsupported_weak_class);
6810 S.
Diag(ObjT->getInterfaceDecl()->getLocation(),
6811 diag::note_class_declared);
6826 Sema &S = state.getSema();
6829 if (!
type->isPointerType() &&
6830 !
type->isObjCObjectPointerType() &&
6831 !
type->isBlockPointerType())
6835 S.
Diag(
attr.getLoc(), diag::err_attribute_multiple_objc_gc);
6841 if (!
attr.isArgIdent(0)) {
6842 S.
Diag(
attr.getLoc(), diag::err_attribute_argument_type)
6848 if (
attr.getNumArgs() > 1) {
6849 S.
Diag(
attr.getLoc(), diag::err_attribute_wrong_number_arguments) <<
attr
6856 if (II->
isStr(
"weak"))
6858 else if (II->
isStr(
"strong"))
6861 S.
Diag(
attr.getLoc(), diag::warn_attribute_type_not_supported)
6871 if (
attr.getLoc().isValid())
6872 type = state.getAttributedType(
6889 struct FunctionTypeUnwrapper {
6903 const FunctionType *
Fn;
6904 SmallVector<
unsigned char , 8> Stack;
6906 FunctionTypeUnwrapper(Sema &S, QualType
T) : Original(
T) {
6908 const Type *Ty =
T.getTypePtr();
6918 Stack.push_back(Array);
6924 Stack.push_back(BlockPointer);
6927 Stack.push_back(MemberPointer);
6933 Stack.push_back(Attributed);
6936 Stack.push_back(MacroQualified);
6944 T = QualType(DTy, 0);
6945 Stack.push_back(Desugar);
6950 bool isFunctionType()
const {
return (Fn !=
nullptr); }
6951 const FunctionType *get()
const {
return Fn; }
6953 QualType wrap(Sema &S,
const FunctionType *
New) {
6955 if (
New == get())
return Original;
6958 return wrap(S.
Context, Original, 0);
6962 QualType wrap(ASTContext &
C, QualType Old,
unsigned I) {
6963 if (I == Stack.size())
6968 SplitQualType SplitOld = Old.
split();
6972 return wrap(
C, SplitOld.
Ty, I);
6973 return C.getQualifiedType(wrap(
C, SplitOld.
Ty, I), SplitOld.
Quals);
6976 QualType wrap(ASTContext &
C,
const Type *Old,
unsigned I) {
6977 if (I == Stack.size())
return QualType(Fn, 0);
6979 switch (
static_cast<WrapKind
>(Stack[I++])) {
6990 return C.getParenType(
New);
6993 case MacroQualified:
6997 if (
const auto *CAT = dyn_cast<ConstantArrayType>(Old)) {
6998 QualType
New = wrap(
C, CAT->getElementType(), I);
6999 return C.getConstantArrayType(
New, CAT->getSize(), CAT->getSizeExpr(),
7000 CAT->getSizeModifier(),
7001 CAT->getIndexTypeCVRQualifiers());
7004 if (
const auto *VAT = dyn_cast<VariableArrayType>(Old)) {
7005 QualType
New = wrap(
C, VAT->getElementType(), I);
7006 return C.getVariableArrayType(
New, VAT->getSizeExpr(),
7007 VAT->getSizeModifier(),
7008 VAT->getIndexTypeCVRQualifiers());
7012 QualType
New = wrap(
C, IAT->getElementType(), I);
7013 return C.getIncompleteArrayType(
New, IAT->getSizeModifier(),
7014 IAT->getIndexTypeCVRQualifiers());
7019 return C.getPointerType(
New);
7022 case BlockPointer: {
7024 return C.getBlockPointerType(
New);
7027 case MemberPointer: {
7040 return C.getRValueReferenceType(
New);
7044 llvm_unreachable(
"unknown wrapping kind");
7051 Sema &S = State.getSema();
7055 default: llvm_unreachable(
"Unknown attribute kind");
7056 case ParsedAttr::AT_Ptr32:
7059 case ParsedAttr::AT_Ptr64:
7062 case ParsedAttr::AT_SPtr:
7065 case ParsedAttr::AT_UPtr:
7070 std::bitset<attr::LastAttr> Attrs;
7073 if (
const TypedefType *TT = dyn_cast<TypedefType>(Desugared)) {
7074 Desugared = TT->desugar();
7077 const AttributedType *AT = dyn_cast<AttributedType>(Desugared);
7080 Attrs[AT->getAttrKind()] =
true;
7081 Desugared = AT->getModifiedType();
7087 if (Attrs[NewAttrKind]) {
7088 S.
Diag(PAttr.
getLoc(), diag::warn_duplicate_attribute_exact) << PAttr;
7091 Attrs[NewAttrKind] =
true;
7095 if (Attrs[attr::Ptr32] && Attrs[attr::Ptr64]) {
7096 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
7098 <<
"'__ptr64'" << 0;
7100 }
else if (Attrs[attr::SPtr] && Attrs[attr::UPtr]) {
7101 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
7113 S.
Diag(PAttr.
getLoc(), diag::err_attribute_no_member_pointers) << PAttr;
7115 S.
Diag(PAttr.
getLoc(), diag::err_attribute_pointers_only) << PAttr << 0;
7123 if (PtrWidth == 32) {
7124 if (Attrs[attr::Ptr64])
7126 else if (Attrs[attr::UPtr])
7128 }
else if (PtrWidth == 64 && Attrs[attr::Ptr32]) {
7145 assert(PAttr.
getKind() == ParsedAttr::AT_WebAssemblyFuncref);
7147 Sema &S = State.getSema();
7150 std::bitset<attr::LastAttr> Attrs;
7152 const auto *AT = dyn_cast<AttributedType>(QT);
7154 Attrs[AT->getAttrKind()] =
true;
7155 AT = dyn_cast<AttributedType>(AT->getModifiedType());
7160 if (Attrs[NewAttrKind]) {
7161 S.
Diag(PAttr.
getLoc(), diag::warn_duplicate_attribute_exact) << PAttr;
7179 Sema &S = State.getSema();
7180 auto &D = State.getDeclarator();
7186 if (State.isProcessingDeclSpec()) {
7187 if (!(D.isPrototypeContext() ||
7191 if (
auto *chunk = D.getInnermostNonParenChunk()) {
7214 auto chunkIdx = State.getCurrentChunkIndex();
7215 if (chunkIdx >= 1 &&
7218 D.getTypeObject(chunkIdx - 1).getAttrs());
7223 auto *A = ::new (S.
Context) SwiftAttrAttr(S.
Context, PAttr, Str);
7224 QT = State.getAttributedType(A, QT, QT);
7231 auto Attributed = dyn_cast<AttributedType>(
Type.getTypePtr());
7236 if (Attributed->getImmediateNullability())
7237 return Attributed->getModifiedType();
7241 Ctx, Attributed->getModifiedType());
7242 assert(Modified.
getTypePtr() != Attributed->getModifiedType().getTypePtr());
7244 Attributed->getEquivalentType(),
7245 Attributed->getAttr());
7251 case ParsedAttr::AT_TypeNonNull:
7254 case ParsedAttr::AT_TypeNullable:
7257 case ParsedAttr::AT_TypeNullableResult:
7260 case ParsedAttr::AT_TypeNullUnspecified:
7264 llvm_unreachable(
"not a nullability attribute kind");
7271 bool IsContextSensitive,
bool AllowOnArrayType,
bool OverrideExisting) {
7272 bool Implicit = (State ==
nullptr);
7278 while (
auto *Attributed = dyn_cast<AttributedType>(Desugared.
getTypePtr())) {
7280 if (
auto ExistingNullability = Attributed->getImmediateNullability()) {
7282 if (Nullability == *ExistingNullability) {
7286 S.
Diag(NullabilityLoc, diag::warn_nullability_duplicate)
7293 if (!OverrideExisting) {
7295 S.
Diag(NullabilityLoc, diag::err_nullability_conflicting)
7305 Desugared = Attributed->getModifiedType();
7313 if (Nullability != *ExistingNullability && !
Implicit) {
7314 S.
Diag(NullabilityLoc, diag::err_nullability_conflicting)
7322 if (
auto typedefNullability =
7323 AttributedType::stripOuterNullability(underlyingType)) {
7324 if (*typedefNullability == *ExistingNullability) {
7337 !(AllowOnArrayType && Desugared->
isArrayType())) {
7339 S.
Diag(NullabilityLoc, diag::err_nullability_nonpointer)
7347 if (IsContextSensitive) {
7349 const Type *pointeeType =
nullptr;
7358 S.
Diag(NullabilityLoc, diag::err_nullability_cs_multilevel)
7360 S.
Diag(NullabilityLoc, diag::note_nullability_type_specifier)
7372 QT = State->getAttributedType(A, QT, QT);
7381 bool AllowOnArrayType) {
7387 Nullability, NullabilityLoc,
7388 IsContextSensitive, AllowOnArrayType,
7395 bool AllowArrayTypes,
7396 bool OverrideExisting) {
7398 *
this,
nullptr,
nullptr,
Type, Nullability, DiagLoc,
7399 false, AllowArrayTypes, OverrideExisting);
7406 Sema &S = state.getSema();
7410 type = state.getAttributedType(
7423 S.
Diag(
attr.getLoc(), diag::err_objc_kindof_nonobject)
7432 objType->getBaseType(), objType->getTypeArgsAsWritten(),
7433 objType->getProtocols(),
7434 objType->isObjCUnqualifiedId() ?
false :
true);
7439 if (
auto nullability =
type->getNullability()) {
7442 assert(
attr.getAttributeSpellingListIndex() == 0 &&
7443 "multiple spellings for __kindof?");
7446 equivType = state.getAttributedType(A, equivType, equivType);
7451 type = state.getAttributedType(
7464 Declarator &declarator = state.getDeclarator();
7467 auto moveToChunk = [&](
DeclaratorChunk &chunk,
bool inFunction) ->
bool {
7480 PK_MemberFunctionPointer,
7485 : inFunction? PK_MemberFunctionPointer : PK_MemberPointer;
7487 auto diag = state.getSema().Diag(
attr.getLoc(),
7488 diag::warn_nullability_declspec)
7490 attr.isContextSensitiveKeywordAttribute())
7492 <<
static_cast<unsigned>(pointerKind);
7498 state.getSema().getPreprocessor().getLocForEndOfToken(
7500 " " +
attr.getAttrName()->getName().str() +
" ");
7510 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
7512 switch (chunk.
Kind) {
7516 return moveToChunk(chunk,
false);
7528 return moveToChunk(*dest,
true);
7544 assert(!
Attr.isInvalid());
7547 llvm_unreachable(
"not a calling convention attribute");
7548 case ParsedAttr::AT_CDecl:
7550 case ParsedAttr::AT_FastCall:
7552 case ParsedAttr::AT_StdCall:
7554 case ParsedAttr::AT_ThisCall:
7556 case ParsedAttr::AT_RegCall:
7558 case ParsedAttr::AT_Pascal:
7560 case ParsedAttr::AT_SwiftCall:
7562 case ParsedAttr::AT_SwiftAsyncCall:
7564 case ParsedAttr::AT_VectorCall:
7566 case ParsedAttr::AT_AArch64VectorPcs:
7568 case ParsedAttr::AT_AArch64SVEPcs:
7570 case ParsedAttr::AT_ArmStreaming:
7572 case ParsedAttr::AT_Pcs: {
7577 if (
Attr.isArgExpr(0))
7580 Str =
Attr.getArgAsIdent(0)->getIdentifierInfo()->getName();
7581 PcsAttr::PCSType
Type;
7582 if (!PcsAttr::ConvertStrToPCSType(Str,
Type))
7583 llvm_unreachable(
"already validated the attribute");
7584 return ::new (Ctx) PcsAttr(Ctx,
Attr,
Type);
7586 case ParsedAttr::AT_IntelOclBicc:
7588 case ParsedAttr::AT_MSABI:
7590 case ParsedAttr::AT_SysVABI:
7592 case ParsedAttr::AT_PreserveMost:
7594 case ParsedAttr::AT_PreserveAll:
7596 case ParsedAttr::AT_M68kRTD:
7598 case ParsedAttr::AT_PreserveNone:
7600 case ParsedAttr::AT_RISCVVectorCC:
7602 case ParsedAttr::AT_RISCVVLSCC: {
7605 unsigned ABIVLen = 128;
7606 if (
Attr.getNumArgs()) {
7607 std::optional<llvm::APSInt> MaybeABIVLen =
7608 Attr.getArgAsExpr(0)->getIntegerConstantExpr(Ctx);
7610 llvm_unreachable(
"Invalid RISC-V ABI VLEN");
7611 ABIVLen = MaybeABIVLen->getZExtValue();
7614 return ::new (Ctx) RISCVVLSCCAttr(Ctx,
Attr, ABIVLen);
7617 llvm_unreachable(
"unexpected attribute kind!");
7620std::optional<FunctionEffectMode>
7625 std::optional<llvm::APSInt> ConditionValue =
7627 if (!ConditionValue) {
7633 return std::nullopt;
7642 FunctionTypeUnwrapper &Unwrapped) {
7644 if (!Unwrapped.isFunctionType())
7647 Sema &S = TPState.getSema();
7651 if (FPT ==
nullptr) {
7652 S.
Diag(PAttr.
getLoc(), diag::err_func_with_effects_no_prototype)
7659 bool IsNonBlocking = PAttr.
getKind() == ParsedAttr::AT_NonBlocking ||
7660 PAttr.
getKind() == ParsedAttr::AT_Blocking;
7663 Expr *CondExpr =
nullptr;
7665 if (PAttr.
getKind() == ParsedAttr::AT_NonBlocking ||
7666 PAttr.
getKind() == ParsedAttr::AT_NonAllocating) {
7675 std::optional<FunctionEffectMode> MaybeMode =
7681 NewMode = *MaybeMode;
7716 assert(
Success &&
"effect conflicts should have been diagnosed above");
7720 FPT->getParamTypes(), EPI);
7729 auto OtherAttr = llvm::find_if(
7730 state.getCurrentAttributes(),
7731 [OtherKind](
const ParsedAttr &A) { return A.getKind() == OtherKind; });
7732 if (OtherAttr == state.getCurrentAttributes().end() || OtherAttr->isInvalid())
7735 Sema &S = state.getSema();
7737 << *OtherAttr <<
Attr
7738 << (OtherAttr->isRegularKeywordAttribute() ||
7740 S.
Diag(OtherAttr->getLoc(), diag::note_conflicting_attribute);
7748 if (!
Attr.getNumArgs()) {
7754 for (
unsigned I = 0; I <
Attr.getNumArgs(); ++I) {
7755 StringRef StateName;
7760 if (StateName !=
"sme_za_state") {
7761 S.
Diag(LiteralLoc, diag::err_unknown_arm_state) << StateName;
7768 S.
Diag(
Attr.
getLoc(), diag::err_conflicting_attributes_arm_agnostic);
7783 if (!
Attr.getNumArgs()) {
7789 for (
unsigned I = 0; I <
Attr.getNumArgs(); ++I) {
7790 StringRef StateName;
7797 if (StateName ==
"za") {
7800 }
else if (StateName ==
"zt0") {
7804 S.
Diag(LiteralLoc, diag::err_unknown_arm_state) << StateName;
7810 S.
Diag(LiteralLoc, diag::err_conflicting_attributes_arm_agnostic);
7819 S.
Diag(LiteralLoc, diag::err_conflicting_attributes_arm_state)
7835 Sema &S = state.getSema();
7837 FunctionTypeUnwrapper unwrapped(S,
type);
7839 if (
attr.getKind() == ParsedAttr::AT_NoReturn) {
7844 if (!unwrapped.isFunctionType())
7853 if (
attr.getKind() == ParsedAttr::AT_CFIUncheckedCallee) {
7855 if (!unwrapped.isFunctionType())
7858 if (!unwrapped.get()->isFunctionProtoType()) {
7859 S.
Diag(
attr.getLoc(), diag::warn_attribute_wrong_decl_type)
7860 <<
attr <<
attr.isRegularKeywordAttribute()
7868 FPT->getReturnType(), FPT->getParamTypes(),
7869 FPT->getExtProtoInfo().withCFIUncheckedCallee(
true));
7874 if (
attr.getKind() == ParsedAttr::AT_CmseNSCall) {
7876 if (!unwrapped.isFunctionType())
7881 S.
Diag(
attr.getLoc(), diag::warn_attribute_ignored) <<
attr;
7888 unwrapped.get()->getExtInfo().withCmseNSCall(
true);
7895 if (
attr.getKind() == ParsedAttr::AT_NSReturnsRetained) {
7896 if (
attr.getNumArgs())
return true;
7899 if (!unwrapped.isFunctionType())
7904 attr.getLoc(), unwrapped.get()->getReturnType()))
7909 if (state.getSema().getLangOpts().ObjCAutoRefCount) {
7911 = unwrapped.get()->getExtInfo().withProducesResult(
true);
7914 type = state.getAttributedType(
7920 if (
attr.getKind() == ParsedAttr::AT_AnyX86NoCallerSavedRegisters) {
7925 if (!unwrapped.isFunctionType())
7929 unwrapped.get()->getExtInfo().withNoCallerSavedRegs(
true);
7934 if (
attr.getKind() == ParsedAttr::AT_AnyX86NoCfCheck) {
7936 S.
Diag(
attr.getLoc(), diag::warn_nocf_check_attribute_ignored);
7946 if (!unwrapped.isFunctionType())
7950 unwrapped.get()->getExtInfo().withNoCfCheck(
true);
7955 if (
attr.getKind() == ParsedAttr::AT_Regparm) {
7961 if (!unwrapped.isFunctionType())
7968 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
7970 <<
attr.isRegularKeywordAttribute();
7976 unwrapped.get()->getExtInfo().withRegParm(value);
7981 if (
attr.getKind() == ParsedAttr::AT_CFISalt) {
7982 if (
attr.getNumArgs() != 1)
7990 if (!unwrapped.isFunctionType())
7995 S.
Diag(
attr.getLoc(), diag::err_attribute_wrong_decl_type)
7996 <<
attr <<
attr.isRegularKeywordAttribute()
8006 FnTy->getParamTypes(), EPI);
8011 if (
attr.getKind() == ParsedAttr::AT_ArmStreaming ||
8012 attr.getKind() == ParsedAttr::AT_ArmStreamingCompatible ||
8013 attr.getKind() == ParsedAttr::AT_ArmPreserves ||
8014 attr.getKind() == ParsedAttr::AT_ArmIn ||
8015 attr.getKind() == ParsedAttr::AT_ArmOut ||
8016 attr.getKind() == ParsedAttr::AT_ArmInOut ||
8017 attr.getKind() == ParsedAttr::AT_ArmAgnostic) {
8021 if (
attr.getKind() == ParsedAttr::AT_ArmStreaming ||
8022 attr.getKind() == ParsedAttr::AT_ArmStreamingCompatible)
8026 if (!unwrapped.isFunctionType())
8033 S.
Diag(
attr.getLoc(), diag::warn_attribute_wrong_decl_type)
8034 <<
attr <<
attr.isRegularKeywordAttribute()
8041 switch (
attr.getKind()) {
8042 case ParsedAttr::AT_ArmStreaming:
8044 ParsedAttr::AT_ArmStreamingCompatible))
8048 case ParsedAttr::AT_ArmStreamingCompatible:
8053 case ParsedAttr::AT_ArmPreserves:
8057 case ParsedAttr::AT_ArmIn:
8061 case ParsedAttr::AT_ArmOut:
8065 case ParsedAttr::AT_ArmInOut:
8069 case ParsedAttr::AT_ArmAgnostic:
8074 llvm_unreachable(
"Unsupported attribute");
8078 FnTy->getParamTypes(), EPI);
8083 if (
attr.getKind() == ParsedAttr::AT_NoThrow) {
8085 if (!unwrapped.isFunctionType())
8098 if (Proto->hasExceptionSpec()) {
8099 switch (Proto->getExceptionSpecType()) {
8101 llvm_unreachable(
"This doesn't have an exception spec!");
8119 S.
Diag(
attr.getLoc(), diag::warn_nothrow_attribute_ignored);
8125 type = unwrapped.wrap(
8134 if (
attr.getKind() == ParsedAttr::AT_NonBlocking ||
8135 attr.getKind() == ParsedAttr::AT_NonAllocating ||
8136 attr.getKind() == ParsedAttr::AT_Blocking ||
8137 attr.getKind() == ParsedAttr::AT_Allocating) {
8142 if (!unwrapped.isFunctionType())
return false;
8157 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
8160 <<
attr.isRegularKeywordAttribute();
8179 return S.
Diag(
attr.getLoc(), diag::warn_cconv_unsupported)
8184 return S.
Diag(
attr.getLoc(), diag::err_cconv_varargs)
8191 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
8193 <<
attr.isRegularKeywordAttribute();
8205 auto EI = unwrapped.get()->getExtInfo().withCallingConv(CC);
8214 const AttributedType *AT;
8218 while ((AT =
T->getAs<AttributedType>()) &&
8220 if (AT->isCallingConv())
8222 T = AT->getModifiedType();
8229 FunctionTypeUnwrapper Unwrapped(*
this,
T);
8235 Context.getDefaultCallingConvention(IsVariadic, HasThisPointer);
8242 if (
Context.getTargetInfo().getCXXABI().isMicrosoft() && IsCtorOrDtor) {
8246 Diag(Loc, diag::warn_cconv_unsupported)
8255 Context.getDefaultCallingConvention(IsVariadic, !HasThisPointer);
8257 if (CurCC != DefaultCC)
8265 QualType Wrapped = Unwrapped.wrap(*
this, FT);
8266 T =
Context.getAdjustedType(
T, Wrapped);
8279 if (
Attr.getNumArgs() != 1) {
8286 Expr *SizeExpr =
Attr.getArgAsExpr(0);
8299 if (
Attr.getNumArgs() != 1) {
8305 Expr *SizeExpr =
Attr.getArgAsExpr(0);
8320 bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 ||
8321 Triple.getArch() == llvm::Triple::aarch64_32 ||
8322 Triple.getArch() == llvm::Triple::aarch64_be;
8324 if (IsPolyUnsigned) {
8326 return BTy->
getKind() == BuiltinType::UChar ||
8327 BTy->
getKind() == BuiltinType::UShort ||
8328 BTy->
getKind() == BuiltinType::ULong ||
8329 BTy->
getKind() == BuiltinType::ULongLong;
8332 return BTy->
getKind() == BuiltinType::SChar ||
8333 BTy->
getKind() == BuiltinType::Short ||
8334 BTy->
getKind() == BuiltinType::LongLong;
8340 if ((Triple.isArch64Bit() || Triple.getArch() == llvm::Triple::aarch64_32) &&
8341 BTy->
getKind() == BuiltinType::Double)
8344 return BTy->
getKind() == BuiltinType::SChar ||
8345 BTy->
getKind() == BuiltinType::UChar ||
8346 BTy->
getKind() == BuiltinType::Short ||
8347 BTy->
getKind() == BuiltinType::UShort ||
8348 BTy->
getKind() == BuiltinType::Int ||
8349 BTy->
getKind() == BuiltinType::UInt ||
8350 BTy->
getKind() == BuiltinType::Long ||
8351 BTy->
getKind() == BuiltinType::ULong ||
8352 BTy->
getKind() == BuiltinType::LongLong ||
8353 BTy->
getKind() == BuiltinType::ULongLong ||
8354 BTy->
getKind() == BuiltinType::Float ||
8355 BTy->
getKind() == BuiltinType::Half ||
8356 BTy->
getKind() == BuiltinType::BFloat16 ||
8357 BTy->
getKind() == BuiltinType::MFloat8;
8361 llvm::APSInt &Result) {
8362 const auto *AttrExpr =
Attr.getArgAsExpr(0);
8363 if (!AttrExpr->isTypeDependent()) {
8364 if (std::optional<llvm::APSInt> Res =
8365 AttrExpr->getIntegerConstantExpr(S.
Context)) {
8407 if (
Attr.getNumArgs() != 1) {
8408 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8414 llvm::APSInt numEltsInt(32);
8420 S.
Diag(
Attr.
getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
8427 unsigned numElts =
static_cast<unsigned>(numEltsInt.getZExtValue());
8428 unsigned vecSize = typeSize * numElts;
8429 if (vecSize != 64 && vecSize != 128) {
8430 S.
Diag(
Attr.
getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType;
8442 assert((
Attr.getNumArgs() > 0 &&
Attr.getNumArgs() <= 3) &&
8443 "__ptrauth qualifier takes between 1 and 3 arguments");
8444 Expr *KeyArg =
Attr.getArgAsExpr(0);
8445 Expr *IsAddressDiscriminatedArg =
8446 Attr.getNumArgs() >= 2 ?
Attr.getArgAsExpr(1) :
nullptr;
8447 Expr *ExtraDiscriminatorArg =
8448 Attr.getNumArgs() >= 3 ?
Attr.getArgAsExpr(2) :
nullptr;
8457 bool IsInvalid =
false;
8458 unsigned IsAddressDiscriminated, ExtraDiscriminator;
8461 IsAddressDiscriminated);
8470 if (!
T->isSignableType(Ctx) && !
T->isDependentType()) {
8471 S.
Diag(
Attr.
getLoc(), diag::err_ptrauth_qualifier_invalid_target) <<
T;
8476 if (
T.getPointerAuth()) {
8488 assert((!IsAddressDiscriminatedArg || IsAddressDiscriminated <= 1) &&
8489 "address discriminator arg should be either 0 or 1");
8491 Key, IsAddressDiscriminated, ExtraDiscriminator,
8513 S.
Diag(
Attr.
getLoc(), diag::err_attribute_arm_feature_sve_bits_unsupported)
8520 if (
Attr.getNumArgs() != 1) {
8521 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8528 llvm::APSInt SveVectorSizeInBits(32);
8532 unsigned VecSize =
static_cast<unsigned>(SveVectorSizeInBits.getZExtValue());
8555 if (BT->getKind() == BuiltinType::SveBool) {
8560 VecSize /= TypeSize;
8567 const VectorType *VT = dyn_cast<VectorType>(CurType);
8570 diag::err_attribute_arm_mve_polymorphism);
8577 State.getSema().Context,
Attr),
8589 <<
Attr <<
"'zve32x'";
8596 if (!VScale || !VScale->first || VScale->first != VScale->second) {
8597 S.
Diag(
Attr.
getLoc(), diag::err_attribute_riscv_rvv_bits_unsupported)
8604 if (
Attr.getNumArgs() != 1) {
8605 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8612 llvm::APSInt RVVVectorSizeInBits(32);
8624 unsigned VecSize =
static_cast<unsigned>(RVVVectorSizeInBits.getZExtValue());
8628 unsigned MinElts = Info.
EC.getKnownMinValue();
8631 unsigned ExpectedSize = VScale->first * MinElts;
8653 ExpectedSize *= EltSize;
8654 NumElts = VecSize / EltSize;
8658 if (VecSize != ExpectedSize) {
8660 << VecSize << ExpectedSize;
8673 S.
Diag(
Attr.
getLoc(), diag::err_opencl_invalid_access_qualifier);
8679 QualType BaseTy = TypedefTy->desugar();
8681 std::string PrevAccessQual;
8683 if (TypedefTy->getDecl()->hasAttr<OpenCLAccessAttr>()) {
8684 OpenCLAccessAttr *
Attr =
8685 TypedefTy->getDecl()->getAttr<OpenCLAccessAttr>();
8688 PrevAccessQual =
"read_only";
8692 switch (ImgType->getKind()) {
8693 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8694 case BuiltinType::Id: \
8695 PrevAccessQual = #Access; \
8697 #include "clang/Basic/OpenCLImageTypes.def"
8699 llvm_unreachable(
"Unable to find corresponding image type.");
8702 llvm_unreachable(
"unexpected type");
8705 if (PrevAccessQual == AttrName.ltrim(
"_")) {
8711 S.
Diag(
Attr.
getLoc(), diag::err_opencl_multiple_access_qualifiers);
8714 S.
Diag(TypedefTy->getDecl()->getBeginLoc(),
8715 diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;
8717 if (
Attr.getSemanticSpelling() == OpenCLAccessAttr::Keyword_write_only) {
8732 if (
Attr.getNumArgs() != 2) {
8733 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8738 Expr *RowsExpr =
Attr.getArgAsExpr(0);
8739 Expr *ColsExpr =
Attr.getArgAsExpr(1);
8747 Sema &S = State.getSema();
8750 S.
Diag(PA.
getLoc(), diag::err_attribute_too_few_arguments) << PA << 1;
8762 for (
unsigned Idx = 1; Idx < PA.
getNumArgs(); Idx++) {
8768 auto *AnnotateTypeAttr =
8769 AnnotateTypeAttr::Create(S.
Context, Str, Args.data(), Args.size(), PA);
8770 CurType = State.getAttributedType(AnnotateTypeAttr, CurType, CurType);
8776 if (State.getDeclarator().isDeclarationOfFunction()) {
8777 CurType = State.getAttributedType(
8782 State.getSema().Diag(
Attr.
getLoc(), diag::err_attribute_wrong_decl_type)
8789 if (State.getDeclarator().isDeclarationOfFunction()) {
8790 auto *
Attr = State.getSema().ParseLifetimeCaptureByAttr(PA,
"this");
8792 CurType = State.getAttributedType(
Attr, CurType, CurType);
8804 if (
Attr.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_inout ||
8805 Attr.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_out) {
8806 State.setParsedHLSLParamMod(
true);
8815 state.setParsedNoDeref(
false);
8831 if (
attr.isInvalid())
8834 if (
attr.isStandardAttributeSyntax() ||
attr.isRegularKeywordAttribute()) {
8839 if (
attr.isGNUScope()) {
8840 assert(
attr.isStandardAttributeSyntax());
8841 bool IsTypeAttr =
attr.isTypeAttr();
8843 state.getSema().Diag(
attr.getLoc(),
8845 ? diag::warn_gcc_ignores_type_attr
8846 : diag::warn_cxx11_gnu_attribute_on_type)
8852 !
attr.isTypeAttr()) {
8865 switch (
attr.getKind()) {
8868 if ((
attr.isStandardAttributeSyntax() ||
8869 attr.isRegularKeywordAttribute()) &&
8871 state.getSema().Diag(
attr.getLoc(), diag::err_attribute_not_type_attr)
8872 <<
attr <<
attr.isRegularKeywordAttribute();
8873 attr.setUsedAsTypeAttr();
8878 if (
attr.isStandardAttributeSyntax()) {
8879 state.getSema().DiagnoseUnknownAttribute(
attr);
8889 case ParsedAttr::AT_BTFTypeTag:
8891 attr.setUsedAsTypeAttr();
8894 case ParsedAttr::AT_MayAlias:
8897 attr.setUsedAsTypeAttr();
8899 case ParsedAttr::AT_OpenCLPrivateAddressSpace:
8900 case ParsedAttr::AT_OpenCLGlobalAddressSpace:
8901 case ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace:
8902 case ParsedAttr::AT_OpenCLGlobalHostAddressSpace:
8903 case ParsedAttr::AT_OpenCLLocalAddressSpace:
8904 case ParsedAttr::AT_OpenCLConstantAddressSpace:
8905 case ParsedAttr::AT_OpenCLGenericAddressSpace:
8906 case ParsedAttr::AT_HLSLGroupSharedAddressSpace:
8907 case ParsedAttr::AT_AddressSpace:
8909 attr.setUsedAsTypeAttr();
8914 attr.setUsedAsTypeAttr();
8916 case ParsedAttr::AT_VectorSize:
8918 attr.setUsedAsTypeAttr();
8920 case ParsedAttr::AT_ExtVectorType:
8922 attr.setUsedAsTypeAttr();
8924 case ParsedAttr::AT_NeonVectorType:
8926 attr.setUsedAsTypeAttr();
8928 case ParsedAttr::AT_NeonPolyVectorType:
8931 attr.setUsedAsTypeAttr();
8933 case ParsedAttr::AT_ArmSveVectorBits:
8935 attr.setUsedAsTypeAttr();
8937 case ParsedAttr::AT_ArmMveStrictPolymorphism: {
8939 attr.setUsedAsTypeAttr();
8942 case ParsedAttr::AT_RISCVRVVVectorBits:
8944 attr.setUsedAsTypeAttr();
8946 case ParsedAttr::AT_OpenCLAccess:
8948 attr.setUsedAsTypeAttr();
8950 case ParsedAttr::AT_PointerAuth:
8953 attr.setUsedAsTypeAttr();
8955 case ParsedAttr::AT_LifetimeBound:
8959 case ParsedAttr::AT_LifetimeCaptureBy:
8964 case ParsedAttr::AT_NoDeref: {
8969 if (
attr.isStandardAttributeSyntax()) {
8970 state.getSema().Diag(
attr.getLoc(), diag::warn_attribute_ignored)
8977 attr.setUsedAsTypeAttr();
8978 state.setParsedNoDeref(
true);
8982 case ParsedAttr::AT_MatrixType:
8984 attr.setUsedAsTypeAttr();
8987 case ParsedAttr::AT_WebAssemblyFuncref: {
8989 attr.setUsedAsTypeAttr();
8993 case ParsedAttr::AT_HLSLParamModifier: {
8995 attr.setUsedAsTypeAttr();
8999 case ParsedAttr::AT_SwiftAttr: {
9006 attr.setUsedAsTypeAttr();
9014 if (
type->canHaveNullability() ||
type->isDependentType() ||
9015 type->isArrayType() ||
9019 endIndex = state.getCurrentChunkIndex();
9021 endIndex = state.getDeclarator().getNumTypeObjects();
9022 bool allowOnArrayType =
9023 state.getDeclarator().isPrototypeContext() &&
9026 allowOnArrayType)) {
9030 attr.setUsedAsTypeAttr();
9034 case ParsedAttr::AT_ObjCKindOf:
9042 state.getSema().Diag(
attr.getLoc(),
9043 diag::err_objc_kindof_wrong_position)
9046 state.getDeclarator().getDeclSpec().getBeginLoc(),
9056 case ParsedAttr::AT_NoThrow:
9059 if (!state.getSema().getLangOpts().CPlusPlus)
9064 attr.setUsedAsTypeAttr();
9068 if (
attr.isStandardAttributeSyntax() ||
9069 attr.isRegularKeywordAttribute()) {
9086 case ParsedAttr::AT_AcquireHandle: {
9087 if (!
type->isFunctionType())
9090 if (
attr.getNumArgs() != 1) {
9091 state.getSema().Diag(
attr.getLoc(),
9092 diag::err_attribute_wrong_number_arguments)
9098 StringRef HandleType;
9099 if (!state.getSema().checkStringLiteralArgumentAttr(
attr, 0, HandleType))
9101 type = state.getAttributedType(
9102 AcquireHandleAttr::Create(state.getSema().Context, HandleType,
attr),
9104 attr.setUsedAsTypeAttr();
9107 case ParsedAttr::AT_AnnotateType: {
9109 attr.setUsedAsTypeAttr();
9112 case ParsedAttr::AT_HLSLResourceClass:
9113 case ParsedAttr::AT_HLSLROV:
9114 case ParsedAttr::AT_HLSLRawBuffer:
9115 case ParsedAttr::AT_HLSLContainedType: {
9120 state.getSema().HLSL().handleResourceTypeAttr(
type,
attr))
9121 attr.setUsedAsTypeAttr();
9129 !
type.getQualifiers().hasObjCLifetime() &&
9130 !
type.getQualifiers().hasObjCGCAttr() &&
9131 attr.getKind() != ParsedAttr::AT_ObjCGC &&
9132 attr.getKind() != ParsedAttr::AT_ObjCOwnership) {
9134 type = state.getSema().Context.getMacroQualifiedType(
type, MacroII);
9135 state.setExpansionLocForMacroQualifiedType(
9137 attr.getMacroExpansionLoc());
9144 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
9146 auto *Def = Var->getDefinition();
9152 Def = Var->getDefinition();
9159 if (Var->getPointOfInstantiation().isInvalid() && Def) {
9160 assert(Var->getTemplateSpecializationKind() ==
9162 "explicit instantiation with no point of instantiation");
9163 Var->setTemplateSpecializationKind(
9164 Var->getTemplateSpecializationKind(), PointOfInstantiation);
9184 if (
const auto CastE = dyn_cast<ExplicitCastExpr>(E)) {
9185 QualType DestType = CastE->getTypeAsWritten();
9186 if (
const auto *IAT =
Context.getAsIncompleteArrayType(DestType)) {
9191 IAT->getElementType(),
9228 if (RequireCompleteTypeImpl(Loc,
T, Kind, &Diagnoser))
9230 if (
auto *TD =
T->getAsTagDecl(); TD && !TD->isCompleteDefinitionRequired()) {
9231 TD->setCompleteDefinitionRequired();
9232 Consumer.HandleTagDeclRequiredDefinition(TD);
9264 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
9265 if (
auto *Pattern = RD->getTemplateInstantiationPattern())
9267 D = RD->getDefinition();
9268 }
else if (
auto *ED = dyn_cast<EnumDecl>(D)) {
9269 if (
auto *Pattern = ED->getTemplateInstantiationPattern())
9271 if (OnlyNeedComplete && (ED->isFixed() ||
getLangOpts().MSVCCompat)) {
9277 *Suggested =
nullptr;
9278 for (
auto *Redecl : ED->redecls()) {
9281 if (Redecl->isThisDeclarationADefinition() ||
9282 (Redecl->isCanonicalDecl() && !*Suggested))
9283 *Suggested = Redecl;
9288 D = ED->getDefinition();
9289 }
else if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
9290 if (
auto *Pattern = FD->getTemplateInstantiationPattern())
9292 D = FD->getDefinition();
9293 }
else if (
auto *VD = dyn_cast<VarDecl>(D)) {
9294 if (
auto *Pattern = VD->getTemplateInstantiationPattern())
9296 D = VD->getDefinition();
9299 assert(D &&
"missing definition for pattern of instantiated definition");
9303 auto DefinitionIsAcceptable = [&] {
9323 if (DefinitionIsAcceptable())
9328 if (
auto *Source =
Context.getExternalSource()) {
9329 Source->CompleteRedeclChain(D);
9330 return DefinitionIsAcceptable();
9346 bool OnlyNeedComplete) {
9363 bool OnlyNeedComplete) {
9371 if (!RD->
hasAttr<MSInheritanceAttr>()) {
9373 bool BestCase =
false;
9393 RD->
addAttr(MSInheritanceAttr::CreateImplicit(
9394 S.
getASTContext(), BestCase, Loc, MSInheritanceAttr::Spelling(IM)));
9400 CompleteTypeKind Kind,
9401 TypeDiagnoser *Diagnoser) {
9410 if (
const auto *MPTy = dyn_cast<MemberPointerType>(
T.getCanonicalType())) {
9411 if (CXXRecordDecl *RD = MPTy->getMostRecentCXXRecordDecl();
9412 RD && !RD->isDependentType()) {
9414 if (
getLangOpts().CompleteMemberPointers && !RD->isBeingDefined() &&
9420 if (
Context.getTargetInfo().getCXXABI().isMicrosoft()) {
9427 NamedDecl *Def =
nullptr;
9439 NamedDecl *Suggested =
nullptr;
9445 if (Diagnoser && Suggested)
9448 return !TreatAsComplete;
9452 TempInst.Template = Def;
9453 TempInst.Entity = Def;
9454 TempInst.PointOfInstantiation = Loc;
9462 TagDecl *
Tag = dyn_cast_or_null<TagDecl>(Def);
9463 ObjCInterfaceDecl *IFace = dyn_cast_or_null<ObjCInterfaceDecl>(Def);
9475 if (
auto *Source =
Context.getExternalSource()) {
9476 if (Tag &&
Tag->hasExternalLexicalStorage())
9477 Source->CompleteType(Tag);
9479 Source->CompleteType(IFace);
9483 return RequireCompleteTypeImpl(Loc,
T, Kind, Diagnoser);
9490 if (
auto *RD = dyn_cast_or_null<CXXRecordDecl>(Tag)) {
9491 bool Instantiated =
false;
9492 bool Diagnosed =
false;
9493 if (RD->isDependentContext()) {
9497 }
else if (
auto *ClassTemplateSpec =
9498 dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
9499 if (ClassTemplateSpec->getSpecializationKind() ==
TSK_Undeclared) {
9503 Diagnoser, ClassTemplateSpec->hasStrictPackMatch());
9505 Instantiated =
true;
9508 CXXRecordDecl *Pattern = RD->getInstantiatedFromMemberClass();
9509 if (!RD->isBeingDefined() && Pattern) {
9510 MemberSpecializationInfo *MSI = RD->getMemberSpecializationInfo();
9511 assert(MSI &&
"Missing member specialization information?");
9521 Instantiated =
true;
9529 if (Diagnoser && Diagnosed)
9535 return RequireCompleteTypeImpl(Loc,
T, Kind, Diagnoser);
9545 Diagnoser->diagnose(*
this, Loc,
T);
9549 if (Tag && !
Tag->isInvalidDecl() && !
Tag->getLocation().isInvalid())
9550 Diag(
Tag->getLocation(),
Tag->isBeingDefined()
9551 ? diag::note_type_being_defined
9552 : diag::note_forward_declaration)
9553 <<
Context.getCanonicalTagType(Tag);
9586 default: llvm_unreachable(
"Invalid tag kind for literal type diagnostic!");
9592 assert(!
T->isDependentType() &&
"type should not be dependent");
9601 if (
T->isVariableArrayType())
9617 Diag(RD->getLocation(), diag::note_non_literal_lambda);
9625 if (RD->getNumVBases()) {
9626 Diag(RD->getLocation(), diag::note_non_literal_virtual_base)
9628 for (
const auto &I : RD->vbases())
9629 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
9630 << I.getSourceRange();
9631 }
else if (!RD->isAggregate() && !RD->hasConstexprNonCopyMoveConstructor() &&
9632 !RD->hasTrivialDefaultConstructor()) {
9633 Diag(RD->getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD;
9634 }
else if (RD->hasNonLiteralTypeFieldsOrBases()) {
9635 for (
const auto &I : RD->bases()) {
9636 if (!I.getType()->isLiteralType(
Context)) {
9637 Diag(I.getBeginLoc(), diag::note_non_literal_base_class)
9638 << RD << I.getType() << I.getSourceRange();
9642 for (
const auto *I : RD->fields()) {
9643 if (!I->getType()->isLiteralType(
Context) ||
9644 I->getType().isVolatileQualified()) {
9645 Diag(I->getLocation(), diag::note_non_literal_field)
9646 << RD << I << I->getType()
9647 << I->getType().isVolatileQualified();
9652 : !RD->hasTrivialDestructor()) {
9657 assert(Dtor &&
"class has literal fields and bases but no dtor?");
9666 ? diag::note_non_literal_user_provided_dtor
9667 : diag::note_non_literal_nontrivial_dtor)
9693 if (
const TagType *TT =
T->getAs<TagType>())
9696 return Context.getTypeOfExprType(E, Kind);
9717 return Context.getCountAttributedType(WrappedTy, CountExpr, CountInBytes,
9727 if (
auto *ImplCastExpr = dyn_cast<ImplicitCastExpr>(E))
9728 IDExpr = ImplCastExpr->getSubExpr();
9730 if (
auto *PackExpr = dyn_cast<PackIndexingExpr>(E)) {
9732 IDExpr = PackExpr->getPackIdExpression();
9734 IDExpr = PackExpr->getSelectedExpr();
9750 if (
const auto *SNTTPE = dyn_cast<SubstNonTypeTemplateParmExpr>(IDExpr))
9751 return SNTTPE->getParameterType(
Context);
9759 if (
const auto *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
9764 if (
const auto *ME = dyn_cast<MemberExpr>(IDExpr)) {
9765 if (
const auto *VD = ME->getMemberDecl())
9767 return VD->getType();
9768 }
else if (
const auto *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
9769 return IR->getDecl()->getType();
9770 }
else if (
const auto *PR = dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {
9771 if (PR->isExplicitProperty())
9772 return PR->getExplicitProperty()->getType();
9773 }
else if (
const auto *PE = dyn_cast<PredefinedExpr>(IDExpr)) {
9774 return PE->getType();
9785 if (
auto *DRE = dyn_cast<DeclRefExpr>(IDExpr->
IgnoreParens())) {
9786 if (
auto *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
9789 return Context.getLValueReferenceType(
T);
9794 return Context.getReferenceQualifiedType(E);
9806 Diag(E->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
9819 Diag(Loc, diag::err_expected_name_of_pack) << Pattern;
9825 : diag::ext_pack_indexing);
9832 bool FullySubstituted,
9843 IndexExpr = Res.
get();
9844 int64_t
V =
Value.getExtValue();
9845 if (FullySubstituted && (
V < 0 || V >= int64_t(Expansions.size()))) {
9847 <<
V << Pattern << Expansions.size();
9850 Index =
static_cast<unsigned>(
V);
9853 return Context.getPackIndexingType(Pattern, IndexExpr, FullySubstituted,
9859 assert(BaseType->isEnumeralType());
9860 EnumDecl *ED = BaseType->castAs<EnumType>()->getDecl();
9865 if (Underlying.
isNull()) {
9871 assert(!Underlying.
isNull());
9879 if (!BaseType->isEnumeralType()) {
9880 Diag(Loc, diag::err_only_enums_have_underlying_types);
9887 if (BaseType->isIncompleteType(&FwdDecl)) {
9888 Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
9889 Diag(FwdDecl->
getLocation(), diag::note_forward_declaration) << FwdDecl;
9897 QualType Pointer = BaseType.isReferenceable() || BaseType->isVoidType()
9906 if (!BaseType->isAnyPointerType())
9915 return Context.getDecayedType(Underlying);
9924 Split.Quals.removeCVRQualifiers();
9925 return Context.getQualifiedType(Split);
9932 BaseType.isReferenceable()
9934 UKind == UnaryTransformType::AddLvalueReference,
9942 if (UKind == UnaryTransformType::RemoveAllExtents)
9943 return Context.getBaseElementType(BaseType);
9945 if (
const auto *AT =
Context.getAsArrayType(BaseType))
9946 return AT->getElementType();
9954 QualType T = BaseType.getNonReferenceType();
9955 if (UKind == UTTKind::RemoveCVRef &&
9956 (
T.isConstQualified() ||
T.isVolatileQualified())) {
9961 T =
Context.getQualifiedType(Unqual, Quals);
9968 if ((BaseType->isReferenceType() && UKind != UTTKind::RemoveRestrict) ||
9969 BaseType->isFunctionType())
9975 if (UKind == UTTKind::RemoveConst || UKind == UTTKind::RemoveCV)
9977 if (UKind == UTTKind::RemoveVolatile || UKind == UTTKind::RemoveCV)
9979 if (UKind == UTTKind::RemoveRestrict)
9982 return Context.getQualifiedType(Unqual, Quals);
9988 if (BaseType->isEnumeralType()) {
9990 if (
auto *
BitInt = dyn_cast<BitIntType>(Underlying)) {
9991 unsigned int Bits =
BitInt->getNumBits();
9995 S.
Diag(Loc, diag::err_make_signed_integral_only)
9996 << IsMakeSigned <<
true << BaseType << 1 << Underlying;
10000 S.
Diag(Loc, diag::err_make_signed_integral_only)
10001 << IsMakeSigned <<
false << BaseType << 1
10008 std::array<CanQualType *, 6> AllSignedIntegers = {
10012 AllSignedIntegers.data(), AllSignedIntegers.size() - Int128Unsupported);
10013 std::array<CanQualType *, 6> AllUnsignedIntegers = {
10018 AllUnsignedIntegers.size() -
10019 Int128Unsupported);
10021 IsMakeSigned ? &AvailableSignedIntegers : &AvailableUnsignedIntegers;
10025 llvm::find_if(*Consider, [&S, BaseSize](
const CanQual<Type> *
T) {
10029 assert(Result != Consider->end());
10030 return QualType((*Result)->getTypePtr(), 0);
10035 bool IsMakeSigned = UKind == UnaryTransformType::MakeSigned;
10036 if ((!BaseType->isIntegerType() && !BaseType->isEnumeralType()) ||
10037 BaseType->isBooleanType() ||
10038 (BaseType->isBitIntType() &&
10040 Diag(Loc, diag::err_make_signed_integral_only)
10041 << IsMakeSigned << BaseType->isBitIntType() << BaseType << 0;
10045 bool IsNonIntIntegral =
10046 BaseType->
isChar16Type() || BaseType->isChar32Type() ||
10047 BaseType->isWideCharType() || BaseType->isEnumeralType();
10052 : IsMakeSigned ?
Context.getCorrespondingSignedType(BaseType)
10053 :
Context.getCorrespondingUnsignedType(BaseType);
10054 if (Underlying.
isNull())
10061 if (BaseType->isDependentType())
10062 return Context.getUnaryTransformType(BaseType, BaseType, UKind);
10065 case UnaryTransformType::EnumUnderlyingType: {
10069 case UnaryTransformType::AddPointer: {
10073 case UnaryTransformType::RemovePointer: {
10077 case UnaryTransformType::Decay: {
10081 case UnaryTransformType::AddLvalueReference:
10082 case UnaryTransformType::AddRvalueReference: {
10086 case UnaryTransformType::RemoveAllExtents:
10087 case UnaryTransformType::RemoveExtent: {
10091 case UnaryTransformType::RemoveCVRef:
10092 case UnaryTransformType::RemoveReference: {
10096 case UnaryTransformType::RemoveConst:
10097 case UnaryTransformType::RemoveCV:
10098 case UnaryTransformType::RemoveRestrict:
10099 case UnaryTransformType::RemoveVolatile: {
10103 case UnaryTransformType::MakeSigned:
10104 case UnaryTransformType::MakeUnsigned: {
10122 int DisallowedKind = -1;
10123 if (
T->isArrayType())
10124 DisallowedKind = 1;
10125 else if (
T->isFunctionType())
10126 DisallowedKind = 2;
10127 else if (
T->isReferenceType())
10128 DisallowedKind = 3;
10129 else if (
T->isAtomicType())
10130 DisallowedKind = 4;
10131 else if (
T.hasQualifiers())
10132 DisallowedKind = 5;
10133 else if (
T->isSizelessType())
10134 DisallowedKind = 6;
10137 DisallowedKind = 7;
10138 else if (
T->isBitIntType())
10139 DisallowedKind = 8;
10142 DisallowedKind = 9;
10144 if (DisallowedKind != -1) {
10145 Diag(Loc, diag::err_atomic_specifier_bad_type) << DisallowedKind <<
T;
Defines the clang::ASTContext interface.
This file defines the classes used to store parsed information about declaration-specifiers and decla...
Defines the C++ template declaration subclasses.
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
Defines the clang::LangOptions interface.
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.
Defines the clang::Preprocessor interface.
static QualType getUnderlyingType(const SubRegion *R)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
This file declares semantic analysis for HLSL constructs.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
static void HandleNeonVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S, VectorKind VecKind)
HandleNeonVectorTypeAttr - The "neon_vector_type" and "neon_polyvector_type" attributes are used to c...
static QualType deduceOpenCLPointeeAddrSpace(Sema &S, QualType PointeeType)
static bool isPermittedNeonBaseType(QualType &Ty, VectorKind VecKind, Sema &S)
static void distributeObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType type)
Given that an objc_gc attribute was written somewhere on a declaration other than on the declarator i...
static void maybeSynthesizeBlockSignature(TypeProcessingState &state, QualType declSpecType)
Add a synthetic '()' to a block-literal declarator if it is required, given the return type.
#define MS_TYPE_ATTRS_CASELIST
#define CALLING_CONV_ATTRS_CASELIST
static void emitNullabilityConsistencyWarning(Sema &S, SimplePointerKind PointerKind, SourceLocation PointerLoc, SourceLocation PointerEndLoc)
static void fixItNullability(Sema &S, DiagBuilderT &Diag, SourceLocation PointerLoc, NullabilityKind Nullability)
Creates a fix-it to insert a C-style nullability keyword at pointerLoc, taking into account whitespac...
static ExprResult checkArraySize(Sema &S, Expr *&ArraySize, llvm::APSInt &SizeVal, unsigned VLADiag, bool VLAIsError)
Check whether the specified array bound can be evaluated using the relevant language rules.
static Attr * createNullabilityAttr(ASTContext &Ctx, ParsedAttr &Attr, NullabilityKind NK)
static void HandleVectorSizeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
HandleVectorSizeAttribute - this attribute is only applicable to integral and float scalars,...
static void inferARCWriteback(TypeProcessingState &state, QualType &declSpecType)
Given that this is the declaration of a parameter under ARC, attempt to infer attributes and such for...
static TypeSourceInfo * GetTypeSourceInfoForDeclarator(TypeProcessingState &State, QualType T, TypeSourceInfo *ReturnTypeInfo)
Create and instantiate a TypeSourceInfo with type source information.
static bool BuildAddressSpaceIndex(Sema &S, LangAS &ASIdx, const Expr *AddrSpace, SourceLocation AttrLoc)
Build an AddressSpace index from a constant expression and diagnose any errors related to invalid add...
static void HandleBTFTypeTagAttribute(QualType &Type, const ParsedAttr &Attr, TypeProcessingState &State)
static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, Qualifiers::ObjCLifetime ownership, unsigned chunkIndex)
static bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
handleObjCGCTypeAttr - Process the attribute((objc_gc)) type attribute on the specified type.
static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk)
static void HandleExtVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
Process the OpenCL-like ext_vector_type attribute when it occurs on a type.
static void HandleHLSLParamModifierAttr(TypeProcessingState &State, QualType &CurType, const ParsedAttr &Attr, Sema &S)
static void HandleLifetimeBoundAttr(TypeProcessingState &State, QualType &CurType, ParsedAttr &Attr)
static bool handleArmStateAttribute(Sema &S, FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr, FunctionType::ArmStateValue State)
static bool handleArmAgnosticAttribute(Sema &S, FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr)
static void distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType, CUDAFunctionTarget CFT)
A function type attribute was written in the decl spec.
static bool handleObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
static QualType inferARCLifetimeForPointee(Sema &S, QualType type, SourceLocation loc, bool isReference)
Given that we're building a pointer or reference to the given.
static bool handleNonBlockingNonAllocatingTypeAttr(TypeProcessingState &TPState, ParsedAttr &PAttr, QualType &QT, FunctionTypeUnwrapper &Unwrapped)
static QualType ChangeIntegralSignedness(Sema &S, QualType BaseType, bool IsMakeSigned, SourceLocation Loc)
static bool CheckNullabilityTypeSpecifier(Sema &S, TypeProcessingState *State, ParsedAttr *PAttr, QualType &QT, NullabilityKind Nullability, SourceLocation NullabilityLoc, bool IsContextSensitive, bool AllowOnArrayType, bool OverrideExisting)
#define OBJC_POINTER_TYPE_ATTRS_CASELIST
static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr, QualType type)
diagnoseBadTypeAttribute - Diagnoses a type attribute which doesn't apply to the given type.
static PointerDeclaratorKind classifyPointerDeclarator(Sema &S, QualType type, Declarator &declarator, PointerWrappingDeclaratorKind &wrappingKind)
Classify the given declarator, whose type-specified is type, based on what kind of pointer it refers ...
static bool verifyValidIntegerConstantExpr(Sema &S, const ParsedAttr &Attr, llvm::APSInt &Result)
static void HandleSwiftAttr(TypeProcessingState &State, TypeAttrLocation TAL, QualType &QT, ParsedAttr &PAttr)
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 void HandleLifetimeCaptureByAttr(TypeProcessingState &State, QualType &CurType, ParsedAttr &PA)
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 void fillHLSLAttributedResourceTypeLoc(HLSLAttributedResourceTypeLoc TL, TypeProcessingState &State)
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 void HandlePtrAuthQualifier(ASTContext &Ctx, QualType &T, const ParsedAttr &Attr, Sema &S)
Handle the __ptrauth qualifier.
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 bool CheckBitIntElementType(Sema &S, SourceLocation AttrLoc, const BitIntType *BIT, bool ForMatrixType=false)
static void checkExtParameterInfos(Sema &S, ArrayRef< QualType > paramTypes, const FunctionProtoType::ExtProtoInfo &EPI, llvm::function_ref< SourceLocation(unsigned)> getParamLoc)
Check the extended parameter information.
static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type, CUDAFunctionTarget CFT)
Process an individual function attribute.
static void transferARCOwnershipToDeclSpec(Sema &S, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership)
static void BuildTypeCoupledDecls(Expr *E, llvm::SmallVectorImpl< TypeCoupledDeclRefInfo > &Decls)
static void assignInheritanceModel(Sema &S, CXXRecordDecl *RD)
Locks in the inheritance model for the given class and all of its bases.
static bool checkObjCKindOfType(TypeProcessingState &state, QualType &type, ParsedAttr &attr)
Check the application of the Objective-C '__kindof' qualifier to the given type.
static bool hasNullabilityAttr(const ParsedAttributesView &attrs)
Check whether there is a nullability attribute of any kind in the given attribute list.
static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
handleObjCOwnershipTypeAttr - Process an objc_ownership attribute on the specified type.
static void moveAttrFromListToList(ParsedAttr &attr, ParsedAttributesView &fromList, ParsedAttributesView &toList)
static void HandleAnnotateTypeAttr(TypeProcessingState &State, QualType &CurType, const ParsedAttr &PA)
static void fillAttributedTypeLoc(AttributedTypeLoc TL, TypeProcessingState &State)
static void fillDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc DASTL, const ParsedAttributesView &Attrs)
TypeAttrLocation
The location of a type attribute.
@ TAL_DeclChunk
The attribute is part of a DeclaratorChunk.
@ TAL_DeclSpec
The attribute is in the decl-specifier-seq.
@ TAL_DeclName
The attribute is immediately after the declaration's name.
static bool isOmittedBlockReturnType(const Declarator &D)
isOmittedBlockReturnType - Return true if this declarator is missing a return type because this is a ...
static TypeSourceInfo * GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo)
static QualType GetEnumUnderlyingType(Sema &S, QualType BaseType, SourceLocation Loc)
static bool IsNoDerefableChunk(const DeclaratorChunk &Chunk)
static AttrT * createSimpleAttr(ASTContext &Ctx, ParsedAttr &AL)
static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy, Declarator &D, unsigned FunctionChunkIndex)
static void processTypeAttrs(TypeProcessingState &state, QualType &type, TypeAttrLocation TAL, const ParsedAttributesView &attrs, CUDAFunctionTarget CFT=CUDAFunctionTarget::HostDevice)
static bool checkMutualExclusion(TypeProcessingState &state, const FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr, AttributeCommonInfo::Kind OtherKind)
static Attr * getCCTypeAttr(ASTContext &Ctx, ParsedAttr &Attr)
Defines the clang::SourceLocation class and associated facilities.
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
__DEVICE__ int max(int __a, int __b)
virtual void 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
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 Attr *attr=nullptr) const
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 getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current context.
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const
Get a function type and produce the equivalent function type with the specified exception specificati...
CanQualType UnsignedLongTy
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
LangAS getDefaultOpenCLPointeeAddrSpace()
Returns default address space based on OpenCL version and enabled features.
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
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false, TemplateDecl *TypeConstraintConcept=nullptr, ArrayRef< TemplateArgument > TypeConstraintArgs={}) const
C++11 deduced auto type.
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.
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
DiagnosticsEngine & getDiagnostics() const
QualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
const TargetInfo & getTargetInfo() 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 ...
CanQualType getCanonicalTagType(const TagDecl *TD) const
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const
Return the uniqued reference to the type for an Objective-C gc-qualified type.
QualType getPointerAuthType(QualType Ty, PointerAuthQualifier PointerAuth)
Return a type with the given __ptrauth qualifier.
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.
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, AttributeScopeInfo scope, 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)
bool hasExplicitTemplateArgs() const
const NestedNameSpecifierLoc getNestedNameSpecifierLoc() const
SourceLocation getRAngleLoc() const
SourceLocation getLAngleLoc() const
void setConceptReference(ConceptReference *CR)
NamedDecl * getFoundDecl() const
TemplateArgumentLoc getArgLoc(unsigned i) const
unsigned getNumArgs() const
TemplateDecl * getNamedConcept() const
DeclarationNameInfo getConceptNameInfo() const
void setRParenLoc(SourceLocation Loc)
TypeLoc getWrappedLoc() const
Comparison function object.
A fixed int type of a specified bitwidth.
unsigned getNumBits() const
void setCaretLoc(SourceLocation Loc)
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.
CXXRecordDecl * getMostRecentDecl()
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]).
Represents a C++ nested-name-specifier or a global scope specifier.
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.
NestedNameSpecifier getScopeRep() const
Retrieve the representation of the nested-name-specifier.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
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.
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, TemplateDecl *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...
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
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.
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
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)
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 setNameLoc(SourceLocation Loc)
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
bool getSuppressSystemWarnings() const
Wrap a function effect's condition expression in another struct so that FunctionProtoType's TrailingO...
void set(SourceLocation ElaboratedKeywordLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation NameLoc)
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
EnumDecl * getDefinition() const
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.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
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...
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.
unsigned getSpellingLineNumber(bool *Invalid=nullptr) const
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration.
A mutable set of FunctionEffects and possibly conditions attached to them.
bool insert(const FunctionEffectWithCondition &NewEC, Conflicts &Errs)
SmallVector< Conflict > Conflicts
Represents an abstract function effect, using just an enumeration describing its kind.
Kind
Identifies the particular effect.
An immutable set of FunctionEffects and possibly conditions attached to them.
Represents a prototype with parameter type info, e.g.
Qualifiers getMethodQuals() const
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
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)
AArch64SMETypeAttributes
The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number of function type attributes that...
@ SME_PStateSMEnabledMask
@ SME_PStateSMCompatibleMask
@ SME_AgnosticZAStateMask
static ArmStateValue getArmZT0State(unsigned AttrBits)
static ArmStateValue getArmZAState(unsigned AttrBits)
CallingConv getCallConv() const
QualType getReturnType() const
bool getHasRegParm() const
Type source information for HLSL attributed resource type.
TypeLoc getWrappedLoc() const
void setContainedTypeSourceInfo(TypeSourceInfo *TSI) const
void setSourceRange(const SourceRange &R)
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.
A simple pair of identifier info and location.
void setIdentifierInfo(IdentifierInfo *Ident)
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
ElaboratedTypeKeyword getKeyword() const
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 allowArrayReturnTypes() const
bool isTargetDevice() const
True when compiling for an offloading target device.
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:
void setStarLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
A pointer to member type per C++ 8.3.3 - Pointers to members.
NestedNameSpecifier getQualifier() const
CXXRecordDecl * getMostRecentCXXRecordDecl() const
Note: this can trigger extra deserialization when external AST sources are used.
QualType getPointeeType() const
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.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
NamespaceAndPrefix getAsNamespaceAndPrefix() const
const Type * getAsType() const
@ Global
The global specifier '::'. There is no stored value.
@ Type
A type, stored as a Type*.
@ Namespace
A namespace-like entity, stored as a NamespaceBaseDecl*.
Represents an ObjC class declaration.
void setNameLoc(SourceLocation Loc)
void setNameEndLoc(SourceLocation Loc)
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
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.
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.
ParsedAttr - Represents a syntactic attribute.
void setInvalid(bool b=true) const
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this attribute.
bool isArgIdent(unsigned Arg) const
Expr * getArgAsExpr(unsigned Arg) const
AttributeCommonInfo::Kind getKind() const
void setUsedAsTypeAttr(bool Used=true)
bool checkAtMostNumArgs(class Sema &S, unsigned Num) const
Check if the attribute has at most as many args as Num.
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)
Pointer-authentication qualifiers.
static PointerAuthQualifier Create(unsigned Key, bool IsAddressDiscriminated, unsigned ExtraDiscriminator, PointerAuthenticationMode AuthenticationMode, bool IsIsaPointer, bool AuthenticatesNullValues)
@ MaxKey
The maximum supported pointer-authentication key.
void setStarLoc(SourceLocation Loc)
PointerType - C99 6.7.5.1 - Pointer Declarators.
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.
PointerAuthQualifier getPointerAuth() const
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.
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.
UnqualTypeLoc getUnqualifiedLoc() const
The collection of all-type qualifiers we support.
void removeCVRQualifiers(unsigned mask)
void addAddressSpace(LangAS space)
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
void removeObjCLifetime()
void addCVRUQualifiers(unsigned mask)
static Qualifiers fromCVRMask(unsigned CVR)
void setUnaligned(bool flag)
std::string getAsString() const
@ MaxAddressSpace
The maximum supported address space number.
void addObjCLifetime(ObjCLifetime type)
void setAmpAmpLoc(SourceLocation Loc)
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)
Emit a diagnostic.
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
QualType ProcessResourceTypeAttributes(QualType Wrapped)
QualType getInoutParameterType(QualType Ty)
bool isCFError(RecordDecl *D)
IdentifierInfo * getNSErrorIdent()
Retrieve the identifier "NSError".
bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type)
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....
UnaryTransformType::UTTKind UTTKind
QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace, SourceLocation AttrLoc)
BuildAddressSpaceAttr - Builds a DependentAddressSpaceType if an expression is uninstantiated.
bool checkPointerAuthDiscriminatorArg(Expr *Arg, PointerAuthDiscArgKind Kind, unsigned &IntVal)
QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc)
std::optional< FunctionEffectMode > ActOnEffectExpression(Expr *CondExpr, StringRef AttributeName)
Try to parse the conditional expression attached to an effect attribute (e.g.
@ AcceptSizeless
Relax the normal rules for complete types so that they include sizeless built-in types.
class clang::Sema::DelayedDiagnostics DelayedDiagnostics
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)
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain, bool PrimaryStrictPackMatch)
QualType BuildFunctionType(QualType T, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc, DeclarationName Entity, const FunctionProtoType::ExtProtoInfo &EPI)
Build a function type.
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, TrivialABIHandling TAH=TrivialABIHandling::IgnoreTrivialABI, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
void checkSpecializationReachability(SourceLocation Loc, NamedDecl *Spec)
ASTContext & getASTContext() const
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
void checkExceptionSpecification(bool IsTopLevel, ExceptionSpecificationType EST, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr, SmallVectorImpl< QualType > &Exceptions, FunctionProtoType::ExceptionSpecInfo &ESI)
Check the given exception-specification and update the exception specification information with the r...
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC, const FunctionDecl *FD=nullptr, CUDAFunctionTarget CFT=CUDAFunctionTarget::InvalidTarget)
Check validaty of calling convention attribute attr.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
QualType BuildCountAttributedArrayOrPointerType(QualType WrappedTy, Expr *CountExpr, bool CountInBytes, bool OrNull)
std::string getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const
Get a string to suggest for zero-initialization of a type.
bool CheckAttrNoArgs(const ParsedAttr &CurrAttr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
QualType BuildBitIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc)
Build a bit-precise integer type.
LangAS getDefaultCXXMethodAddrSpace() const
Returns default addr space for method qualifiers.
QualType BuiltinRemoveReference(QualType BaseType, UTTKind UKind, SourceLocation Loc)
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
bool CheckFunctionReturnType(QualType T, SourceLocation Loc)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_TypeConstraint
A type constraint.
const LangOptions & getLangOpts() const
bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type of the given expression is complete.
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
QualType BuiltinEnumUnderlyingType(QualType BaseType, SourceLocation Loc)
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
const LangOptions & LangOpts
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
IdentifierInfo * InventAbbreviatedTemplateParameterTypeName(const IdentifierInfo *ParamName, unsigned Index)
Invent a new identifier for parameters of abbreviated templates.
bool checkConstantPointerAuthKey(Expr *keyExpr, unsigned &key)
SourceLocation ImplicitMSInheritanceAttrLoc
Source location for newly created implicit MSInheritanceAttrs.
SmallVector< InventedTemplateParameterInfo, 4 > InventedParameterInfos
Stack containing information needed when in C++2a an 'auto' is encountered in a function declaration ...
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
void completeExprArrayBound(Expr *E)
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...
QualType BuildMemberPointerType(QualType T, const CXXScopeSpec &SS, CXXRecordDecl *Cls, SourceLocation Loc, DeclarationName Entity)
Build a member pointer type T Class::*.
ExprResult DefaultLvalueConversion(Expr *E)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
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, bool ForDefaultArgumentSubstitution=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
QualType BuiltinDecay(QualType BaseType, SourceLocation Loc)
IdentifierInfo * getNullabilityKeyword(NullabilityKind nullability)
Retrieve the keyword associated.
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...
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, TemplateDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
bool diagnoseConflictingFunctionEffect(const FunctionEffectsRef &FX, const FunctionEffectWithCondition &EC, SourceLocation NewAttrLoc)
Warn and return true if adding a function effect to a set would create a conflict.
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 CheckAttrTarget(const ParsedAttr &CurrAttr)
QualType BuiltinAddPointer(QualType BaseType, SourceLocation Loc)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=AllowFoldKind::No)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
IntrusiveRefCntPtr< ExternalSemaSource > ExternalSource
Source of additional semantic information.
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...
bool checkStringLiteralArgumentAttr(const AttributeCommonInfo &CI, const Expr *E, StringRef &Str, SourceLocation *ArgLocation=nullptr)
Check if the argument E is a ASCII string literal.
QualType BuildBlockPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a block pointer type.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Information about a FileID, basically just the logical file that it represents and include stack info...
CharacteristicKind getFileCharacteristic() const
Return whether this is a system header or not.
SourceLocation getIncludeLoc() const
This is a discriminated union of FileInfo and ExpansionInfo.
const FileInfo & getFile() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
Represents the declaration of a struct/union/class/enum.
void setEmbeddedInDeclarator(bool isInDeclarator)
True if this tag declaration is "embedded" (i.e., defined or declared for the very first time) in the...
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool isThisDeclarationADemotedDefinition() const
Whether this declaration was a definition in some module but was forced to be a declaration.
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
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
virtual std::optional< std::pair< unsigned, unsigned > > getVScaleRange(const LangOptions &LangOpts, ArmStreamingKind Mode, llvm::StringMap< bool > *FeatureMap=nullptr) const
Returns target-specific min and max values VScale_Range.
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.
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.
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.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
ArrayRef< TemplateArgumentLoc > arguments() const
Location wrapper for a TemplateArgument.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) 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, UnsignedOrNone 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 isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
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 isIncompleteArrayType() const
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isUndeducedAutoType() const
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
CXXRecordDecl * castAsCXXRecordDecl() const
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
NestedNameSpecifier getPrefix() const
If this type represents a qualified-id, this returns its nested name specifier.
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.
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
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
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 isObjCObjectType() const
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
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 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.
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 ...
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< Type > type
Matches Types in the clang AST.
const internal::VariadicDynCastAllOfMatcher< Decl, RecordDecl > recordDecl
Matches class, struct, and union declarations.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
The JSON file list parser is used to communicate input to InstallAPI.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
bool isa(CodeGen::Address addr)
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
@ ExpectedParameterOrImplicitObjectParameter
@ ExpectedFunctionWithProtoType
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
@ GNUAutoType
__auto_type (GNU extension)
@ DecltypeAuto
decltype(auto)
llvm::StringRef getParameterABISpelling(ParameterABI kind)
FunctionEffectMode
Used with attributes/effects with a boolean condition, e.g. nonblocking.
LLVM_READONLY bool isAsciiIdentifierContinue(unsigned char c)
NullabilityKind
Describes the nullability of a particular type.
@ Nullable
Values of this type can be null.
@ Unspecified
Whether values of this type can be null is (explicitly) unspecified.
@ NonNull
Values of this type can never be null.
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
llvm::PointerUnion< Expr *, IdentifierLoc * > ArgsUnion
A union of the various pointer types that can be passed to an ParsedAttr as an argument.
@ Success
Annotation was successful.
@ TemplateName
The identifier is a template name. FIXME: Add an annotation for that.
@ 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.
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword.
@ AANT_ArgumentIntegerConstant
@ Result
The result type of a method or function.
ActionResult< ParsedType > TypeResult
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.
const FunctionProtoType * T
bool supportsVariadicCall(CallingConv CC)
Checks whether the given calling convention supports variadic calls.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
static bool isBlockPointer(Expr *Arg)
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',...
@ Keyword
The name has been typo-corrected to a keyword.
@ Type
The name was classified as a type.
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ FirstTargetAddressSpace
MutableArrayRef< ParsedTemplateArgument > ASTTemplateArgsPtr
MSInheritanceModel
Assigned inheritance model for a class in the MS C++ ABI.
@ IgnoreTrivialABI
The triviality of a method unaffected by "trivial_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.
@ AltiVecBool
is AltiVec 'vector bool ...'
@ SveFixedLengthData
is AArch64 SVE fixed-length data vector
@ AltiVecVector
is AltiVec vector
@ AltiVecPixel
is AltiVec 'vector Pixel'
@ Generic
not a target-specific vector type
@ RVVFixedLengthData
is RISC-V RVV fixed-length data vector
@ RVVFixedLengthMask
is RISC-V RVV fixed-length mask vector
@ NeonPoly
is ARM Neon polynomial vector
@ SveFixedLengthPredicate
is AArch64 SVE fixed-length predicate vector
U cast(CodeGen::Address addr)
LangAS getLangASFromTargetAS(unsigned TargetAS)
@ None
The alignment was not explicit in code.
@ ArrayBound
Array bound in array declarator or new-expression.
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
ActionResult< Expr * > ExprResult
@ Parens
New-expression has a C++98 paren-delimited initializer.
@ EST_DependentNoexcept
noexcept(expression), value-dependent
@ EST_Uninstantiated
not instantiated yet
@ EST_Unparsed
not parsed yet
@ EST_NoThrow
Microsoft __declspec(nothrow) extension.
@ EST_None
no exception specification
@ EST_MSAny
Microsoft throw(...) extension.
@ EST_BasicNoexcept
noexcept
@ EST_NoexceptFalse
noexcept(expression), evals to 'false'
@ EST_Unevaluated
not evaluated yet, for special member function
@ EST_NoexceptTrue
noexcept(expression), evals to 'true'
@ EST_Dynamic
throw(T1, T2)
@ Implicit
An implicit conversion.
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
unsigned isStar
True if this dimension was [*]. In this case, NumElts is null.
unsigned TypeQuals
The type qualifiers for the array: const/volatile/restrict/__unaligned/_Atomic.
unsigned hasStatic
True if this dimension included the 'static' keyword.
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
unsigned TypeQuals
For now, sema will catch these as invalid.
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with ',...)',...
SourceLocation getTrailingReturnTypeLoc() const
Get the trailing-return-type location for this function declarator.
SourceLocation getLParenLoc() const
bool hasTrailingReturnType() const
Determine whether this function declarator had a trailing-return-type.
TypeAndRange * Exceptions
Pointer to a new[]'d array of TypeAndRange objects that contain the types in the function's dynamic e...
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
ParsedType getTrailingReturnType() const
Get the trailing-return-type for this function declarator.
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
SourceLocation getExceptionSpecLocBeg() const
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
SourceLocation getRParenLoc() const
SourceLocation getEllipsisLoc() const
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
unsigned getNumExceptions() const
Get the number of dynamic exception specifications.
bool hasMethodTypeQualifiers() const
Determine whether this method has qualifiers.
unsigned isAmbiguous
Can this declaration be a constructor-style initializer?
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
SourceRange getExceptionSpecRange() const
ExceptionSpecificationType getExceptionSpecType() const
Get the type of exception specification this function has.
Expr * NoexceptExpr
Pointer to the expression in the noexcept-specifier of this function, if it has one.
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
SourceLocation StarLoc
Location of the '*' token.
const IdentifierInfo * Ident
SourceLocation RestrictQualLoc
The location of the restrict-qualifier, if any.
SourceLocation ConstQualLoc
The location of the const-qualifier, if any.
SourceLocation VolatileQualLoc
The location of the volatile-qualifier, if any.
SourceLocation UnalignedQualLoc
The location of the __unaligned-qualifier, if any.
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/unaligned/atomic.
SourceLocation AtomicQualLoc
The location of the _Atomic-qualifier, if any.
bool LValueRef
True if this is an lvalue reference, false if it's an rvalue reference.
bool HasRestrict
The type qualifier: restrict. [GNU] C++ extension.
One instance of this struct is used for each type in a declarator that is parsed.
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
SourceLocation EndLoc
EndLoc - If valid, the place where this chunck ends.
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), SourceLocation TrailingReturnTypeLoc=SourceLocation(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
MemberPointerTypeInfo Mem
SourceLocation Loc
Loc - The place where this type was defined.
enum clang::DeclaratorChunk::@340323374315200305336204205154073066142310370142 Kind
Describes whether we've seen any nullability information for the given file.
SourceLocation PointerEndLoc
The end location for the first pointer declarator in the file.
SourceLocation PointerLoc
The first pointer declarator (of any pointer kind) in the file that does not have a corresponding nul...
bool SawTypeNullability
Whether we saw any type nullability annotations in the given file.
uint8_t PointerKind
Which kind of pointer declarator we saw.
A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e....
Holds information about the various types of exception specification.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
FunctionTypeExtraAttributeInfo ExtraAttributeInfo
unsigned AArch64SMEAttributes
SourceLocation EllipsisLoc
FunctionEffectsRef FunctionEffects
const ExtParameterInfo * ExtParameterInfos
RefQualifierKind RefQualifier
unsigned HasTrailingReturn
void setArmSMEAttribute(AArch64SMETypeAttributes Kind, bool Enable=true)
FunctionType::ExtInfo ExtInfo
TypeSourceInfo * ContainedTyInfo
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...
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
NestedNameSpecifier Prefix
Describes how types, statements, expressions, and declarations should be printed.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
enum clang::Sema::CodeSynthesisContext::SynthesisKind Kind
@ 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.
llvm::DenseSet< std::tuple< Decl *, Decl *, int > > NonEquivalentDeclSet
Store declaration pairs already found to be non-equivalent.
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.