39#include "llvm/ADT/ArrayRef.h"
40#include "llvm/ADT/SmallPtrSet.h"
41#include "llvm/ADT/SmallString.h"
42#include "llvm/ADT/StringExtras.h"
43#include "llvm/IR/DerivedTypes.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/ErrorHandling.h"
60 if (D.
getContext() != DeclaratorContext::BlockLiteral ||
79 bool useExpansionLoc =
true;
80 switch (
attr.getKind()) {
81 case ParsedAttr::AT_ObjCGC:
84 case ParsedAttr::AT_ObjCOwnership:
90 useExpansionLoc =
false;
95 StringRef name =
attr.getAttrName()->getName();
100 if (useExpansionLoc && loc.
isMacroID() && II) {
101 if (II->
isStr(
"strong")) {
103 }
else if (II->
isStr(
"weak")) {
108 S.
Diag(loc,
attr.isRegularKeywordAttribute()
109 ? diag::err_type_attribute_wrong_type
110 : diag::warn_type_attribute_wrong_type)
111 << name << WhichType <<
type;
116#define OBJC_POINTER_TYPE_ATTRS_CASELIST \
117 case ParsedAttr::AT_ObjCGC: \
118 case ParsedAttr::AT_ObjCOwnership
121#define CALLING_CONV_ATTRS_CASELIST \
122 case ParsedAttr::AT_CDecl: \
123 case ParsedAttr::AT_FastCall: \
124 case ParsedAttr::AT_StdCall: \
125 case ParsedAttr::AT_ThisCall: \
126 case ParsedAttr::AT_RegCall: \
127 case ParsedAttr::AT_Pascal: \
128 case ParsedAttr::AT_SwiftCall: \
129 case ParsedAttr::AT_SwiftAsyncCall: \
130 case ParsedAttr::AT_VectorCall: \
131 case ParsedAttr::AT_AArch64VectorPcs: \
132 case ParsedAttr::AT_AArch64SVEPcs: \
133 case ParsedAttr::AT_AMDGPUKernelCall: \
134 case ParsedAttr::AT_MSABI: \
135 case ParsedAttr::AT_SysVABI: \
136 case ParsedAttr::AT_Pcs: \
137 case ParsedAttr::AT_IntelOclBicc: \
138 case ParsedAttr::AT_PreserveMost: \
139 case ParsedAttr::AT_PreserveAll: \
140 case ParsedAttr::AT_M68kRTD: \
141 case ParsedAttr::AT_PreserveNone
144#define FUNCTION_TYPE_ATTRS_CASELIST \
145 case ParsedAttr::AT_NSReturnsRetained: \
146 case ParsedAttr::AT_NoReturn: \
147 case ParsedAttr::AT_Regparm: \
148 case ParsedAttr::AT_CmseNSCall: \
149 case ParsedAttr::AT_ArmStreaming: \
150 case ParsedAttr::AT_ArmStreamingCompatible: \
151 case ParsedAttr::AT_ArmPreserves: \
152 case ParsedAttr::AT_ArmIn: \
153 case ParsedAttr::AT_ArmOut: \
154 case ParsedAttr::AT_ArmInOut: \
155 case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: \
156 case ParsedAttr::AT_AnyX86NoCfCheck: \
157 CALLING_CONV_ATTRS_CASELIST
160#define MS_TYPE_ATTRS_CASELIST \
161 case ParsedAttr::AT_Ptr32: \
162 case ParsedAttr::AT_Ptr64: \
163 case ParsedAttr::AT_SPtr: \
164 case ParsedAttr::AT_UPtr
167#define NULLABILITY_TYPE_ATTRS_CASELIST \
168 case ParsedAttr::AT_TypeNonNull: \
169 case ParsedAttr::AT_TypeNullable: \
170 case ParsedAttr::AT_TypeNullableResult: \
171 case ParsedAttr::AT_TypeNullUnspecified
176 class TypeProcessingState {
200 using TypeAttrPair = std::pair<const AttributedType*, const Attr*>;
202 bool AttrsForTypesSorted =
true;
206 llvm::DenseMap<const MacroQualifiedType *, SourceLocation> LocsForMacros;
214 : sema(sema), declarator(declarator),
217 Sema &getSema()
const {
225 bool isProcessingDeclSpec()
const {
229 unsigned getCurrentChunkIndex()
const {
233 void setCurrentChunkIndex(
unsigned idx) {
239 if (isProcessingDeclSpec())
240 return getMutableDeclSpec().getAttributes();
245 void saveDeclSpecAttrs() {
247 if (!savedAttrs.empty())
250 DeclSpec &spec = getMutableDeclSpec();
251 llvm::append_range(savedAttrs,
258 ignoredTypeAttrs.push_back(&
attr);
264 for (
auto *
Attr : ignoredTypeAttrs)
274 AttrsForTypes.push_back({cast<AttributedType>(T.
getTypePtr()), A});
275 AttrsForTypesSorted =
false;
280 QualType getBTFTagAttributedType(
const BTFTypeTagAttr *BTFAttr,
292 auto *NewAttrTy = cast<AttributedType>(T.
getTypePtr());
293 for (TypeAttrPair &A : AttrsForTypes) {
294 if (A.first == AttrTy)
297 AttrsForTypesSorted =
false;
304 if (!AttrsForTypesSorted) {
305 llvm::stable_sort(AttrsForTypes, llvm::less_first());
306 AttrsForTypesSorted =
true;
311 for (
auto It = std::partition_point(
312 AttrsForTypes.begin(), AttrsForTypes.end(),
313 [=](
const TypeAttrPair &A) { return A.first < AT; });
314 It != AttrsForTypes.end() && It->first == AT; ++It) {
316 const Attr *Result = It->second;
317 It->second =
nullptr;
322 llvm_unreachable(
"no Attr* for AttributedType*");
327 auto FoundLoc = LocsForMacros.find(MQT);
328 assert(FoundLoc != LocsForMacros.end() &&
329 "Unable to find macro expansion location for MacroQualifedType");
330 return FoundLoc->second;
335 LocsForMacros[MQT] = Loc;
338 void setParsedNoDeref(
bool parsed) { parsedNoDeref = parsed; }
340 bool didParseNoDeref()
const {
return parsedNoDeref; }
342 ~TypeProcessingState() {
343 if (savedAttrs.empty())
346 getMutableDeclSpec().getAttributes().clearListOnly();
348 getMutableDeclSpec().getAttributes().addAtEnd(AL);
352 DeclSpec &getMutableDeclSpec()
const {
395 if (
attr.getKind() == ParsedAttr::AT_ObjCGC)
397 assert(
attr.getKind() == ParsedAttr::AT_ObjCOwnership);
412 bool onlyBlockPointers) {
418 for (; i != 0; --i) {
420 switch (fnChunk.
Kind) {
436 for (--i; i != 0; --i) {
438 switch (ptrChunk.
Kind) {
448 if (onlyBlockPointers)
457 llvm_unreachable(
"bad declarator chunk kind");
463 llvm_unreachable(
"bad declarator chunk kind");
480 Declarator &declarator = state.getDeclarator();
483 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
485 switch (chunk.
Kind) {
491 if (state.isProcessingDeclSpec() &&
492 attr.getKind() == ParsedAttr::AT_ObjCOwnership)
495 if (!destChunk) destChunk = &chunk;
508 if (state.isProcessingDeclSpec() &&
509 attr.getKind() == ParsedAttr::AT_ObjCOwnership) {
536 Declarator &declarator = state.getDeclarator();
540 unsigned innermost = -1U;
541 bool considerDeclSpec =
true;
544 switch (chunk.
Kind) {
558 considerDeclSpec =
false;
566 if (considerDeclSpec) {
571 state.saveDeclSpecAttrs();
580 if (innermost != -1U) {
588 state.addIgnoredTypeAttr(
attr);
597 Declarator &declarator = state.getDeclarator();
601 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
603 switch (chunk.
Kind) {
630 Declarator &declarator = state.getDeclarator();
650 state.saveDeclSpecAttrs();
654 state,
attr, state.getCurrentAttributes(), declSpecType, CFT))
659 state.addIgnoredTypeAttr(
attr);
669 Declarator &declarator = state.getDeclarator();
679 state.addIgnoredTypeAttr(
attr);
704 if (
attr.isStandardAttributeSyntax() ||
attr.isRegularKeywordAttribute())
707 switch (
attr.getKind()) {
724 case ParsedAttr::AT_ObjCKindOf:
737 Declarator &declarator = state.getDeclarator();
783 std::nullopt, loc, loc, declarator));
798 typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc;
803 if (!(RemoveTQs & Qual.first))
807 if (TypeQuals & Qual.first)
808 S.
Diag(Qual.second, DiagID)
813 TypeQuals &= ~Qual.first;
827 if (AL.isInvalid() || !AL.isTypeAttr())
830 diag::warn_block_literal_attributes_on_omitted_return_type)
832 ToBeRemoved.push_back(&AL);
842 diag::warn_block_literal_qualifiers_on_omitted_return_type);
855 if (!objcObjectType || !objcObjectType->getInterface()) {
856 S.
Diag(loc, diag::err_objc_type_args_non_class)
869 S.
Diag(loc, diag::err_objc_type_args_non_parameterized_class)
880 if (objcObjectType->isSpecialized()) {
881 S.
Diag(loc, diag::err_objc_type_args_specialized_class)
893 unsigned numTypeParams = typeParams->
size();
894 bool anyPackExpansions =
false;
895 for (
unsigned i = 0, n = typeArgs.size(); i != n; ++i) {
903 bool diagnosed =
false;
906 rangeToRemove =
attr.getLocalSourceRange();
907 if (
attr.getTypePtr()->getImmediateNullability()) {
908 typeArg =
attr.getTypePtr()->getModifiedType();
910 diag::err_objc_type_arg_explicit_nullability)
918 if (!rebuilding && !diagnosed) {
919 S.
Diag(qual.getBeginLoc(), diag::err_objc_type_arg_qualified)
928 finalTypeArgs.push_back(typeArg);
931 anyPackExpansions =
true;
935 if (!anyPackExpansions) {
936 if (i < numTypeParams) {
937 typeParam = typeParams->
begin()[i];
940 S.
Diag(loc, diag::err_objc_type_args_wrong_arity)
961 assert(anyPackExpansions &&
"Too many arguments?");
970 if (typeArgObjC->isObjCIdType()) {
973 if (boundObjC->isObjCIdType())
982 diag::err_objc_type_arg_does_not_match_bound)
999 assert(anyPackExpansions &&
"Too many arguments?");
1010 diag::err_objc_type_arg_does_not_match_bound)
1028 diag::err_objc_type_arg_not_id_compatible)
1038 if (!anyPackExpansions && finalTypeArgs.size() != numTypeParams) {
1039 S.
Diag(loc, diag::err_objc_type_args_wrong_arity)
1040 << (typeArgs.size() < typeParams->
size())
1064 if (!Protocols.empty()) {
1070 <<
SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
1073 if (FailOnError &&
Result.isNull())
1085 bool FailOnError,
bool Rebuilding) {
1087 if (!TypeArgs.empty()) {
1090 SourceRange(TypeArgsLAngleLoc, TypeArgsRAngleLoc),
1091 FailOnError, Rebuilding);
1092 if (FailOnError &&
Result.isNull())
1096 if (!Protocols.empty()) {
1101 Diag(Loc, diag::err_invalid_protocol_qualifiers)
1102 <<
SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
1105 if (FailOnError &&
Result.isNull())
1131 auto ObjCObjectTL = ObjCObjectPointerTL.getPointeeLoc()
1141 ObjCObjectTL.setProtocolLAngleLoc(lAngleLoc);
1142 ObjCObjectTL.setProtocolRAngleLoc(rAngleLoc);
1143 for (
unsigned i = 0, n = protocols.size(); i != n; ++i)
1144 ObjCObjectTL.setProtocolLoc(i, protocolLocs[i]);
1172 for (
unsigned i = 0, n = TypeArgs.size(); i != n; ++i) {
1176 ActualTypeArgInfos.clear();
1180 assert(TypeArgInfo &&
"No type source info?");
1181 ActualTypeArgInfos.push_back(TypeArgInfo);
1187 TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc,
1191 ProtocolLocs, ProtocolRAngleLoc,
1207 ResultTL = ObjCObjectPointerTL.getPointeeLoc();
1212 if (OTPTL.getNumProtocols() > 0) {
1213 assert(OTPTL.getNumProtocols() == Protocols.size());
1214 OTPTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1215 OTPTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1216 for (
unsigned i = 0, n = Protocols.size(); i != n; ++i)
1217 OTPTL.setProtocolLoc(i, ProtocolLocs[i]);
1227 if (ObjCObjectTL.getNumTypeArgs() > 0) {
1228 assert(ObjCObjectTL.getNumTypeArgs() == ActualTypeArgInfos.size());
1229 ObjCObjectTL.setTypeArgsLAngleLoc(TypeArgsLAngleLoc);
1230 ObjCObjectTL.setTypeArgsRAngleLoc(TypeArgsRAngleLoc);
1231 for (
unsigned i = 0, n = ActualTypeArgInfos.size(); i != n; ++i)
1232 ObjCObjectTL.setTypeArgTInfo(i, ActualTypeArgInfos[i]);
1239 if (ObjCObjectTL.getNumProtocols() > 0) {
1240 assert(ObjCObjectTL.getNumProtocols() == Protocols.size());
1241 ObjCObjectTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1242 ObjCObjectTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1243 for (
unsigned i = 0, n = Protocols.size(); i != n; ++i)
1244 ObjCObjectTL.setProtocolLoc(i, ProtocolLocs[i]);
1251 ObjCObjectTL.setHasBaseTypeAsWritten(
true);
1252 if (ObjCObjectTL.getType() == T)
1253 ObjCObjectTL.getBaseLoc().initializeFullCopy(BaseTypeInfo->
getTypeLoc());
1255 ObjCObjectTL.getBaseLoc().initialize(
Context, Loc);
1261static OpenCLAccessAttr::Spelling
1264 if (AL.getKind() == ParsedAttr::AT_OpenCLAccess)
1265 return static_cast<OpenCLAccessAttr::Spelling
>(AL.getSemanticSpelling());
1266 return OpenCLAccessAttr::Keyword_read_only;
1271 switch (SwitchTST) {
1272#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait) \
1274 return UnaryTransformType::Enum;
1275#include "clang/Basic/TransformTypeTraits.def"
1277 llvm_unreachable(
"attempted to parse a non-unary transform builtin");
1291 Sema &S = state.getSema();
1292 Declarator &declarator = state.getDeclarator();
1312 "Unknown TSS value");
1326 "Unknown TSS value");
1335 "Unknown TSS value");
1340 "Unknown TSS value");
1345 "Unknown TSS value");
1373 S.
Diag(DeclLoc, diag::warn_missing_type_specifier)
1382 S.
Diag(DeclLoc, diag::err_missing_type_specifier)
1391 S.
Diag(DeclLoc, diag::err_missing_actual_pipe_type)
1396 "implicit int is disabled?");
1397 S.
Diag(DeclLoc, diag::ext_missing_type_specifier)
1424 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1449 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1482 llvm_unreachable(
"Unable to specify long long as _Accum width");
1505 llvm_unreachable(
"Unable to specify long long as _Fract width");
1556 ?
"cl_khr_fp64 and __opencl_c_fp64"
1606 "No qualifiers on tag names!");
1622 "Can't handle qualifiers on typedef names yet!");
1635 assert(!
Result.isNull() &&
"Didn't get a type for typeof?");
1636 if (!
Result->isDependentType())
1648 assert(E &&
"Didn't get an expression for typeof?");
1662 assert(E &&
"Didn't get an expression for decltype?");
1673 assert(E &&
"Didn't get an expression for pack indexing");
1684#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
1685#include "clang/Basic/TransformTypeTraits.def"
1687 assert(!
Result.isNull() &&
"Didn't get a type for the transformation?");
1707 TypeConstraintConcept =
1708 cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl());
1713 TemplateId->NumArgs);
1715 for (
const auto &ArgLoc : TemplateArgsInfo.
arguments())
1716 TemplateArgs.push_back(ArgLoc.getArgument());
1723 TypeConstraintConcept, TemplateArgs);
1737 assert(!
Result.isNull() &&
"Didn't get a type for _Atomic?");
1745#define GENERIC_IMAGE_TYPE(ImgType, Id) \
1746 case DeclSpec::TST_##ImgType##_t: \
1747 switch (getImageAccess(DS.getAttributes())) { \
1748 case OpenCLAccessAttr::Keyword_write_only: \
1749 Result = Context.Id##WOTy; \
1751 case OpenCLAccessAttr::Keyword_read_write: \
1752 Result = Context.Id##RWTy; \
1754 case OpenCLAccessAttr::Keyword_read_only: \
1755 Result = Context.Id##ROTy; \
1757 case OpenCLAccessAttr::SpellingNotCalculated: \
1758 llvm_unreachable("Spelling not yet calculated"); \
1761#include "clang/Basic/OpenCLImageTypes.def"
1772 if (
Result->containsErrors())
1777 bool IsOpenCLC30Compatible =
1787 (IsOpenCLC30Compatible &&
1790 << 0 <<
Result <<
"__opencl_c_images";
1792 }
else if (
Result->isOCLImage3dWOType() &&
1797 << (IsOpenCLC30Compatible
1798 ?
"cl_khr_3d_image_writes and __opencl_c_3d_image_writes"
1799 :
"cl_khr_3d_image_writes");
1820 assert(typeSize > 0 &&
"type size for vector must be greater than 0 bits");
1849 if (AL.slidesFromDeclToDeclSpecLegacyBehavior()) {
1860 if (AL.isStandardAttributeSyntax() && AL.isClangScope() &&
1861 !(AL.getKind() == ParsedAttr::AT_MatrixType &&
1863 S.
Diag(AL.getLoc(), diag::warn_type_attribute_deprecated_on_decl)
1889 if (
Result->isFunctionType()) {
1893 ? diag::warn_typecheck_function_qualifiers_ignored
1894 : diag::warn_typecheck_function_qualifiers_unspecified);
1907 if (TypeQuals &&
Result->isReferenceType()) {
1909 S, DS, TypeQuals,
Result,
1911 diag::warn_typecheck_reference_qualifiers);
1918 && TypeQuals &
Result.getCVRQualifiers()) {
1942 assert(!
Result.isNull() &&
"This function should not return a null type");
1957 const auto *AT = dyn_cast<AutoType>(T);
1958 return AT && AT->isGNUAutoType();
1975 unsigned DiagID = 0;
1991 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
1998 DiagID = diag::err_typecheck_invalid_restrict_not_pointer;
2012 unsigned CVRAU,
const DeclSpec *DS) {
2046 Split.Quals.addCVRQualifiers(CVR);
2065 if (!
type->isObjCLifetimeType() ||
2075 if (
type.isConstQualified()) {
2081 }
else if (
type->isObjCARCImplicitlyUnretainedType()) {
2099 diag::err_arc_indirect_no_ownership,
type, isReference));
2101 S.
Diag(loc, diag::err_arc_indirect_no_ownership) <<
type << isReference;
2105 assert(implicitLifetime &&
"didn't infer any lifetime!");
2146enum QualifiedFunctionKind { QFK_BlockPointer, QFK_Pointer, QFK_Reference };
2152 QualifiedFunctionKind QFK) {
2159 S.
Diag(Loc, diag::err_compound_qualified_function_type)
2171 Diag(Loc, diag::err_qualified_function_typeid)
2203 Diag(Loc, diag::err_illegal_decl_pointer_to_reference)
2211 Diag(Loc, diag::err_opencl_function_pointer) << 0;
2216 Diag(Loc, diag::err_hlsl_pointers_unsupported) << 0;
2236 Diag(Loc, diag::err_wasm_reference_pr) << 0;
2242 Diag(Loc, diag::err_wasm_table_pr) << 0;
2268 "Unresolved overloaded function type");
2296 Diag(Loc, diag::err_reference_to_void);
2301 Diag(Loc, diag::err_hlsl_pointers_unsupported) << 1;
2311 Diag(Loc, diag::err_opencl_function_pointer) << 1;
2325 Diag(Loc, diag::err_wasm_reference_pr) << 1;
2329 Diag(Loc, diag::err_wasm_table_pr) << 1;
2376 llvm::APSInt Bits(32);
2383 size_t NumBits = Bits.getZExtValue();
2384 if (!IsUnsigned && NumBits < 2) {
2385 Diag(Loc, diag::err_bit_int_bad_size) << 0;
2389 if (IsUnsigned && NumBits < 1) {
2390 Diag(Loc, diag::err_bit_int_bad_size) << 1;
2396 Diag(Loc, diag::err_bit_int_max_size)
2410 llvm::APSInt &SizeVal,
unsigned VLADiag,
2435 VLADiagnoser(
unsigned VLADiag,
bool VLAIsError)
2436 : VLADiag(VLADiag), VLAIsError(VLAIsError) {}
2440 return S.
Diag(Loc, diag::err_array_size_non_int) << T;
2445 IsVLA = !VLAIsError;
2446 return S.
Diag(Loc, VLADiag);
2451 return S.
Diag(Loc, diag::ext_vla_folded_to_constant);
2453 } Diagnoser(VLADiag, VLAIsError);
2457 if (Diagnoser.IsVLA)
2471 if (Size.isMultipleOf(Alignment))
2474 Diag(Loc, diag::err_array_element_alignment)
2475 << EltTy << Size.getQuantity() << Alignment.
getQuantity();
2495 Expr *ArraySize,
unsigned Quals,
2512 Diag(Loc, diag::err_illegal_decl_array_of_references)
2518 Diag(Loc, diag::err_array_incomplete_or_sizeless_type) << 0 << T;
2523 diag::err_array_of_abstract_type))
2530 if (!MPTy->getClass()->isDependentType())
2538 diag::err_array_incomplete_or_sizeless_type))
2544 const auto *ATy = dyn_cast<ArrayType>(T);
2545 if (ATy && ATy->getElementType().isWebAssemblyReferenceType()) {
2546 Diag(Loc, diag::err_wasm_reftype_multidimensional_array);
2552 Diag(Loc, diag::err_array_incomplete_or_sizeless_type) << 1 << T;
2557 Diag(Loc, diag::err_illegal_decl_array_of_functions)
2565 if (EltTy->getDecl()->hasFlexibleArrayMember())
2566 Diag(Loc, diag::ext_flexible_array_in_array) << T;
2568 Diag(Loc, diag::err_objc_array_of_interfaces) << T;
2579 ArraySize =
Result.get();
2583 if (ArraySize && !ArraySize->
isPRValue()) {
2588 ArraySize =
Result.get();
2611 if (
const auto *CondExpr = dyn_cast_if_present<ConditionalOperator>(
2613 std::optional<llvm::APSInt> LHS =
2614 CondExpr->getLHS()->getIntegerConstantExpr(
Context);
2615 std::optional<llvm::APSInt> RHS =
2616 CondExpr->getRHS()->getIntegerConstantExpr(
Context);
2617 return LHS && RHS && LHS->isNegative() != RHS->isNegative();
2627 VLADiag = diag::err_opencl_vla;
2630 VLADiag = diag::warn_vla_used;
2633 VLADiag = diag::err_vla_in_sfinae;
2636 VLADiag = diag::err_openmp_vla_in_task_untied;
2641 ? diag::ext_vla_cxx_in_gnu_mode_static_assert
2642 : diag::ext_vla_cxx_static_assert;
2644 VLADiag =
getLangOpts().GNUMode ? diag::ext_vla_cxx_in_gnu_mode
2645 : diag::ext_vla_cxx;
2648 VLADiag = diag::ext_vla;
2689 if (ConstVal.isSigned() && ConstVal.isNegative()) {
2696 diag::err_typecheck_negative_array_size)
2705 : diag::ext_typecheck_zero_array_size)
2710 unsigned ActiveSizeBits =
2714 : ConstVal.getActiveBits();
2730 IsCUDADevice ? diag::err_cuda_vla : diag::err_vla_unsupported)
2735 FSI->setHasVLA(Loc);
2743 : diag::ext_c99_array_usage)
2744 << llvm::to_underlying(ASM);
2754 Diag(Loc, diag::err_opencl_invalid_type_array) << ArrType;
2771 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << CurType;
2776 unsigned NumBits = BIT->getNumBits();
2777 if (!llvm::isPowerOf2_32(NumBits) || NumBits < 8) {
2778 Diag(AttrLoc, diag::err_attribute_invalid_bitint_vector_type)
2788 std::optional<llvm::APSInt> VecSize =
2791 Diag(AttrLoc, diag::err_attribute_argument_type)
2802 if (!VecSize->isIntN(61)) {
2804 Diag(AttrLoc, diag::err_attribute_size_too_large)
2808 uint64_t VectorSizeBits = VecSize->getZExtValue() * 8;
2811 if (VectorSizeBits == 0) {
2812 Diag(AttrLoc, diag::err_attribute_zero_size)
2817 if (!TypeSize || VectorSizeBits % TypeSize) {
2818 Diag(AttrLoc, diag::err_attribute_invalid_size)
2823 if (VectorSizeBits / TypeSize > std::numeric_limits<uint32_t>::max()) {
2824 Diag(AttrLoc, diag::err_attribute_size_too_large)
2851 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << T;
2858 if (!llvm::isPowerOf2_32(NumBits) || NumBits < 8) {
2859 Diag(AttrLoc, diag::err_attribute_invalid_bitint_vector_type)
2866 std::optional<llvm::APSInt> vecSize =
2869 Diag(AttrLoc, diag::err_attribute_argument_type)
2875 if (!vecSize->isIntN(32)) {
2876 Diag(AttrLoc, diag::err_attribute_size_too_large)
2882 unsigned vectorSize =
static_cast<unsigned>(vecSize->getZExtValue());
2884 if (vectorSize == 0) {
2885 Diag(AttrLoc, diag::err_attribute_zero_size)
2899 "Should never build a matrix type when it is disabled");
2904 Diag(AttrLoc, diag::err_attribute_invalid_matrix_type) << ElementTy;
2913 std::optional<llvm::APSInt> ValueRows =
2915 std::optional<llvm::APSInt> ValueColumns =
2922 if (!ValueRows && !ValueColumns) {
2923 Diag(AttrLoc, diag::err_attribute_argument_type)
2931 Diag(AttrLoc, diag::err_attribute_argument_type)
2937 if (!ValueColumns) {
2938 Diag(AttrLoc, diag::err_attribute_argument_type)
2944 unsigned MatrixRows =
static_cast<unsigned>(ValueRows->getZExtValue());
2945 unsigned MatrixColumns =
static_cast<unsigned>(ValueColumns->getZExtValue());
2946 if (MatrixRows == 0 && MatrixColumns == 0) {
2947 Diag(AttrLoc, diag::err_attribute_zero_size)
2948 <<
"matrix" << RowRange << ColRange;
2951 if (MatrixRows == 0) {
2952 Diag(AttrLoc, diag::err_attribute_zero_size) <<
"matrix" << RowRange;
2955 if (MatrixColumns == 0) {
2956 Diag(AttrLoc, diag::err_attribute_zero_size) <<
"matrix" << ColRange;
2960 Diag(AttrLoc, diag::err_attribute_size_too_large)
2961 << RowRange <<
"matrix row";
2965 Diag(AttrLoc, diag::err_attribute_size_too_large)
2966 << ColRange <<
"matrix column";
2974 Diag(Loc, diag::err_func_returning_array_function)
2982 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 <<
2990 Diag(Loc, diag::err_object_cannot_be_passed_returned_by_value)
3003 Diag(Loc, diag::warn_deprecated_volatile_return) << T;
3018 bool emittedError =
false;
3020 enum class RequiredCC { OnlySwift, SwiftOrSwiftAsync };
3021 auto checkCompatible = [&](
unsigned paramIndex, RequiredCC required) {
3023 (required == RequiredCC::OnlySwift)
3026 if (isCompatible || emittedError)
3028 S.
Diag(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall)
3030 << (required == RequiredCC::OnlySwift);
3031 emittedError =
true;
3033 for (
size_t paramIndex = 0, numParams = paramTypes.size();
3034 paramIndex != numParams; ++paramIndex) {
3043 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
3044 if (paramIndex != 0 &&
3047 S.
Diag(getParamLoc(paramIndex),
3048 diag::err_swift_indirect_result_not_first);
3053 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
3062 checkCompatible(paramIndex, RequiredCC::OnlySwift);
3063 if (paramIndex == 0 ||
3066 S.
Diag(getParamLoc(paramIndex),
3067 diag::err_swift_error_result_not_after_swift_context);
3071 llvm_unreachable(
"bad ABI kind");
3083 for (
unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) {
3087 Diag(Loc, diag::err_param_with_void_type);
3092 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<
3096 Diag(Loc, diag::err_wasm_table_as_function_parameter);
3103 Diag(Loc, diag::warn_deprecated_volatile_param) << ParamType;
3105 ParamTypes[Idx] = ParamType;
3110 [=](
unsigned i) {
return Loc; });
3139 Diag(Loc, diag::err_distant_exception_spec);
3146 Diag(Loc, diag::err_illegal_decl_mempointer_to_reference)
3152 Diag(Loc, diag::err_illegal_decl_mempointer_to_void)
3157 if (!
Class->isDependentType() && !
Class->isRecordType()) {
3158 Diag(Loc, diag::err_mempointer_in_nonclass_type) <<
Class;
3165 Diag(Loc, diag::err_opencl_function_pointer) << 0;
3170 Diag(Loc, diag::err_hlsl_pointers_unsupported) << 0;
3200 Diag(Loc, diag::err_nonfunction_block_type);
3216 if (TInfo) *TInfo =
nullptr;
3221 if (
const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
3222 QT = LIT->getType();
3223 DI = LIT->getTypeSourceInfo();
3226 if (TInfo) *TInfo = DI;
3232 unsigned chunkIndex);
3239 Sema &S = state.getSema();
3240 Declarator &declarator = state.getDeclarator();
3246 unsigned outermostPointerIndex = 0;
3248 unsigned numPointers = 0;
3250 unsigned chunkIndex = i;
3252 switch (chunk.
Kind) {
3262 outermostPointerIndex = chunkIndex;
3270 if (numPointers != 1)
return;
3272 outermostPointerIndex = chunkIndex;
3290 if (numPointers == 1) {
3308 }
else if (numPointers == 2) {
3321 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership)
3325 outermostPointerIndex);
3347 }
const QualKinds[5] = {
3356 unsigned NumQuals = 0;
3361 for (
auto &E : QualKinds) {
3362 if (Quals & E.Mask) {
3363 if (!QualStr.empty()) QualStr +=
' ';
3380 << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];
3386 unsigned FunctionChunkIndex) {
3396 for (
unsigned OuterChunkIndex = FunctionChunkIndex + 1,
3398 OuterChunkIndex != End; ++OuterChunkIndex) {
3400 switch (OuterChunk.
Kind) {
3407 diag::warn_qual_return_type,
3433 llvm_unreachable(
"unknown declarator chunk kind");
3454static std::pair<QualType, TypeSourceInfo *>
3458 Sema &S = state.getSema();
3462 const unsigned AutoParameterPosition = Info.
TemplateParams.size();
3476 TemplateParameterDepth, AutoParameterPosition,
3479 IsParameterPack,
Auto->isConstrained());
3484 if (
Auto->isConstrained()) {
3491 for (
unsigned Idx = 0; Idx < AutoLoc.
getNumArgs(); ++Idx) {
3538 USD ? cast<NamedDecl>(USD) : CD,
3550 QualType NewT = state.ReplaceAutoType(T, Replacement);
3554 return {NewT, NewTSI};
3563 Sema &SemaRef = state.getSema();
3566 ReturnTypeInfo =
nullptr;
3569 TagDecl *OwnedTagDecl =
nullptr;
3620 bool DeducedIsTrailingReturnType =
false;
3624 DeducedIsTrailingReturnType =
true;
3634 bool IsCXXAutoType =
3636 bool IsDeducedReturnType =
false;
3673 assert(Info &&
"No LambdaScopeInfo on the stack!");
3679 if (!DeducedIsTrailingReturnType)
3688 if (isa<ObjCContainerDecl>(SemaRef.
CurContext)) {
3691 switch (cast<TagDecl>(SemaRef.
CurContext)->getTagKind()) {
3693 llvm_unreachable(
"unhandled tag kind");
3695 Error = Cxx ? 1 : 2;
3698 Error = Cxx ? 3 : 4;
3717 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
3729 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
3743 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3745 IsDeducedReturnType =
true;
3748 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3750 IsDeducedReturnType =
true;
3753 if (isa<DeducedTemplateSpecializationType>(Deduced))
3755 if (SemaRef.
getLangOpts().CPlusPlus23 && IsCXXAutoType &&
3756 !
Auto->isDecltypeAuto())
3775 if (!IsCXXAutoType && !isa<DeducedTemplateSpecializationType>(Deduced))
3789 (!SemaRef.
getLangOpts().CPlusPlus11 || !IsCXXAutoType))
3799 switch (
Auto->getKeyword()) {
3805 assert(isa<DeducedTemplateSpecializationType>(Deduced) &&
3806 "unknown auto type");
3810 auto *DTST = dyn_cast<DeducedTemplateSpecializationType>(Deduced);
3813 SemaRef.
Diag(AutoRange.
getBegin(), diag::err_auto_not_allowed)
3815 <<
QualType(Deduced, 0) << AutoRange;
3826 ? diag::warn_cxx11_compat_generic_lambda
3827 : IsDeducedReturnType
3828 ? diag::warn_cxx11_compat_deduced_return_type
3829 : diag::warn_cxx98_compat_auto_type_specifier)
3838 unsigned DiagID = 0;
3844 llvm_unreachable(
"parser should not have allowed this");
3860 DiagID = diag::err_type_defined_in_alias_template;
3872 DiagID = diag::err_type_defined_in_type_specifier;
3882 DiagID = diag::err_type_defined_in_param_type;
3888 DiagID = diag::err_type_defined_in_condition;
3899 assert(!T.
isNull() &&
"This function should not return a null type");
3908 assert(FTI.
isAmbiguous &&
"no direct-initializer / function ambiguity");
3938 FTI.
NumParams ? diag::warn_parens_disambiguated_as_function_declaration
3939 : diag::warn_empty_parens_are_function_decl)
3950 if (Comma.getFileID() != Name.getFileID() ||
3951 Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) {
3958 Result.suppressDiagnostics();
3971 S.
Diag(B, diag::note_additional_parens_for_variable_declaration)
3986 S.
Diag(DeclType.
Loc, diag::note_empty_parens_default_ctor)
3994 S.
Diag(DeclType.
Loc, diag::note_empty_parens_zero_initialize)
4005 "do not have redundant top-level parentheses");
4014 bool CouldBeTemporaryObject =
4021 bool StartsWithDeclaratorId =
true;
4029 StartsWithDeclaratorId =
false;
4034 CouldBeTemporaryObject =
false;
4042 CouldBeTemporaryObject =
false;
4043 StartsWithDeclaratorId =
false;
4053 CouldBeTemporaryObject =
false;
4060 CouldBeTemporaryObject =
false;
4061 StartsWithDeclaratorId =
false;
4071 if (CouldBeTemporaryObject) {
4075 CouldBeTemporaryObject =
false;
4076 Result.suppressDiagnostics();
4081 if (!CouldBeTemporaryObject) {
4094 S.
Diag(
Paren.Loc, diag::warn_redundant_parens_around_declarator)
4100 S.
Diag(
Paren.Loc, diag::warn_parens_disambiguated_as_variable_declaration)
4103 if (!RD || !RD->hasDefinition() || RD->hasNonTrivialDestructor())
4104 S.
Diag(
Paren.Loc, diag::note_raii_guard_add_name)
4109 S.
Diag(D.
getBeginLoc(), diag::note_function_style_cast_add_parentheses)
4112 S.
Diag(
Paren.Loc, diag::note_remove_parens_for_variable_declaration)
4128 switch (AL.getKind()) {
4147 bool IsCXXInstanceMethod =
false;
4153 unsigned I = ChunkIndex;
4154 bool FoundNonParen =
false;
4155 while (I && !FoundNonParen) {
4158 FoundNonParen =
true;
4161 if (FoundNonParen) {
4164 IsCXXInstanceMethod =
4169 IsCXXInstanceMethod =
4177 IsCXXInstanceMethod =
4185 IsCXXInstanceMethod);
4193 if (AL.getKind() == ParsedAttr::AT_OpenCLKernel) {
4203 if (Triple.getArch() == llvm::Triple::spirv32 ||
4204 Triple.getArch() == llvm::Triple::spirv64) {
4206 if (AL.getKind() == ParsedAttr::AT_CUDAGlobal) {
4220 enum class SimplePointerKind {
4229 switch (nullability) {
4231 if (!Ident__Nonnull)
4233 return Ident__Nonnull;
4236 if (!Ident__Nullable)
4238 return Ident__Nullable;
4241 if (!Ident__Nullable_result)
4243 return Ident__Nullable_result;
4246 if (!Ident__Null_unspecified)
4248 return Ident__Null_unspecified;
4250 llvm_unreachable(
"Unknown nullability kind.");
4258 return Ident_NSError;
4265 if (AL.getKind() == ParsedAttr::AT_TypeNonNull ||
4266 AL.getKind() == ParsedAttr::AT_TypeNullable ||
4267 AL.getKind() == ParsedAttr::AT_TypeNullableResult ||
4268 AL.getKind() == ParsedAttr::AT_TypeNullUnspecified)
4277 enum class PointerDeclaratorKind {
4285 MaybePointerToCFRef,
4289 NSErrorPointerPointer,
4295 enum class PointerWrappingDeclaratorKind {
4309static PointerDeclaratorKind
4311 PointerWrappingDeclaratorKind &wrappingKind) {
4312 unsigned numNormalPointers = 0;
4315 if (
type->isDependentType())
4316 return PointerDeclaratorKind::NonPointer;
4321 switch (chunk.
Kind) {
4323 if (numNormalPointers == 0)
4324 wrappingKind = PointerWrappingDeclaratorKind::Array;
4333 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
4334 : PointerDeclaratorKind::SingleLevelPointer;
4340 if (numNormalPointers == 0)
4341 wrappingKind = PointerWrappingDeclaratorKind::Reference;
4345 ++numNormalPointers;
4346 if (numNormalPointers > 2)
4347 return PointerDeclaratorKind::MultiLevelPointer;
4353 unsigned numTypeSpecifierPointers = 0;
4357 ++numNormalPointers;
4359 if (numNormalPointers > 2)
4360 return PointerDeclaratorKind::MultiLevelPointer;
4362 type = ptrType->getPointeeType();
4363 ++numTypeSpecifierPointers;
4369 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
4370 : PointerDeclaratorKind::SingleLevelPointer;
4375 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
4376 : PointerDeclaratorKind::SingleLevelPointer;
4381 ++numNormalPointers;
4382 ++numTypeSpecifierPointers;
4385 if (
auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) {
4387 numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
4388 return PointerDeclaratorKind::NSErrorPointerPointer;
4397 if (objcClass->getInterface()->getIdentifier() == S.
getNSErrorIdent()) {
4398 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2)
4399 return PointerDeclaratorKind::NSErrorPointerPointer;
4406 if (numNormalPointers == 0)
4407 return PointerDeclaratorKind::NonPointer;
4413 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2 &&
4415 return PointerDeclaratorKind::CFErrorRefPointer;
4423 switch (numNormalPointers) {
4425 return PointerDeclaratorKind::NonPointer;
4428 return PointerDeclaratorKind::SingleLevelPointer;
4431 return PointerDeclaratorKind::MaybePointerToCFRef;
4434 return PointerDeclaratorKind::MultiLevelPointer;
4449 if (
auto bridgeAttr = RD->
getAttr<ObjCBridgeAttr>())
4450 bridgedType = bridgeAttr->getBridgedType();
4451 else if (
auto bridgeAttr = RD->
getAttr<ObjCBridgeMutableAttr>())
4452 bridgedType = bridgeAttr->getBridgedType();
4468 if (ctx->isFunctionOrMethod())
4471 if (ctx->isFileContext())
4482 bool invalid =
false;
4484 if (invalid || !sloc.
isFile())
4502template <
typename DiagBuilderT>
4511 if (!FixItLoc.
isValid() || FixItLoc == PointerLoc)
4520 InsertionTextBuf +=
" ";
4521 StringRef InsertionText = InsertionTextBuf.str();
4524 InsertionText = InsertionText.drop_back();
4525 }
else if (NextChar[-1] ==
'[') {
4526 if (NextChar[0] ==
']')
4527 InsertionText = InsertionText.drop_back().drop_front();
4529 InsertionText = InsertionText.drop_front();
4532 InsertionText = InsertionText.drop_back().drop_front();
4539 SimplePointerKind PointerKind,
4544 if (PointerKind == SimplePointerKind::Array) {
4545 S.
Diag(PointerLoc, diag::warn_nullability_missing_array);
4547 S.
Diag(PointerLoc, diag::warn_nullability_missing)
4548 <<
static_cast<unsigned>(PointerKind);
4551 auto FixItLoc = PointerEndLoc.
isValid() ? PointerEndLoc : PointerLoc;
4552 if (FixItLoc.isMacroID())
4556 auto Diag = S.
Diag(FixItLoc, diag::note_nullability_fix_it);
4557 Diag << static_cast<unsigned>(Nullability);
4558 Diag << static_cast<unsigned>(PointerKind);
4587 if (pointerKind == SimplePointerKind::Array)
4588 diagKind = diag::warn_nullability_missing_array;
4590 diagKind = diag::warn_nullability_missing;
4596 fileNullability.
PointerKind =
static_cast<unsigned>(pointerKind);
4628 auto kind =
static_cast<SimplePointerKind
>(fileNullability.
PointerKind);
4643 unsigned i = endIndex;
4671template<
typename AttrT>
4674 return ::new (Ctx) AttrT(Ctx, AL);
4681 return createSimpleAttr<TypeNonNullAttr>(Ctx,
Attr);
4684 return createSimpleAttr<TypeNullableAttr>(Ctx,
Attr);
4687 return createSimpleAttr<TypeNullableResultAttr>(Ctx,
Attr);
4690 return createSimpleAttr<TypeNullUnspecifiedAttr>(Ctx,
Attr);
4692 llvm_unreachable(
"unknown NullabilityKind");
4703 if (ASOld != ASNew) {
4704 S.
Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
4709 diag::warn_attribute_address_multiple_identical_qualifiers);
4721 Sema &S = state.getSema();
4731 bool IsTypedefName =
4747 bool IsClassTemplateDeduction = isa<DeducedTemplateSpecializationType>(DT);
4750 unsigned Index = E - I - 1;
4752 unsigned DiagId = IsClassTemplateDeduction
4753 ? diag::err_deduced_class_template_compound_type
4754 : diag::err_decltype_auto_compound_type;
4755 unsigned DiagKind = 0;
4756 switch (DeclChunk.
Kind) {
4759 if (IsClassTemplateDeduction) {
4765 if (IsClassTemplateDeduction) {
4773 DiagId = diag::err_decltype_auto_function_declarator_not_declaration;
4791 S.
Diag(DeclChunk.
Loc, DiagId) << DiagKind;
4799 std::optional<NullabilityKind> inferNullability;
4800 bool inferNullabilityCS =
false;
4801 bool inferNullabilityInnerOnly =
false;
4802 bool inferNullabilityInnerOnlyComplete =
false;
4805 bool inAssumeNonNullRegion =
false;
4807 if (assumeNonNullLoc.
isValid()) {
4808 inAssumeNonNullRegion =
true;
4822 } complainAboutMissingNullability = CAMN_No;
4823 unsigned NumPointersRemaining = 0;
4824 auto complainAboutInferringWithinChunk = PointerWrappingDeclaratorKind::None;
4826 if (IsTypedefName) {
4830 complainAboutMissingNullability = CAMN_InnerPointers;
4835 ++NumPointersRemaining;
4840 switch (chunk.
Kind) {
4848 ++NumPointersRemaining;
4856 ++NumPointersRemaining;
4862 switch (
auto context = state.getDeclarator().getContext()) {
4873 complainAboutMissingNullability = CAMN_No;
4878 if (state.getDeclarator().isObjCWeakProperty()) {
4881 complainAboutMissingNullability = CAMN_No;
4882 if (inAssumeNonNullRegion) {
4892 complainAboutMissingNullability = CAMN_Yes;
4895 auto wrappingKind = PointerWrappingDeclaratorKind::None;
4897 case PointerDeclaratorKind::NonPointer:
4898 case PointerDeclaratorKind::MultiLevelPointer:
4902 case PointerDeclaratorKind::SingleLevelPointer:
4904 if (inAssumeNonNullRegion) {
4905 complainAboutInferringWithinChunk = wrappingKind;
4912 case PointerDeclaratorKind::CFErrorRefPointer:
4913 case PointerDeclaratorKind::NSErrorPointerPointer:
4920 case PointerDeclaratorKind::MaybePointerToCFRef:
4925 auto hasCFReturnsAttr =
4927 return AttrList.hasAttribute(ParsedAttr::AT_CFReturnsRetained) ||
4928 AttrList.hasAttribute(ParsedAttr::AT_CFReturnsNotRetained);
4933 hasCFReturnsAttr(InnermostChunk->getAttrs()) ||
4936 inferNullabilityInnerOnly =
true;
4946 complainAboutMissingNullability = CAMN_Yes;
4974 auto isVaList = [&S](
QualType T) ->
bool {
4980 if (typedefTy->getDecl() == vaListTypedef)
4982 if (
auto *name = typedefTy->getDecl()->getIdentifier())
4983 if (name->isStr(
"va_list"))
4985 typedefTy = typedefTy->desugar()->getAs<
TypedefType>();
4986 }
while (typedefTy);
4992 auto inferPointerNullability =
4997 if (NumPointersRemaining > 0)
4998 --NumPointersRemaining;
5005 if (inferNullability && !inferNullabilityInnerOnlyComplete) {
5008 ? ParsedAttr::Form::ContextSensitiveKeyword()
5009 : ParsedAttr::Form::Keyword(
false ,
5015 attrs.addAtEnd(nullabilityAttr);
5017 if (inferNullabilityCS) {
5018 state.getDeclarator().getMutableDeclSpec().getObjCQualifiers()
5022 if (pointerLoc.isValid() &&
5023 complainAboutInferringWithinChunk !=
5024 PointerWrappingDeclaratorKind::None) {
5026 S.
Diag(pointerLoc, diag::warn_nullability_inferred_on_nested_type);
5027 Diag << static_cast<int>(complainAboutInferringWithinChunk);
5031 if (inferNullabilityInnerOnly)
5032 inferNullabilityInnerOnlyComplete =
true;
5033 return nullabilityAttr;
5038 switch (complainAboutMissingNullability) {
5042 case CAMN_InnerPointers:
5043 if (NumPointersRemaining == 0)
5060 if (NumPointersRemaining > 0)
5061 --NumPointersRemaining;
5063 SimplePointerKind pointerKind = SimplePointerKind::Pointer;
5065 pointerKind = SimplePointerKind::BlockPointer;
5067 pointerKind = SimplePointerKind::MemberPointer;
5069 if (
auto *
attr = inferPointerNullability(
5074 T = state.getAttributedType(
5080 if (complainAboutMissingNullability == CAMN_Yes && T->
isArrayType() &&
5088 bool ExpectNoDerefChunk =
5089 state.getCurrentAttributes().hasAttribute(ParsedAttr::AT_NoDeref);
5099 bool AreDeclaratorChunksValid =
true;
5101 unsigned chunkIndex = e - i - 1;
5102 state.setCurrentChunkIndex(chunkIndex);
5105 switch (DeclType.
Kind) {
5113 if (!LangOpts.Blocks)
5114 S.
Diag(DeclType.
Loc, diag::err_blocks_disable) << LangOpts.OpenCL;
5117 inferPointerNullability(SimplePointerKind::BlockPointer, DeclType.
Loc,
5119 state.getDeclarator().getAttributePool());
5125 if (LangOpts.OpenCL)
5140 inferPointerNullability(SimplePointerKind::Pointer, DeclType.
Loc,
5142 state.getDeclarator().getAttributePool());
5154 if (LangOpts.OpenCL) {
5195 if (chunkIndex != 0 && !ArraySize &&
5214 S.
Diag(DeclType.
Loc, diag::err_array_star_outside_prototype);
5225 S.
Diag(DeclType.
Loc, diag::err_array_static_outside_prototype)
5227 :
"type qualifier");
5238 S.
Diag(DeclType.
Loc, diag::err_array_static_not_outermost)
5240 :
"type qualifier");
5250 if (complainAboutMissingNullability == CAMN_Yes &&
5266 IsQualifiedFunction =
5279 ? diag::err_auto_missing_trailing_return
5280 : diag::err_deduced_return_type);
5283 AreDeclaratorChunksValid =
false;
5286 diag::warn_cxx11_compat_deduced_return_type);
5290 if (isa<ParenType>(T)) {
5295 AreDeclaratorChunksValid =
false;
5300 diag::err_deduction_guide_with_complex_decl)
5304 AreDeclaratorChunksValid =
false;
5308 cast<AutoType>(T)->getKeyword() !=
5310 cast<AutoType>(T)->isConstrained())) {
5312 diag::err_trailing_return_without_auto)
5316 AreDeclaratorChunksValid =
false;
5332 if (InventedParamInfo) {
5334 state, T, TInfo,
Auto, *InventedParamInfo);
5348 unsigned diagID = diag::err_func_returning_array_function;
5351 if (chunkIndex == 0 &&
5353 diagID = diag::err_block_returning_array_function;
5357 AreDeclaratorChunksValid =
false;
5370 }
else if (!S.
getLangOpts().NativeHalfArgsAndReturns &&
5373 diag::err_parameters_retval_cannot_have_fp16_type) << 1;
5378 if (LangOpts.OpenCL) {
5392 "__cl_clang_variadic_functions", S.
getLangOpts()) &&
5413 S.
Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value)
5425 AreDeclaratorChunksValid =
false;
5442 S.
Diag(DeclType.
Loc, diag::err_func_returning_qualified_void) << T;
5449 S.
Diag(DeclType.
Loc, diag::warn_deprecated_volatile_return) << T;
5460 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5461 AttrLoc = AL.getLoc();
5468 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5469 AttrLoc = AL.getLoc();
5483 S.
Diag(AttrLoc, diag::warn_arc_lifetime_result_type)
5500 diag::err_exception_spec_in_typedef)
5526 diag::warn_c17_compat_ellipsis_only_parameter);
5528 ParsedAttr::AT_Overloadable) &&
5530 ParsedAttr::AT_Overloadable) &&
5532 ParsedAttr::AT_Overloadable))
5540 diag::err_ident_list_in_fn_declaration);
5546 AreDeclaratorChunksValid =
false;
5569 bool HasAnyInterestingExtParameterInfos =
false;
5571 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
5574 assert(!ParamTy.
isNull() &&
"Couldn't parse type?");
5585 ParamTy = Context.
IntTy;
5590 ParamTy = Context.
IntTy;
5595 S.
Diag(DeclType.
Loc, diag::err_void_param_qualified);
5611 }
else if (!S.
getLangOpts().NativeHalfArgsAndReturns &&
5614 diag::err_parameters_retval_cannot_have_fp16_type) << 0;
5622 if (BTy->getKind() == BuiltinType::Float) {
5634 if (LangOpts.ObjCAutoRefCount && Param->
hasAttr<NSConsumedAttr>()) {
5635 ExtParameterInfos[i] = ExtParameterInfos[i].withIsConsumed(
true);
5636 HasAnyInterestingExtParameterInfos =
true;
5640 ExtParameterInfos[i] =
5641 ExtParameterInfos[i].withABI(
attr->getABI());
5642 HasAnyInterestingExtParameterInfos =
true;
5645 if (Param->
hasAttr<PassObjectSizeAttr>()) {
5646 ExtParameterInfos[i] = ExtParameterInfos[i].withHasPassObjectSize();
5647 HasAnyInterestingExtParameterInfos =
true;
5650 if (Param->
hasAttr<NoEscapeAttr>()) {
5651 ExtParameterInfos[i] = ExtParameterInfos[i].withIsNoEscape(
true);
5652 HasAnyInterestingExtParameterInfos =
true;
5655 ParamTys.push_back(ParamTy);
5658 if (HasAnyInterestingExtParameterInfos) {
5667 Expr *NoexceptExpr =
nullptr;
5673 DynamicExceptions.reserve(N);
5674 DynamicExceptionRanges.reserve(N);
5675 for (
unsigned I = 0; I != N; ++I) {
5686 DynamicExceptionRanges,
5693 auto IsClassMember = [&]() {
5694 return (!state.getDeclarator().getCXXScopeSpec().isEmpty() &&
5695 state.getDeclarator()
5699 state.getDeclarator().getContext() ==
5701 state.getDeclarator().getContext() ==
5705 if (state.getSema().getLangOpts().OpenCLCPlusPlus && IsClassMember()) {
5735 inferPointerNullability(SimplePointerKind::MemberPointer, DeclType.
Loc,
5737 state.getDeclarator().getAttributePool());
5756 llvm_unreachable(
"Nested-name-specifier must name a type");
5766 if (isa<TemplateSpecializationType>(NNS->
getAsType()))
5768 NNSPrefix, ClsType);
5773 diag::err_illegal_decl_mempointer_in_nonclass)
5783 AreDeclaratorChunksValid =
false;
5788 AreDeclaratorChunksValid =
false;
5806 AreDeclaratorChunksValid =
false;
5815 S.
Diag(DeclType.
Loc, diag::warn_noderef_on_non_pointer_or_array);
5817 ExpectNoDerefChunk = state.didParseNoDeref();
5821 if (ExpectNoDerefChunk)
5822 S.
Diag(state.getDeclarator().getBeginLoc(),
5823 diag::warn_noderef_on_non_pointer_or_array);
5836 bool IsBlock =
false;
5838 switch (DeclType.Kind) {
5850 S.
Diag(DeclType.Loc, diag::warn_strict_prototypes)
5862 assert(!T.
isNull() &&
"T must not be null after this point");
5866 assert(FnTy &&
"Why oh why is there not a FunctionProtoType here?");
5879 ExplicitObjectMember,
5883 Kind = DeductionGuide;
5901 if (
P &&
P->isExplicitObjectParameter())
5902 Kind = ExplicitObjectMember;
5928 if (IsQualifiedFunction &&
5953 if (!RemovalLocs.empty()) {
5954 llvm::sort(RemovalLocs,
5956 RemovalRange =
SourceRange(RemovalLocs.front(), RemovalLocs.back());
5957 Loc = RemovalLocs.front();
5961 S.
Diag(Loc, diag::err_invalid_qualified_function_type)
5985 if (!AL.slidesFromDeclToDeclSpecLegacyBehavior()) {
5993 state.diagnoseIgnoredTypeAttrs(T);
6032 diag::err_function_parameter_pack_without_parameter_packs)
6053 LangOpts.CPlusPlus11
6054 ? diag::warn_cxx98_compat_variadic_templates
6055 : diag::ext_variadic_templates);
6085 diag::err_ellipsis_in_declarator_not_parameter);
6091 assert(!T.
isNull() &&
"T must not be null at the end of this function");
6092 if (!AreDeclaratorChunksValid)
6106 TypeProcessingState state(*
this, D);
6129 unsigned chunkIndex) {
6130 Sema &S = state.getSema();
6138 const char *attrStr =
nullptr;
6139 switch (ownership) {
6158 &Args, 1, ParsedAttr::Form::GNU());
6167 Sema &S = state.getSema();
6171 bool hasIndirection =
false;
6174 switch (chunk.
Kind) {
6183 hasIndirection =
true;
6216 TypeProcessingState state(*
this, D);
6231 TypeProcessingState &State) {
6238 if (AL.getKind() == ParsedAttr::AT_MatrixType) {
6247 llvm_unreachable(
"no matrix_type attribute found at the expected location!");
6251 class TypeSpecLocFiller :
public TypeLocVisitor<TypeSpecLocFiller> {
6254 TypeProcessingState &State;
6258 TypeSpecLocFiller(
Sema &S,
ASTContext &Context, TypeProcessingState &State,
6260 : SemaRef(S), Context(Context), State(State), DS(DS) {}
6272 State.getExpansionLocForMacroQualifiedType(TL.
getTypePtr()));
6395 void VisitDependentTemplateSpecializationTypeLoc(
6424 if (TemplateId->
NumArgs > 0) {
6435 TN.getKind() == TemplateName::NameKind::UsingTemplate
6436 ? cast<NamedDecl>(TN.getAsUsingShadowDecl())
6437 : cast_if_present<NamedDecl>(TN.getAsTemplateDecl()),
6480 void VisitTypeLoc(
TypeLoc TL) {
6486 class DeclaratorLocFiller :
public TypeLocVisitor<DeclaratorLocFiller> {
6488 TypeProcessingState &State;
6492 DeclaratorLocFiller(
ASTContext &Context, TypeProcessingState &State,
6494 : Context(Context), State(State), Chunk(Chunk) {}
6497 llvm_unreachable(
"qualified type locs not expected here!");
6500 llvm_unreachable(
"decayed type locs not expected here!");
6536 assert(isa<DependentNameType>(ClsTy) &&
"Unexpected TypeLoc");
6547 if (isa<ElaboratedType>(ClsTy)) {
6562 llvm_unreachable(
"Nested-name-specifier must name a type");
6594 for (
unsigned i = 0, e = TL.
getNumParams(), tpi = 0; i != e; ++i) {
6630 void VisitTypeLoc(
TypeLoc TL) {
6631 llvm_unreachable(
"unsupported TypeLoc kind in declarator!");
6638 switch (Chunk.
Kind) {
6643 llvm_unreachable(
"cannot be _Atomic qualified");
6664 if (AL.getKind() == ParsedAttr::AT_AddressSpace) {
6673 "no address_space attribute found at the expected location!");
6687 Sema &S = State.getSema();
6694 if (isa<PackExpansionType>(T)) {
6713 bool HasDesugaredTypeLoc =
true;
6714 while (HasDesugaredTypeLoc) {
6716 case TypeLoc::MacroQualified: {
6719 State.getExpansionLocForMacroQualifiedType(TL.
getTypePtr()));
6724 case TypeLoc::Attributed: {
6731 case TypeLoc::Adjusted:
6732 case TypeLoc::BTFTagAttributed: {
6737 case TypeLoc::DependentAddressSpace: {
6745 HasDesugaredTypeLoc =
false;
6756 if (ReturnTypeInfo) {
6776 "LocInfoType's TypeClass conflicts with an existing Type class");
6782 llvm_unreachable(
"LocInfoType leaked into the type system; an opaque TypeTy*"
6783 " was used directly instead of getting the QualType through"
6784 " GetTypeFromParser");
6791 "Type name should have no identifier!");
6830 const Expr *AddrSpace,
6833 std::optional<llvm::APSInt> OptAddrSpace =
6835 if (!OptAddrSpace) {
6836 S.
Diag(AttrLoc, diag::err_attribute_argument_type)
6841 llvm::APSInt &addrSpace = *OptAddrSpace;
6844 if (addrSpace.isSigned()) {
6845 if (addrSpace.isNegative()) {
6846 S.
Diag(AttrLoc, diag::err_attribute_address_space_negative)
6850 addrSpace.setIsSigned(
false);
6853 llvm::APSInt
max(addrSpace.getBitWidth());
6857 if (addrSpace >
max) {
6858 S.
Diag(AttrLoc, diag::err_attribute_address_space_too_high)
6893 Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
6909 TypeProcessingState &State) {
6910 Sema &S = State.getSema();
6913 if (
Attr.getNumArgs() != 1) {
6914 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
6921 auto *StrLiteral = dyn_cast<StringLiteral>(
Attr.getArgAsExpr(0));
6930 StringRef BTFTypeTag = StrLiteral->getString();
6931 Type = State.getBTFTagAttributedType(
6932 ::new (Ctx) BTFTypeTagAttr(Ctx,
Attr, BTFTypeTag),
Type);
6940 TypeProcessingState &State) {
6941 Sema &S = State.getSema();
6946 S.
Diag(
Attr.
getLoc(), diag::err_attribute_address_function_type);
6952 if (
Attr.
getKind() == ParsedAttr::AT_AddressSpace) {
6955 if (
Attr.getNumArgs() != 1) {
6962 Expr *ASArgExpr =
static_cast<Expr *
>(
Attr.getArgAsExpr(0));
6971 ::new (Ctx) AddressSpaceAttr(Ctx,
Attr,
static_cast<unsigned>(ASIdx));
6983 if (EquivType.
isNull()) {
6987 T = State.getAttributedType(ASAttr,
Type, EquivType);
6989 T = State.getAttributedType(ASAttr,
Type,
Type);
7000 :
Attr.asOpenCLLangAS();
7002 ASIdx =
Attr.asHLSLLangAS();
7005 llvm_unreachable(
"Invalid address space");
7023 bool NonObjCPointer =
false;
7025 if (!
type->isDependentType() && !
type->isUndeducedType()) {
7033 NonObjCPointer =
true;
7034 }
else if (!
type->isObjCRetainableType()) {
7040 if (state.isProcessingDeclSpec()) {
7048 Sema &S = state.getSema();
7054 if (!
attr.isArgIdent(0)) {
7055 S.
Diag(AttrLoc, diag::err_attribute_argument_type) <<
attr
7063 if (II->
isStr(
"none"))
7065 else if (II->
isStr(
"strong"))
7067 else if (II->
isStr(
"weak"))
7069 else if (II->
isStr(
"autoreleasing"))
7072 S.
Diag(AttrLoc, diag::warn_attribute_type_not_supported) <<
attr << II;
7089 =
type.getQualifiers().getObjCLifetime()) {
7092 S.
Diag(AttrLoc, diag::err_attr_objc_ownership_redundant)
7099 if (previousLifetime != lifetime) {
7102 const Type *prevTy =
nullptr;
7103 while (!prevTy || prevTy != underlyingType.
Ty) {
7104 prevTy = underlyingType.
Ty;
7113 if (NonObjCPointer) {
7114 StringRef name =
attr.getAttrName()->getName();
7123 S.
Diag(AttrLoc, diag::warn_type_attribute_wrong_type) << name
7140 type = state.getAttributedType(
7141 createSimpleAttr<ObjCInertUnsafeUnretainedAttr>(S.
Context,
attr),
7147 if (!NonObjCPointer)
7164 diagnostic,
type, 0));
7166 S.
Diag(loc, diagnostic);
7175 unsigned diagnostic =
7176 (S.
getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled
7177 : diag::err_arc_weak_no_runtime);
7180 diagnoseOrDelay(S, AttrLoc, diagnostic,
type);
7192 if (
Class->isArcWeakrefUnavailable()) {
7193 S.
Diag(AttrLoc, diag::err_arc_unsupported_weak_class);
7194 S.
Diag(ObjT->getInterfaceDecl()->getLocation(),
7195 diag::note_class_declared);
7210 Sema &S = state.getSema();
7213 if (!
type->isPointerType() &&
7214 !
type->isObjCObjectPointerType() &&
7215 !
type->isBlockPointerType())
7219 S.
Diag(
attr.getLoc(), diag::err_attribute_multiple_objc_gc);
7225 if (!
attr.isArgIdent(0)) {
7226 S.
Diag(
attr.getLoc(), diag::err_attribute_argument_type)
7232 if (
attr.getNumArgs() > 1) {
7233 S.
Diag(
attr.getLoc(), diag::err_attribute_wrong_number_arguments) <<
attr
7240 if (II->
isStr(
"weak"))
7242 else if (II->
isStr(
"strong"))
7245 S.
Diag(
attr.getLoc(), diag::warn_attribute_type_not_supported)
7255 if (
attr.getLoc().isValid())
7256 type = state.getAttributedType(
7273 struct FunctionTypeUnwrapper {
7290 FunctionTypeUnwrapper(
Sema &S,
QualType T) : Original(T) {
7293 if (isa<FunctionType>(Ty)) {
7294 Fn = cast<FunctionType>(Ty);
7296 }
else if (isa<ParenType>(Ty)) {
7297 T = cast<ParenType>(Ty)->getInnerType();
7299 }
else if (isa<ConstantArrayType>(Ty) || isa<VariableArrayType>(Ty) ||
7300 isa<IncompleteArrayType>(Ty)) {
7301 T = cast<ArrayType>(Ty)->getElementType();
7302 Stack.push_back(Array);
7303 }
else if (isa<PointerType>(Ty)) {
7306 }
else if (isa<BlockPointerType>(Ty)) {
7308 Stack.push_back(BlockPointer);
7309 }
else if (isa<MemberPointerType>(Ty)) {
7311 Stack.push_back(MemberPointer);
7312 }
else if (isa<ReferenceType>(Ty)) {
7314 Stack.push_back(Reference);
7315 }
else if (isa<AttributedType>(Ty)) {
7316 T = cast<AttributedType>(Ty)->getEquivalentType();
7317 Stack.push_back(Attributed);
7318 }
else if (isa<MacroQualifiedType>(Ty)) {
7319 T = cast<MacroQualifiedType>(Ty)->getUnderlyingType();
7320 Stack.push_back(MacroQualified);
7329 Stack.push_back(Desugar);
7334 bool isFunctionType()
const {
return (Fn !=
nullptr); }
7339 if (New == get())
return Original;
7342 return wrap(S.
Context, Original, 0);
7347 if (I == Stack.size())
7356 return wrap(
C, SplitOld.
Ty, I);
7357 return C.getQualifiedType(wrap(
C, SplitOld.
Ty, I), SplitOld.
Quals);
7361 if (I == Stack.size())
return QualType(Fn, 0);
7363 switch (
static_cast<WrapKind
>(Stack[I++])) {
7370 return wrap(
C, cast<AttributedType>(Old)->getEquivalentType(), I);
7373 QualType New = wrap(
C, cast<ParenType>(Old)->getInnerType(), I);
7374 return C.getParenType(New);
7377 case MacroQualified:
7381 if (
const auto *CAT = dyn_cast<ConstantArrayType>(Old)) {
7382 QualType New = wrap(
C, CAT->getElementType(), I);
7383 return C.getConstantArrayType(New, CAT->getSize(), CAT->getSizeExpr(),
7384 CAT->getSizeModifier(),
7385 CAT->getIndexTypeCVRQualifiers());
7388 if (
const auto *VAT = dyn_cast<VariableArrayType>(Old)) {
7389 QualType New = wrap(
C, VAT->getElementType(), I);
7390 return C.getVariableArrayType(
7391 New, VAT->getSizeExpr(), VAT->getSizeModifier(),
7392 VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange());
7395 const auto *IAT = cast<IncompleteArrayType>(Old);
7396 QualType New = wrap(
C, IAT->getElementType(), I);
7397 return C.getIncompleteArrayType(New, IAT->getSizeModifier(),
7398 IAT->getIndexTypeCVRQualifiers());
7402 QualType New = wrap(
C, cast<PointerType>(Old)->getPointeeType(), I);
7403 return C.getPointerType(New);
7406 case BlockPointer: {
7407 QualType New = wrap(
C, cast<BlockPointerType>(Old)->getPointeeType(),I);
7408 return C.getBlockPointerType(New);
7411 case MemberPointer: {
7414 return C.getMemberPointerType(New, OldMPT->
getClass());
7420 if (isa<LValueReferenceType>(OldRef))
7423 return C.getRValueReferenceType(New);
7427 llvm_unreachable(
"unknown wrapping kind");
7434 Sema &S = State.getSema();
7438 default: llvm_unreachable(
"Unknown attribute kind");
7439 case ParsedAttr::AT_Ptr32:
7440 A = createSimpleAttr<Ptr32Attr>(S.
Context, PAttr);
7442 case ParsedAttr::AT_Ptr64:
7443 A = createSimpleAttr<Ptr64Attr>(S.
Context, PAttr);
7445 case ParsedAttr::AT_SPtr:
7446 A = createSimpleAttr<SPtrAttr>(S.
Context, PAttr);
7448 case ParsedAttr::AT_UPtr:
7449 A = createSimpleAttr<UPtrAttr>(S.
Context, PAttr);
7453 std::bitset<attr::LastAttr> Attrs;
7456 if (
const TypedefType *TT = dyn_cast<TypedefType>(Desugared)) {
7457 Desugared = TT->desugar();
7459 }
else if (
const ElaboratedType *ET = dyn_cast<ElaboratedType>(Desugared)) {
7460 Desugared = ET->desugar();
7473 if (Attrs[NewAttrKind]) {
7474 S.
Diag(PAttr.
getLoc(), diag::warn_duplicate_attribute_exact) << PAttr;
7477 Attrs[NewAttrKind] =
true;
7481 if (Attrs[attr::Ptr32] && Attrs[attr::Ptr64]) {
7482 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
7484 <<
"'__ptr64'" << 0;
7486 }
else if (Attrs[attr::SPtr] && Attrs[attr::UPtr]) {
7487 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
7495 if (!isa<PointerType>(Desugared)) {
7499 S.
Diag(PAttr.
getLoc(), diag::err_attribute_no_member_pointers) << PAttr;
7501 S.
Diag(PAttr.
getLoc(), diag::err_attribute_pointers_only) << PAttr << 0;
7509 if (PtrWidth == 32) {
7510 if (Attrs[attr::Ptr64])
7512 else if (Attrs[attr::UPtr])
7514 }
else if (PtrWidth == 64 && Attrs[attr::Ptr32]) {
7515 if (Attrs[attr::UPtr])
7531 assert(PAttr.
getKind() == ParsedAttr::AT_WebAssemblyFuncref);
7533 Sema &S = State.getSema();
7534 Attr *A = createSimpleAttr<WebAssemblyFuncrefAttr>(S.
Context, PAttr);
7536 std::bitset<attr::LastAttr> Attrs;
7538 const auto *AT = dyn_cast<AttributedType>(QT);
7540 Attrs[AT->getAttrKind()] =
true;
7541 AT = dyn_cast<AttributedType>(AT->getModifiedType());
7546 if (Attrs[NewAttrKind]) {
7547 S.
Diag(PAttr.
getLoc(), diag::warn_duplicate_attribute_exact) << PAttr;
7563 auto Attributed = dyn_cast<AttributedType>(
Type.getTypePtr());
7568 if (Attributed->getImmediateNullability())
7569 return Attributed->getModifiedType();
7573 Ctx, Attributed->getModifiedType());
7574 assert(Modified.
getTypePtr() != Attributed->getModifiedType().getTypePtr());
7576 Attributed->getEquivalentType());
7582 case ParsedAttr::AT_TypeNonNull:
7585 case ParsedAttr::AT_TypeNullable:
7588 case ParsedAttr::AT_TypeNullableResult:
7591 case ParsedAttr::AT_TypeNullUnspecified:
7595 llvm_unreachable(
"not a nullability attribute kind");
7602 bool IsContextSensitive,
bool AllowOnArrayType,
bool OverrideExisting) {
7603 bool Implicit = (State ==
nullptr);
7609 while (
auto *Attributed = dyn_cast<AttributedType>(Desugared.
getTypePtr())) {
7611 if (
auto ExistingNullability = Attributed->getImmediateNullability()) {
7613 if (Nullability == *ExistingNullability) {
7617 S.
Diag(NullabilityLoc, diag::warn_nullability_duplicate)
7624 if (!OverrideExisting) {
7626 S.
Diag(NullabilityLoc, diag::err_nullability_conflicting)
7636 Desugared = Attributed->getModifiedType();
7644 if (Nullability != *ExistingNullability && !Implicit) {
7645 S.
Diag(NullabilityLoc, diag::err_nullability_conflicting)
7653 if (
auto typedefNullability =
7655 if (*typedefNullability == *ExistingNullability) {
7668 !(AllowOnArrayType && Desugared->
isArrayType())) {
7670 S.
Diag(NullabilityLoc, diag::err_nullability_nonpointer)
7678 if (IsContextSensitive) {
7680 const Type *pointeeType =
nullptr;
7689 S.
Diag(NullabilityLoc, diag::err_nullability_cs_multilevel)
7691 S.
Diag(NullabilityLoc, diag::note_nullability_type_specifier)
7703 QT = State->getAttributedType(A, QT, QT);
7713 bool AllowOnArrayType) {
7719 Nullability, NullabilityLoc,
7720 IsContextSensitive, AllowOnArrayType,
7727 bool AllowArrayTypes,
7728 bool OverrideExisting) {
7730 *
this,
nullptr,
nullptr,
Type, Nullability, DiagLoc,
7731 false, AllowArrayTypes, OverrideExisting);
7738 Sema &S = state.getSema();
7740 if (isa<ObjCTypeParamType>(
type)) {
7742 type = state.getAttributedType(
7755 S.
Diag(
attr.getLoc(), diag::err_objc_kindof_nonobject)
7764 objType->getBaseType(), objType->getTypeArgsAsWritten(),
7765 objType->getProtocols(),
7766 objType->isObjCUnqualifiedId() ?
false :
true);
7771 if (
auto nullability =
type->getNullability()) {
7774 assert(
attr.getAttributeSpellingListIndex() == 0 &&
7775 "multiple spellings for __kindof?");
7778 equivType = state.getAttributedType(A, equivType, equivType);
7783 type = state.getAttributedType(
7796 Declarator &declarator = state.getDeclarator();
7799 auto moveToChunk = [&](
DeclaratorChunk &chunk,
bool inFunction) ->
bool {
7812 PK_MemberFunctionPointer,
7817 : inFunction? PK_MemberFunctionPointer : PK_MemberPointer;
7819 auto diag = state.getSema().Diag(
attr.getLoc(),
7820 diag::warn_nullability_declspec)
7822 attr.isContextSensitiveKeywordAttribute())
7824 <<
static_cast<unsigned>(pointerKind);
7830 state.getSema().getPreprocessor().getLocForEndOfToken(
7832 " " +
attr.getAttrName()->getName().str() +
" ");
7842 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
7844 switch (chunk.
Kind) {
7848 return moveToChunk(chunk,
false);
7860 return moveToChunk(*dest,
true);
7876 assert(!
Attr.isInvalid());
7879 llvm_unreachable(
"not a calling convention attribute");
7880 case ParsedAttr::AT_CDecl:
7881 return createSimpleAttr<CDeclAttr>(Ctx,
Attr);
7882 case ParsedAttr::AT_FastCall:
7883 return createSimpleAttr<FastCallAttr>(Ctx,
Attr);
7884 case ParsedAttr::AT_StdCall:
7885 return createSimpleAttr<StdCallAttr>(Ctx,
Attr);
7886 case ParsedAttr::AT_ThisCall:
7887 return createSimpleAttr<ThisCallAttr>(Ctx,
Attr);
7888 case ParsedAttr::AT_RegCall:
7889 return createSimpleAttr<RegCallAttr>(Ctx,
Attr);
7890 case ParsedAttr::AT_Pascal:
7891 return createSimpleAttr<PascalAttr>(Ctx,
Attr);
7892 case ParsedAttr::AT_SwiftCall:
7893 return createSimpleAttr<SwiftCallAttr>(Ctx,
Attr);
7894 case ParsedAttr::AT_SwiftAsyncCall:
7895 return createSimpleAttr<SwiftAsyncCallAttr>(Ctx,
Attr);
7896 case ParsedAttr::AT_VectorCall:
7897 return createSimpleAttr<VectorCallAttr>(Ctx,
Attr);
7898 case ParsedAttr::AT_AArch64VectorPcs:
7899 return createSimpleAttr<AArch64VectorPcsAttr>(Ctx,
Attr);
7900 case ParsedAttr::AT_AArch64SVEPcs:
7901 return createSimpleAttr<AArch64SVEPcsAttr>(Ctx,
Attr);
7902 case ParsedAttr::AT_ArmStreaming:
7903 return createSimpleAttr<ArmStreamingAttr>(Ctx,
Attr);
7904 case ParsedAttr::AT_AMDGPUKernelCall:
7905 return createSimpleAttr<AMDGPUKernelCallAttr>(Ctx,
Attr);
7906 case ParsedAttr::AT_Pcs: {
7911 if (
Attr.isArgExpr(0))
7912 Str = cast<StringLiteral>(
Attr.getArgAsExpr(0))->getString();
7914 Str =
Attr.getArgAsIdent(0)->Ident->getName();
7915 PcsAttr::PCSType
Type;
7916 if (!PcsAttr::ConvertStrToPCSType(Str,
Type))
7917 llvm_unreachable(
"already validated the attribute");
7918 return ::new (Ctx) PcsAttr(Ctx,
Attr,
Type);
7920 case ParsedAttr::AT_IntelOclBicc:
7921 return createSimpleAttr<IntelOclBiccAttr>(Ctx,
Attr);
7922 case ParsedAttr::AT_MSABI:
7923 return createSimpleAttr<MSABIAttr>(Ctx,
Attr);
7924 case ParsedAttr::AT_SysVABI:
7925 return createSimpleAttr<SysVABIAttr>(Ctx,
Attr);
7926 case ParsedAttr::AT_PreserveMost:
7927 return createSimpleAttr<PreserveMostAttr>(Ctx,
Attr);
7928 case ParsedAttr::AT_PreserveAll:
7929 return createSimpleAttr<PreserveAllAttr>(Ctx,
Attr);
7930 case ParsedAttr::AT_M68kRTD:
7931 return createSimpleAttr<M68kRTDAttr>(Ctx,
Attr);
7932 case ParsedAttr::AT_PreserveNone:
7933 return createSimpleAttr<PreserveNoneAttr>(Ctx,
Attr);
7935 llvm_unreachable(
"unexpected attribute kind!");
7942 auto OtherAttr = std::find_if(
7943 state.getCurrentAttributes().begin(), state.getCurrentAttributes().end(),
7944 [OtherKind](
const ParsedAttr &A) { return A.getKind() == OtherKind; });
7945 if (OtherAttr == state.getCurrentAttributes().end() || OtherAttr->isInvalid())
7948 Sema &S = state.getSema();
7950 << *OtherAttr <<
Attr
7951 << (OtherAttr->isRegularKeywordAttribute() ||
7953 S.
Diag(OtherAttr->getLoc(), diag::note_conflicting_attribute);
7962 if (!
Attr.getNumArgs()) {
7968 for (
unsigned I = 0; I <
Attr.getNumArgs(); ++I) {
7969 StringRef StateName;
7976 if (StateName ==
"za") {
7979 }
else if (StateName ==
"zt0") {
7983 S.
Diag(LiteralLoc, diag::err_unknown_arm_state) << StateName;
7992 S.
Diag(LiteralLoc, diag::err_conflicting_attributes_arm_state)
8009 Sema &S = state.getSema();
8011 FunctionTypeUnwrapper unwrapped(S,
type);
8013 if (
attr.getKind() == ParsedAttr::AT_NoReturn) {
8018 if (!unwrapped.isFunctionType())
8027 if (
attr.getKind() == ParsedAttr::AT_CmseNSCall) {
8029 if (!unwrapped.isFunctionType())
8034 S.
Diag(
attr.getLoc(), diag::warn_attribute_ignored) <<
attr;
8041 unwrapped.get()->getExtInfo().withCmseNSCall(
true);
8048 if (
attr.getKind() == ParsedAttr::AT_NSReturnsRetained) {
8049 if (
attr.getNumArgs())
return true;
8052 if (!unwrapped.isFunctionType())
8057 unwrapped.get()->getReturnType()))
8062 if (state.getSema().getLangOpts().ObjCAutoRefCount) {
8064 = unwrapped.get()->getExtInfo().withProducesResult(
true);
8067 type = state.getAttributedType(
8068 createSimpleAttr<NSReturnsRetainedAttr>(S.
Context,
attr),
8073 if (
attr.getKind() == ParsedAttr::AT_AnyX86NoCallerSavedRegisters) {
8078 if (!unwrapped.isFunctionType())
8082 unwrapped.get()->getExtInfo().withNoCallerSavedRegs(
true);
8087 if (
attr.getKind() == ParsedAttr::AT_AnyX86NoCfCheck) {
8089 S.
Diag(
attr.getLoc(), diag::warn_nocf_check_attribute_ignored);
8099 if (!unwrapped.isFunctionType())
8103 unwrapped.get()->getExtInfo().withNoCfCheck(
true);
8108 if (
attr.getKind() == ParsedAttr::AT_Regparm) {
8114 if (!unwrapped.isFunctionType())
8121 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
8123 <<
attr.isRegularKeywordAttribute();
8129 unwrapped.get()->getExtInfo().withRegParm(value);
8134 if (
attr.getKind() == ParsedAttr::AT_ArmStreaming ||
8135 attr.getKind() == ParsedAttr::AT_ArmStreamingCompatible ||
8136 attr.getKind() == ParsedAttr::AT_ArmPreserves ||
8137 attr.getKind() == ParsedAttr::AT_ArmIn ||
8138 attr.getKind() == ParsedAttr::AT_ArmOut ||
8139 attr.getKind() == ParsedAttr::AT_ArmInOut) {
8143 if (
attr.getKind() == ParsedAttr::AT_ArmStreaming ||
8144 attr.getKind() == ParsedAttr::AT_ArmStreamingCompatible)
8148 if (!unwrapped.isFunctionType())
8155 S.
Diag(
attr.getLoc(), diag::warn_attribute_wrong_decl_type) <<
8162 switch (
attr.getKind()) {
8163 case ParsedAttr::AT_ArmStreaming:
8165 ParsedAttr::AT_ArmStreamingCompatible))
8169 case ParsedAttr::AT_ArmStreamingCompatible:
8174 case ParsedAttr::AT_ArmPreserves:
8178 case ParsedAttr::AT_ArmIn:
8182 case ParsedAttr::AT_ArmOut:
8186 case ParsedAttr::AT_ArmInOut:
8191 llvm_unreachable(
"Unsupported attribute");
8195 FnTy->getParamTypes(), EPI);
8200 if (
attr.getKind() == ParsedAttr::AT_NoThrow) {
8202 if (!unwrapped.isFunctionType())
8215 if (Proto->hasExceptionSpec()) {
8216 switch (Proto->getExceptionSpecType()) {
8218 llvm_unreachable(
"This doesn't have an exception spec!");
8236 S.
Diag(
attr.getLoc(), diag::warn_nothrow_attribute_ignored);
8242 type = unwrapped.wrap(
8252 if (!unwrapped.isFunctionType())
return false;
8267 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
8270 <<
attr.isRegularKeywordAttribute();
8289 return S.
Diag(
attr.getLoc(), diag::warn_cconv_unsupported)
8294 return S.
Diag(
attr.getLoc(), diag::err_cconv_varargs)
8301 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
8303 <<
attr.isRegularKeywordAttribute();
8315 auto EI = unwrapped.get()->getExtInfo().withCallingConv(CC);
8339 FunctionTypeUnwrapper Unwrapped(*
this, T);
8341 bool IsVariadic = (isa<FunctionProtoType>(FT) &&
8342 cast<FunctionProtoType>(FT)->isVariadic());
8356 Diag(Loc, diag::warn_cconv_unsupported)
8367 if (CurCC != DefaultCC)
8375 QualType Wrapped = Unwrapped.wrap(*
this, FT);
8389 if (
Attr.getNumArgs() != 1) {
8396 Expr *SizeExpr =
Attr.getArgAsExpr(0);
8409 if (
Attr.getNumArgs() != 1) {
8415 Expr *SizeExpr =
Attr.getArgAsExpr(0);
8430 bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 ||
8431 Triple.getArch() == llvm::Triple::aarch64_32 ||
8432 Triple.getArch() == llvm::Triple::aarch64_be;
8434 if (IsPolyUnsigned) {
8436 return BTy->
getKind() == BuiltinType::UChar ||
8437 BTy->
getKind() == BuiltinType::UShort ||
8438 BTy->
getKind() == BuiltinType::ULong ||
8439 BTy->
getKind() == BuiltinType::ULongLong;
8442 return BTy->
getKind() == BuiltinType::SChar ||
8443 BTy->
getKind() == BuiltinType::Short ||
8444 BTy->
getKind() == BuiltinType::LongLong;
8450 if ((Triple.isArch64Bit() || Triple.getArch() == llvm::Triple::aarch64_32) &&
8451 BTy->
getKind() == BuiltinType::Double)
8454 return BTy->
getKind() == BuiltinType::SChar ||
8455 BTy->
getKind() == BuiltinType::UChar ||
8456 BTy->
getKind() == BuiltinType::Short ||
8457 BTy->
getKind() == BuiltinType::UShort ||
8458 BTy->
getKind() == BuiltinType::Int ||
8459 BTy->
getKind() == BuiltinType::UInt ||
8460 BTy->
getKind() == BuiltinType::Long ||
8461 BTy->
getKind() == BuiltinType::ULong ||
8462 BTy->
getKind() == BuiltinType::LongLong ||
8463 BTy->
getKind() == BuiltinType::ULongLong ||
8464 BTy->
getKind() == BuiltinType::Float ||
8465 BTy->
getKind() == BuiltinType::Half ||
8466 BTy->
getKind() == BuiltinType::BFloat16;
8471 const auto *AttrExpr =
Attr.getArgAsExpr(0);
8472 if (!AttrExpr->isTypeDependent()) {
8473 if (std::optional<llvm::APSInt> Res =
8474 AttrExpr->getIntegerConstantExpr(S.
Context)) {
8494 bool IsTargetCUDAAndHostARM =
false;
8497 IsTargetCUDAAndHostARM =
8507 IsTargetCUDAAndHostARM) &&
8510 <<
Attr <<
"'neon', 'mve', 'sve' or 'sme'";
8516 IsTargetCUDAAndHostARM) &&
8519 <<
Attr <<
"'neon' or 'mve'";
8525 if (
Attr.getNumArgs() != 1) {
8526 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8532 llvm::APSInt numEltsInt(32);
8538 !IsTargetCUDAAndHostARM) {
8539 S.
Diag(
Attr.
getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
8546 unsigned numElts =
static_cast<unsigned>(numEltsInt.getZExtValue());
8547 unsigned vecSize = typeSize * numElts;
8548 if (vecSize != 64 && vecSize != 128) {
8549 S.
Diag(
Attr.
getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType;
8573 S.
Diag(
Attr.
getLoc(), diag::err_attribute_arm_feature_sve_bits_unsupported)
8580 if (
Attr.getNumArgs() != 1) {
8581 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8588 llvm::APSInt SveVectorSizeInBits(32);
8592 unsigned VecSize =
static_cast<unsigned>(SveVectorSizeInBits.getZExtValue());
8615 if (BT->getKind() == BuiltinType::SveBool) {
8620 VecSize /= TypeSize;
8627 const VectorType *VT = dyn_cast<VectorType>(CurType);
8630 diag::err_attribute_arm_mve_polymorphism);
8636 State.getAttributedType(createSimpleAttr<ArmMveStrictPolymorphismAttr>(
8637 State.getSema().Context,
Attr),
8649 <<
Attr <<
"'zve32x'";
8655 if (!VScale || !VScale->first || VScale->first != VScale->second) {
8656 S.
Diag(
Attr.
getLoc(), diag::err_attribute_riscv_rvv_bits_unsupported)
8663 if (
Attr.getNumArgs() != 1) {
8664 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8671 llvm::APSInt RVVVectorSizeInBits(32);
8683 unsigned VecSize =
static_cast<unsigned>(RVVVectorSizeInBits.getZExtValue());
8687 unsigned MinElts = Info.
EC.getKnownMinValue();
8690 unsigned ExpectedSize = VScale->first * MinElts;
8698 ExpectedSize *= EltSize;
8699 NumElts = VecSize / EltSize;
8703 if (ExpectedSize % 8 != 0 || VecSize != ExpectedSize) {
8705 << VecSize << ExpectedSize;
8718 S.
Diag(
Attr.
getLoc(), diag::err_opencl_invalid_access_qualifier);
8724 QualType BaseTy = TypedefTy->desugar();
8726 std::string PrevAccessQual;
8728 if (TypedefTy->getDecl()->hasAttr<OpenCLAccessAttr>()) {
8729 OpenCLAccessAttr *
Attr =
8730 TypedefTy->getDecl()->getAttr<OpenCLAccessAttr>();
8733 PrevAccessQual =
"read_only";
8737 switch (ImgType->getKind()) {
8738 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8739 case BuiltinType::Id: \
8740 PrevAccessQual = #Access; \
8742 #include "clang/Basic/OpenCLImageTypes.def"
8744 llvm_unreachable(
"Unable to find corresponding image type.");
8747 llvm_unreachable(
"unexpected type");
8750 if (PrevAccessQual == AttrName.ltrim(
"_")) {
8756 S.
Diag(
Attr.
getLoc(), diag::err_opencl_multiple_access_qualifiers);
8759 S.
Diag(TypedefTy->getDecl()->getBeginLoc(),
8760 diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;
8762 if (
Attr.getSemanticSpelling() == OpenCLAccessAttr::Keyword_write_only) {
8777 if (
Attr.getNumArgs() != 2) {
8778 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8783 Expr *RowsExpr =
Attr.getArgAsExpr(0);
8784 Expr *ColsExpr =
Attr.getArgAsExpr(1);
8792 Sema &S = State.getSema();
8795 S.
Diag(PA.
getLoc(), diag::err_attribute_too_few_arguments) << PA << 1;
8807 for (
unsigned Idx = 1; Idx < PA.
getNumArgs(); Idx++) {
8813 auto *AnnotateTypeAttr =
8814 AnnotateTypeAttr::Create(S.
Context, Str, Args.data(), Args.size(), PA);
8815 CurType = State.getAttributedType(AnnotateTypeAttr, CurType, CurType);
8821 if (State.getDeclarator().isDeclarationOfFunction()) {
8822 CurType = State.getAttributedType(
8823 createSimpleAttr<LifetimeBoundAttr>(State.getSema().Context,
Attr),
8834 if (
Attr.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_inout ||
8835 Attr.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_out)
8844 state.setParsedNoDeref(
false);
8860 if (
attr.isInvalid())
8863 if (
attr.isStandardAttributeSyntax() ||
attr.isRegularKeywordAttribute()) {
8868 if (
attr.isGNUScope()) {
8869 assert(
attr.isStandardAttributeSyntax());
8870 bool IsTypeAttr =
attr.isTypeAttr();
8872 state.getSema().Diag(
attr.getLoc(),
8874 ? diag::warn_gcc_ignores_type_attr
8875 : diag::warn_cxx11_gnu_attribute_on_type)
8881 !
attr.isTypeAttr()) {
8894 switch (
attr.getKind()) {
8897 if ((
attr.isStandardAttributeSyntax() ||
8898 attr.isRegularKeywordAttribute()) &&
8900 state.getSema().Diag(
attr.getLoc(), diag::err_attribute_not_type_attr)
8901 <<
attr <<
attr.isRegularKeywordAttribute();
8902 attr.setUsedAsTypeAttr();
8907 if (
attr.isStandardAttributeSyntax()) {
8908 state.getSema().Diag(
attr.getLoc(),
8909 diag::warn_unknown_attribute_ignored)
8920 case ParsedAttr::AT_BTFTypeTag:
8922 attr.setUsedAsTypeAttr();
8925 case ParsedAttr::AT_MayAlias:
8928 attr.setUsedAsTypeAttr();
8930 case ParsedAttr::AT_OpenCLPrivateAddressSpace:
8931 case ParsedAttr::AT_OpenCLGlobalAddressSpace:
8932 case ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace:
8933 case ParsedAttr::AT_OpenCLGlobalHostAddressSpace:
8934 case ParsedAttr::AT_OpenCLLocalAddressSpace:
8935 case ParsedAttr::AT_OpenCLConstantAddressSpace:
8936 case ParsedAttr::AT_OpenCLGenericAddressSpace:
8937 case ParsedAttr::AT_HLSLGroupSharedAddressSpace:
8938 case ParsedAttr::AT_AddressSpace:
8940 attr.setUsedAsTypeAttr();
8945 attr.setUsedAsTypeAttr();
8947 case ParsedAttr::AT_VectorSize:
8949 attr.setUsedAsTypeAttr();
8951 case ParsedAttr::AT_ExtVectorType:
8953 attr.setUsedAsTypeAttr();
8955 case ParsedAttr::AT_NeonVectorType:
8957 attr.setUsedAsTypeAttr();
8959 case ParsedAttr::AT_NeonPolyVectorType:
8962 attr.setUsedAsTypeAttr();
8964 case ParsedAttr::AT_ArmSveVectorBits:
8966 attr.setUsedAsTypeAttr();
8968 case ParsedAttr::AT_ArmMveStrictPolymorphism: {
8970 attr.setUsedAsTypeAttr();
8973 case ParsedAttr::AT_RISCVRVVVectorBits:
8975 attr.setUsedAsTypeAttr();
8977 case ParsedAttr::AT_OpenCLAccess:
8979 attr.setUsedAsTypeAttr();
8981 case ParsedAttr::AT_LifetimeBound:
8986 case ParsedAttr::AT_NoDeref: {
8991 if (
attr.isStandardAttributeSyntax()) {
8992 state.getSema().Diag(
attr.getLoc(), diag::warn_attribute_ignored)
8997 type = state.getAttributedType(createSimpleAttr<NoDerefAttr>(Ctx,
attr),
8999 attr.setUsedAsTypeAttr();
9000 state.setParsedNoDeref(
true);
9004 case ParsedAttr::AT_MatrixType:
9006 attr.setUsedAsTypeAttr();
9009 case ParsedAttr::AT_WebAssemblyFuncref: {
9011 attr.setUsedAsTypeAttr();
9015 case ParsedAttr::AT_HLSLParamModifier: {
9017 attr.setUsedAsTypeAttr();
9023 attr.setUsedAsTypeAttr();
9031 if (
type->canHaveNullability() ||
type->isDependentType() ||
9032 type->isArrayType() ||
9036 endIndex = state.getCurrentChunkIndex();
9038 endIndex = state.getDeclarator().getNumTypeObjects();
9039 bool allowOnArrayType =
9040 state.getDeclarator().isPrototypeContext() &&
9043 allowOnArrayType)) {
9047 attr.setUsedAsTypeAttr();
9051 case ParsedAttr::AT_ObjCKindOf:
9059 state.getSema().Diag(
attr.getLoc(),
9060 diag::err_objc_kindof_wrong_position)
9063 state.getDeclarator().getDeclSpec().getBeginLoc(),
9073 case ParsedAttr::AT_NoThrow:
9076 if (!state.getSema().getLangOpts().CPlusPlus)
9080 attr.setUsedAsTypeAttr();
9084 if (
attr.isStandardAttributeSyntax() ||
9085 attr.isRegularKeywordAttribute()) {
9102 case ParsedAttr::AT_AcquireHandle: {
9103 if (!
type->isFunctionType())
9106 if (
attr.getNumArgs() != 1) {
9107 state.getSema().Diag(
attr.getLoc(),
9108 diag::err_attribute_wrong_number_arguments)
9114 StringRef HandleType;
9115 if (!state.getSema().checkStringLiteralArgumentAttr(
attr, 0, HandleType))
9117 type = state.getAttributedType(
9118 AcquireHandleAttr::Create(state.getSema().Context, HandleType,
attr),
9120 attr.setUsedAsTypeAttr();
9123 case ParsedAttr::AT_AnnotateType: {
9125 attr.setUsedAsTypeAttr();
9132 if (isa<AttributedType>(
type) &&
attr.hasMacroIdentifier() &&
9133 !
type.getQualifiers().hasObjCLifetime() &&
9134 !
type.getQualifiers().hasObjCGCAttr() &&
9135 attr.getKind() != ParsedAttr::AT_ObjCGC &&
9136 attr.getKind() != ParsedAttr::AT_ObjCOwnership) {
9138 type = state.getSema().Context.getMacroQualifiedType(
type, MacroII);
9139 state.setExpansionLocForMacroQualifiedType(
9140 cast<MacroQualifiedType>(
type.getTypePtr()),
9141 attr.getMacroExpansionLoc());
9148 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
9150 auto *Def = Var->getDefinition();
9156 Def = Var->getDefinition();
9163 if (Var->getPointOfInstantiation().isInvalid() && Def) {
9164 assert(Var->getTemplateSpecializationKind() ==
9166 "explicit instantiation with no point of instantiation");
9167 Var->setTemplateSpecializationKind(
9168 Var->getTemplateSpecializationKind(), PointOfInstantiation);
9252 if (RequireCompleteTypeImpl(Loc, T, Kind, &Diagnoser))
9255 if (!Tag->getDecl()->isCompleteDefinitionRequired()) {
9256 Tag->getDecl()->setCompleteDefinitionRequired();
9286 if (isa<TagDecl>(D) && cast<TagDecl>(D)->isBeingDefined()) {
9290 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
9291 if (
auto *Pattern = RD->getTemplateInstantiationPattern())
9293 D = RD->getDefinition();
9294 }
else if (
auto *ED = dyn_cast<EnumDecl>(D)) {
9295 if (
auto *Pattern = ED->getTemplateInstantiationPattern())
9297 if (OnlyNeedComplete && (ED->isFixed() ||
getLangOpts().MSVCCompat)) {
9303 *Suggested =
nullptr;
9304 for (
auto *Redecl : ED->redecls()) {
9307 if (Redecl->isThisDeclarationADefinition() ||
9308 (Redecl->isCanonicalDecl() && !*Suggested))
9309 *Suggested = Redecl;
9314 D = ED->getDefinition();
9315 }
else if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
9316 if (
auto *Pattern = FD->getTemplateInstantiationPattern())
9318 D = FD->getDefinition();
9319 }
else if (
auto *VD = dyn_cast<VarDecl>(D)) {
9320 if (
auto *Pattern = VD->getTemplateInstantiationPattern())
9322 D = VD->getDefinition();
9325 assert(D &&
"missing definition for pattern of instantiated definition");
9329 auto DefinitionIsAcceptable = [&] {
9349 if (DefinitionIsAcceptable())
9355 Source->CompleteRedeclChain(D);
9356 return DefinitionIsAcceptable();
9372 bool OnlyNeedComplete) {
9389 bool OnlyNeedComplete) {
9397 if (!RD->
hasAttr<MSInheritanceAttr>()) {
9399 bool BestCase =
false;
9419 RD->
addAttr(MSInheritanceAttr::CreateImplicit(
9420 S.
getASTContext(), BestCase, Loc, MSInheritanceAttr::Spelling(IM)));
9427 CompleteTypeKind Kind,
9428 TypeDiagnoser *Diagnoser) {
9438 if (!MPTy->getClass()->isDependentType()) {
9440 !MPTy->getClass()->getAsCXXRecordDecl()->isBeingDefined() &&
9442 diag::err_memptr_incomplete))
9461 if (Def && !isa<EnumDecl>(Def))
9472 if (Diagnoser && Suggested)
9475 return !TreatAsComplete;
9477 CodeSynthesisContext TempInst;
9479 TempInst.Template = Def;
9480 TempInst.Entity = Def;
9481 TempInst.PointOfInstantiation = Loc;
9489 TagDecl *Tag = dyn_cast_or_null<TagDecl>(Def);
9504 Source->CompleteType(Tag);
9506 Source->CompleteType(IFace);
9510 return RequireCompleteTypeImpl(Loc, T, Kind, Diagnoser);
9517 if (
auto *RD = dyn_cast_or_null<CXXRecordDecl>(Tag)) {
9518 bool Instantiated =
false;
9519 bool Diagnosed =
false;
9520 if (RD->isDependentContext()) {
9524 }
else if (
auto *ClassTemplateSpec =
9525 dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
9526 if (ClassTemplateSpec->getSpecializationKind() ==
TSK_Undeclared) {
9532 Instantiated =
true;
9536 if (!RD->isBeingDefined() && Pattern) {
9538 assert(MSI &&
"Missing member specialization information?");
9548 Instantiated =
true;
9556 if (Diagnoser && Diagnosed)
9562 return RequireCompleteTypeImpl(Loc, T, Kind, Diagnoser);
9572 Diagnoser->diagnose(*
this, Loc, T);
9579 : diag::note_forward_declaration)
9613 default: llvm_unreachable(
"Invalid tag kind for literal type diagnostic!");
9675 for (
const auto &I : RD->
vbases())
9676 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
9677 << I.getSourceRange();
9680 Diag(RD->
getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD;
9682 for (
const auto &I : RD->
bases()) {
9683 if (!I.getType()->isLiteralType(
Context)) {
9684 Diag(I.getBeginLoc(), diag::note_non_literal_base_class)
9685 << RD << I.getType() << I.getSourceRange();
9689 for (
const auto *I : RD->
fields()) {
9690 if (!I->getType()->isLiteralType(
Context) ||
9691 I->getType().isVolatileQualified()) {
9692 Diag(I->getLocation(), diag::note_non_literal_field)
9693 << RD << I << I->getType()
9694 << I->getType().isVolatileQualified();
9704 assert(Dtor &&
"class has literal fields and bases but no dtor?");
9713 ? diag::note_non_literal_user_provided_dtor
9714 : diag::note_non_literal_nontrivial_dtor)
9765 if (
auto *ImplCastExpr = dyn_cast<ImplicitCastExpr>(E))
9766 IDExpr = ImplCastExpr->getSubExpr();
9768 if (
auto *PackExpr = dyn_cast<PackIndexingExpr>(E))
9769 IDExpr = PackExpr->getSelectedExpr();
9781 if (
const auto *SNTTPE = dyn_cast<SubstNonTypeTemplateParmExpr>(IDExpr))
9782 return SNTTPE->getParameterType(
Context);
9790 if (
const auto *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
9795 if (
const auto *ME = dyn_cast<MemberExpr>(IDExpr)) {
9796 if (
const auto *VD = ME->getMemberDecl())
9797 if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
9798 return VD->getType();
9799 }
else if (
const auto *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
9800 return IR->getDecl()->getType();
9801 }
else if (
const auto *PR = dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {
9802 if (PR->isExplicitProperty())
9803 return PR->getExplicitProperty()->getType();
9804 }
else if (
const auto *PE = dyn_cast<PredefinedExpr>(IDExpr)) {
9805 return PE->getType();
9816 if (
auto *DRE = dyn_cast<DeclRefExpr>(IDExpr->
IgnoreParens())) {
9817 if (
auto *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
9837 Diag(E->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
9850 Diag(Loc, diag::err_expected_name_of_pack) << Pattern;
9856 : diag::ext_pack_indexing);
9863 bool FullySubstituted,
9866 std::optional<int64_t> Index;
9874 Index =
Value.getExtValue();
9875 IndexExpr = Res.
get();
9878 if (FullySubstituted && Index) {
9879 if (*Index < 0 || *Index >= int64_t(Expansions.size())) {
9881 << *Index << Pattern << Expansions.size();
9887 Expansions, Index.value_or(-1));
9894 assert(ED &&
"EnumType has no EnumDecl");
9899 assert(!Underlying.
isNull());
9907 Diag(Loc, diag::err_only_enums_have_underlying_types);
9915 Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
9916 Diag(FwdDecl->
getLocation(), diag::note_forward_declaration) << FwdDecl;
9952 Split.Quals.removeCVRQualifiers();
9962 UKind == UnaryTransformType::AddLvalueReference,
9965 return Reference.isNull() ?
QualType() : Reference;
9970 if (UKind == UnaryTransformType::RemoveAllExtents)
9974 return AT->getElementType();
9983 if (UKind == UTTKind::RemoveCVRef &&
9996 if ((BaseType->
isReferenceType() && UKind != UTTKind::RemoveRestrict) ||
10003 if (UKind == UTTKind::RemoveConst || UKind == UTTKind::RemoveCV)
10005 if (UKind == UTTKind::RemoveVolatile || UKind == UTTKind::RemoveCV)
10007 if (UKind == UTTKind::RemoveRestrict)
10018 if (
auto *
BitInt = dyn_cast<BitIntType>(Underlying)) {
10019 unsigned int Bits =
BitInt->getNumBits();
10023 S.
Diag(Loc, diag::err_make_signed_integral_only)
10024 << IsMakeSigned <<
true << BaseType << 1 << Underlying;
10028 S.
Diag(Loc, diag::err_make_signed_integral_only)
10029 << IsMakeSigned <<
false << BaseType << 1
10036 std::array<CanQualType *, 6> AllSignedIntegers = {
10040 AllSignedIntegers.data(), AllSignedIntegers.size() - Int128Unsupported);
10041 std::array<CanQualType *, 6> AllUnsignedIntegers = {
10046 AllUnsignedIntegers.size() -
10047 Int128Unsupported);
10049 IsMakeSigned ? &AvailableSignedIntegers : &AvailableUnsignedIntegers;
10053 llvm::find_if(*Consider, [&S, BaseSize](
const CanQual<Type> *T) {
10057 assert(
Result != Consider->end());
10058 return QualType((*Result)->getTypePtr(), 0);
10063 bool IsMakeSigned = UKind == UnaryTransformType::MakeSigned;
10068 Diag(Loc, diag::err_make_signed_integral_only)
10069 << IsMakeSigned << BaseType->
isBitIntType() << BaseType << 0;
10073 bool IsNonIntIntegral =
10082 if (Underlying.
isNull())
10093 case UnaryTransformType::EnumUnderlyingType: {
10097 case UnaryTransformType::AddPointer: {
10101 case UnaryTransformType::RemovePointer: {
10105 case UnaryTransformType::Decay: {
10109 case UnaryTransformType::AddLvalueReference:
10110 case UnaryTransformType::AddRvalueReference: {
10114 case UnaryTransformType::RemoveAllExtents:
10115 case UnaryTransformType::RemoveExtent: {
10119 case UnaryTransformType::RemoveCVRef:
10120 case UnaryTransformType::RemoveReference: {
10124 case UnaryTransformType::RemoveConst:
10125 case UnaryTransformType::RemoveCV:
10126 case UnaryTransformType::RemoveRestrict:
10127 case UnaryTransformType::RemoveVolatile: {
10131 case UnaryTransformType::MakeSigned:
10132 case UnaryTransformType::MakeUnsigned: {
10150 int DisallowedKind = -1;
10152 DisallowedKind = 1;
10154 DisallowedKind = 2;
10156 DisallowedKind = 3;
10158 DisallowedKind = 4;
10160 DisallowedKind = 5;
10162 DisallowedKind = 6;
10165 DisallowedKind = 7;
10167 DisallowedKind = 8;
10170 DisallowedKind = 9;
10172 if (DisallowedKind != -1) {
10173 Diag(Loc, diag::err_atomic_specifier_bad_type) << DisallowedKind << T;
Defines the clang::ASTContext interface.
Defines the C++ template declaration subclasses.
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::Preprocessor interface.
static QualType getUnderlyingType(const SubRegion *R)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
static bool isBlockPointer(Expr *Arg)
static bool isFunctionOrMethod(const Decl *D)
isFunctionOrMethod - Return true if the given decl has function type (function or function-typed vari...
static void HandleNeonVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S, VectorKind VecKind)
HandleNeonVectorTypeAttr - The "neon_vector_type" and "neon_polyvector_type" attributes are used to c...
static QualType deduceOpenCLPointeeAddrSpace(Sema &S, QualType PointeeType)
static bool isPermittedNeonBaseType(QualType &Ty, VectorKind VecKind, Sema &S)
static void distributeObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType type)
Given that an objc_gc attribute was written somewhere on a declaration other than on the declarator i...
static void maybeSynthesizeBlockSignature(TypeProcessingState &state, QualType declSpecType)
Add a synthetic '()' to a block-literal declarator if it is required, given the return type.
#define MS_TYPE_ATTRS_CASELIST
#define CALLING_CONV_ATTRS_CASELIST
static void emitNullabilityConsistencyWarning(Sema &S, SimplePointerKind PointerKind, SourceLocation PointerLoc, SourceLocation PointerEndLoc)
static void fixItNullability(Sema &S, DiagBuilderT &Diag, SourceLocation PointerLoc, NullabilityKind Nullability)
Creates a fix-it to insert a C-style nullability keyword at pointerLoc, taking into account whitespac...
static ExprResult checkArraySize(Sema &S, Expr *&ArraySize, llvm::APSInt &SizeVal, unsigned VLADiag, bool VLAIsError)
Check whether the specified array bound can be evaluated using the relevant language rules.
static Attr * createNullabilityAttr(ASTContext &Ctx, ParsedAttr &Attr, NullabilityKind NK)
static void HandleVectorSizeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
HandleVectorSizeAttribute - this attribute is only applicable to integral and float scalars,...
static void inferARCWriteback(TypeProcessingState &state, QualType &declSpecType)
Given that this is the declaration of a parameter under ARC, attempt to infer attributes and such for...
static TypeSourceInfo * GetTypeSourceInfoForDeclarator(TypeProcessingState &State, QualType T, TypeSourceInfo *ReturnTypeInfo)
Create and instantiate a TypeSourceInfo with type source information.
static bool BuildAddressSpaceIndex(Sema &S, LangAS &ASIdx, const Expr *AddrSpace, SourceLocation AttrLoc)
Build an AddressSpace index from a constant expression and diagnose any errors related to invalid add...
static void HandleBTFTypeTagAttribute(QualType &Type, const ParsedAttr &Attr, TypeProcessingState &State)
static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, Qualifiers::ObjCLifetime ownership, unsigned chunkIndex)
static bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
handleObjCGCTypeAttr - Process the attribute((objc_gc)) type attribute on the specified type.
static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk)
static void HandleExtVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
Process the OpenCL-like ext_vector_type attribute when it occurs on a type.
static void HandleLifetimeBoundAttr(TypeProcessingState &State, QualType &CurType, ParsedAttr &Attr)
static bool handleArmStateAttribute(Sema &S, FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr, FunctionType::ArmStateValue State)
static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type, Sema::CUDAFunctionTarget CFT)
Process an individual function attribute.
static bool handleObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
static void processTypeAttrs(TypeProcessingState &state, QualType &type, TypeAttrLocation TAL, const ParsedAttributesView &attrs, Sema::CUDAFunctionTarget CFT=Sema::CFT_HostDevice)
static QualType inferARCLifetimeForPointee(Sema &S, QualType type, SourceLocation loc, bool isReference)
Given that we're building a pointer or reference to the given.
static QualType ChangeIntegralSignedness(Sema &S, QualType BaseType, bool IsMakeSigned, SourceLocation Loc)
static bool CheckNullabilityTypeSpecifier(Sema &S, TypeProcessingState *State, ParsedAttr *PAttr, QualType &QT, NullabilityKind Nullability, SourceLocation NullabilityLoc, bool IsContextSensitive, bool AllowOnArrayType, bool OverrideExisting)
#define OBJC_POINTER_TYPE_ATTRS_CASELIST
static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr, QualType type)
diagnoseBadTypeAttribute - Diagnoses a type attribute which doesn't apply to the given type.
static PointerDeclaratorKind classifyPointerDeclarator(Sema &S, QualType type, Declarator &declarator, PointerWrappingDeclaratorKind &wrappingKind)
Classify the given declarator, whose type-specified is type, based on what kind of pointer it refers ...
static bool verifyValidIntegerConstantExpr(Sema &S, const ParsedAttr &Attr, llvm::APSInt &Result)
static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
static 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 bool distributeFunctionTypeAttrToInnermost(TypeProcessingState &state, ParsedAttr &attr, ParsedAttributesView &attrList, QualType &declSpecType, Sema::CUDAFunctionTarget CFT)
Try to distribute a function type attribute to the innermost function chunk or type.
static FileID getNullabilityCompletenessCheckFileID(Sema &S, SourceLocation loc)
static void HandleArmSveVectorBitsTypeAttr(QualType &CurType, ParsedAttr &Attr, Sema &S)
HandleArmSveVectorBitsTypeAttr - The "arm_sve_vector_bits" attribute is used to create fixed-length v...
#define FUNCTION_TYPE_ATTRS_CASELIST
static bool distributeNullabilityTypeAttr(TypeProcessingState &state, QualType type, ParsedAttr &attr)
Distribute a nullability type attribute that cannot be applied to the type specifier to a pointer,...
static void distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType, Sema::CUDAFunctionTarget CFT)
A function type attribute was written on the declarator or declaration.
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.
#define NULLABILITY_TYPE_ATTRS_CASELIST
static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, TypeSourceInfo *&ReturnTypeInfo)
static void checkNullabilityConsistency(Sema &S, SimplePointerKind pointerKind, SourceLocation pointerLoc, SourceLocation pointerEndLoc=SourceLocation())
Complains about missing nullability if the file containing pointerLoc has other uses of nullability (...
static void transferARCOwnership(TypeProcessingState &state, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership)
Used for transferring ownership in casts resulting in l-values.
static std::string getPrintableNameForEntity(DeclarationName Entity)
static std::string getFunctionQualifiersAsString(const FunctionProtoType *FnTy)
static QualType rebuildAttributedTypeWithoutNullability(ASTContext &Ctx, QualType Type)
Rebuild an attributed type without the nullability attribute on it.
static DeclaratorChunk * maybeMovePastReturnType(Declarator &declarator, unsigned i, bool onlyBlockPointers)
Given the index of a declarator chunk, check whether that chunk directly specifies the return type of...
static OpenCLAccessAttr::Spelling getImageAccess(const ParsedAttributesView &Attrs)
static void fillMatrixTypeLoc(MatrixTypeLoc MTL, const ParsedAttributesView &Attrs)
static UnaryTransformType::UTTKind TSTToUnaryTransformType(DeclSpec::TST SwitchTST)
static void HandleRISCVRVVVectorBitsTypeAttr(QualType &CurType, ParsedAttr &Attr, Sema &S)
HandleRISCVRVVVectorBitsTypeAttr - The "riscv_rvv_vector_bits" attribute is used to create fixed-leng...
static void HandleAddressSpaceTypeAttribute(QualType &Type, const ParsedAttr &Attr, TypeProcessingState &State)
HandleAddressSpaceTypeAttribute - Process an address_space attribute on the specified type.
static bool checkQualifiedFunction(Sema &S, QualType T, SourceLocation Loc, QualifiedFunctionKind QFK)
Check whether the type T is a qualified function type, and if it is, diagnose that it cannot be conta...
static bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator, QualType Result)
Return true if this is omitted block return type.
static bool DiagnoseMultipleAddrSpaceAttributes(Sema &S, LangAS ASOld, LangAS ASNew, SourceLocation AttrLoc)
static void warnAboutRedundantParens(Sema &S, Declarator &D, QualType T)
Produce an appropriate diagnostic for a declarator with top-level parentheses.
static QualType ConvertDeclSpecToType(TypeProcessingState &state)
Convert the specified declspec to the appropriate type object.
static QualType applyObjCTypeArgs(Sema &S, SourceLocation loc, QualType type, ArrayRef< TypeSourceInfo * > typeArgs, SourceRange typeArgsRange, bool failOnError, bool rebuilding)
Apply Objective-C type arguments to the given type.
static std::pair< QualType, TypeSourceInfo * > InventTemplateParameter(TypeProcessingState &state, QualType T, TypeSourceInfo *TrailingTSI, AutoType *Auto, InventedTemplateParameterInfo &Info)
static void diagnoseAndRemoveTypeQualifiers(Sema &S, const DeclSpec &DS, unsigned &TypeQuals, QualType TypeSoFar, unsigned RemoveTQs, unsigned DiagID)
static CallingConv getCCForDeclaratorChunk(Sema &S, Declarator &D, const ParsedAttributesView &AttrList, const DeclaratorChunk::FunctionTypeInfo &FTI, unsigned ChunkIndex)
Helper for figuring out the default CC for a function declarator type.
static unsigned getLiteralDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for literal type diagnostic message.
static void recordNullabilitySeen(Sema &S, SourceLocation loc)
Marks that a nullability feature has been used in the file containing loc.
static void HandleHLSLParamModifierAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
static void checkExtParameterInfos(Sema &S, ArrayRef< QualType > paramTypes, const FunctionProtoType::ExtProtoInfo &EPI, llvm::function_ref< SourceLocation(unsigned)> getParamLoc)
Check the extended parameter information.
static void transferARCOwnershipToDeclSpec(Sema &S, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership)
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 void distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType, Sema::CUDAFunctionTarget CFT)
A function type attribute was written in the decl spec.
static AttrT * createSimpleAttr(ASTContext &Ctx, ParsedAttr &AL)
static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy, Declarator &D, unsigned FunctionChunkIndex)
static bool checkMutualExclusion(TypeProcessingState &state, const FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr, AttributeCommonInfo::Kind OtherKind)
static Attr * getCCTypeAttr(ASTContext &Ctx, ParsedAttr &Attr)
static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state, QualType &declSpecType, Sema::CUDAFunctionTarget CFT)
Given that there are attributes written on the declarator or declaration itself, try to distribute an...
Defines the clang::SourceLocation class and associated facilities.
Defines various enumerations that describe declaration and type specifiers.
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
__DEVICE__ int max(int __a, int __b)
virtual void HandleTagDeclRequiredDefinition(const TagDecl *D)
This callback is invoked the first time each TagDecl is required to be complete.
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
TranslationUnitDecl * getTranslationUnitDecl() const
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
QualType getParenType(QualType NamedType) const
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
QualType getDependentSizedMatrixType(QualType ElementType, Expr *RowExpr, Expr *ColumnExpr, SourceLocation AttrLoc) const
Return the unique reference to the matrix type of the specified element type and size.
unsigned getIntWidth(QualType T) const
QualType getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr, QualType Wrapped)
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false, ConceptDecl *TypeConstraintConcept=nullptr, ArrayRef< TemplateArgument > TypeConstraintArgs={}) const
C++11 deduced auto type.
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
QualType getPackExpansionType(QualType Pattern, std::optional< unsigned > NumExpansions, bool ExpectPackInType=true)
Form a pack expansion type with the given pattern.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
QualType getDependentVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc, VectorKind VecKind) const
Return the unique reference to the type for a dependently sized vector of the specified element type.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getReadPipeType(QualType T) const
Return a read_only pipe type for the specified type.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getDependentBitIntType(bool Unsigned, Expr *BitsExpr) const
Return a dependent bit-precise integer type with the specified signedness and bit count.
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
QualType getReferenceQualifiedType(const Expr *e) const
getReferenceQualifiedType - Given an expr, will return the type for that expression,...
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
QualType applyObjCProtocolQualifiers(QualType type, ArrayRef< ObjCProtocolDecl * > protocols, bool &hasError, bool allowOnPointerType=false) const
Apply Objective-C protocol qualifiers to the given type.
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const
Get a function type and produce the equivalent function type with the specified exception specificati...
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
CanQualType ObjCBuiltinIdTy
const TargetInfo * getAuxTargetInfo() const
CanQualType UnsignedLongTy
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType getCorrespondingSaturatedType(QualType Ty) const
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
LangAS getDefaultOpenCLPointeeAddrSpace()
Returns default address space based on OpenCL version and enabled features.
const clang::PrintingPolicy & getPrintingPolicy() const
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
QualType getUnsignedWCharType() const
Return the type of "unsigned wchar_t".
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
QualType getWritePipeType(QualType T) const
Return a write_only pipe type for the specified type.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CanQualType UnsignedInt128Ty
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type.
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
CanQualType UnsignedLongLongTy
CanQualType UnsignedShortTy
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
QualType getDependentAddressSpaceType(QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttrLoc) const
QualType getPackIndexingType(QualType Pattern, Expr *IndexExpr, bool FullySubstituted=false, ArrayRef< QualType > Expansions={}, int Index=-1) const
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind UKind) const
Unary type transforms.
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const
Recurses in pointer/array types until it finds an Objective-C retainable type and returns its ownersh...
DiagnosticsEngine & getDiagnostics() const
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
const TargetInfo & getTargetInfo() const
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
QualType getCorrespondingUnsignedType(QualType T) const
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
QualType getTypeOfType(QualType QT, TypeOfKind Kind) const
getTypeOfType - Unlike many "get<Type>" functions, we don't unique TypeOfType nodes.
QualType getCorrespondingSignedType(QualType T) const
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const
Return the uniqued reference to the type for an Objective-C gc-qualified type.
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const
C++11 decltype.
QualType getIncompleteArrayType(QualType EltTy, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type.
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
QualType getTypeOfExprType(Expr *E, TypeOfKind Kind) const
C23 feature and GCC extension.
QualType getSignedWCharType() const
Return the type of "signed wchar_t".
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
QualType getBitIntType(bool Unsigned, unsigned NumBits) const
Return a bit-precise integer type with the specified signedness and bit count.
The result of parsing/analyzing an expression, statement etc.
Wrapper for source info for arrays.
void setLBracketLoc(SourceLocation Loc)
void setRBracketLoc(SourceLocation Loc)
void setSizeExpr(Expr *Size)
TypeLoc getValueLoc() const
void setKWLoc(SourceLocation Loc)
void setParensRange(SourceRange Range)
Attr - This represents one attribute.
attr::Kind getKind() const
const char * getSpelling() const
SourceRange getRange() const
bool isContextSensitiveKeywordAttribute() const
bool isRegularKeywordAttribute() const
SourceLocation getLoc() const
const IdentifierInfo * getAttrName() const
ParsedAttr * create(IdentifierInfo *attrName, SourceRange attrRange, IdentifierInfo *scopeName, SourceLocation scopeLoc, ArgsUnion *args, unsigned numArgs, ParsedAttr::Form form, SourceLocation ellipsisLoc=SourceLocation())
Type source information for an attributed type.
TypeLoc getModifiedLoc() const
The modified type, which is generally canonically different from the attribute type.
void setAttr(const Attr *A)
An attributed type is a type to which a type attribute has been applied.
QualType getModifiedType() const
bool isCallingConv() const
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
static std::optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
bool hasExplicitTemplateArgs() const
const NestedNameSpecifierLoc getNestedNameSpecifierLoc() const
SourceLocation getRAngleLoc() const
ConceptDecl * getNamedConcept() const
SourceLocation getLAngleLoc() const
void setConceptReference(ConceptReference *CR)
NamedDecl * getFoundDecl() const
TemplateArgumentLoc getArgLoc(unsigned i) const
unsigned getNumArgs() const
DeclarationNameInfo getConceptNameInfo() const
void setRParenLoc(SourceLocation Loc)
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
bool isDecltypeAuto() const
ConceptDecl * getTypeConstraintConcept() const
Type source information for an btf_tag attributed type.
TypeLoc getWrappedLoc() const
Comparison function object.
A fixed int type of a specified bitwidth.
unsigned getNumBits() const
Wrapper for source info for block pointers.
void setCaretLoc(SourceLocation Loc)
Wrapper for source info for builtin types.
TypeSpecifierWidth getWrittenWidthSpec() const
bool needsExtraLocalData() const
void setBuiltinLoc(SourceLocation Loc)
WrittenBuiltinSpecs & getWrittenBuiltinSpecs()
TypeSpecifierSign getWrittenSignSpec() const
void expandBuiltinRange(SourceRange Range)
This class is used for builtin types like 'int'.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
bool isAggregate() const
Determine whether this class is an aggregate (C++ [dcl.init.aggr]), which is a class with no user-dec...
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
bool isLambda() const
Determine whether this class describes a lambda function object.
bool hasConstexprNonCopyMoveConstructor() const
Determine whether this class has at least one constexpr constructor other than the copy or move const...
bool hasConstexprDestructor() const
Determine whether this class has a constexpr destructor.
bool hasNonLiteralTypeFieldsOrBases() const
Determine whether this class has a non-literal or/ volatile type non-static data member or base class...
CXXRecordDecl * getMostRecentNonInjectedDecl()
base_class_range vbases()
bool hasUserProvidedDefaultConstructor() const
Whether this class has a user-provided default constructor per C++11.
bool hasDefinition() const
MSInheritanceModel calculateInheritanceModel() const
Calculate what the inheritance model would be for this class.
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Represents a C++ nested-name-specifier or a global scope specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
SourceRange getRange() const
SourceLocation getBeginLoc() const
bool isSet() const
Deprecated.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Represents a canonical, potentially-qualified type.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
SourceLocation getBegin() const
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a C++20 concept.
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten)
const TypeClass * getTypePtr() const
TypeLoc getNextTypeLoc() const
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
static constexpr bool isDimensionValid(size_t NumElements)
Returns true if NumElements is a valid matrix dimension.
Wrapper for source info for pointers decayed from arrays and functions.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
bool isFunctionOrMethod() const
A reference to a declared variable, function, enum, etc.
Captures information about "declaration specifiers".
const WrittenBuiltinSpecs & getWrittenBuiltinSpecs() const
bool isTypeSpecPipe() const
static const TST TST_typeof_unqualType
SourceLocation getTypeSpecSignLoc() const
bool hasAutoTypeSpec() const
static const TST TST_typename
SourceLocation getEndLoc() const LLVM_READONLY
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
static const TST TST_char8
static const TST TST_BFloat16
Expr * getPackIndexingExpr() const
TST getTypeSpecType() const
SCS getStorageClassSpec() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isTypeSpecSat() const
SourceRange getSourceRange() const LLVM_READONLY
static const TST TST_auto_type
static const TST TST_interface
static const TST TST_double
static const TST TST_typeofExpr
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
TemplateIdAnnotation * getRepAsTemplateId() const
static const TST TST_union
static const TST TST_typename_pack_indexing
static const TST TST_char
static const TST TST_bool
static const TST TST_char16
static const TST TST_unknown_anytype
TSC getTypeSpecComplex() const
ParsedType getRepAsType() const
static const TST TST_accum
static const TST TST_half
ParsedAttributes & getAttributes()
SourceLocation getEllipsisLoc() const
bool isTypeAltiVecPixel() const
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
SourceLocation getConstSpecLoc() const
static const TST TST_ibm128
Expr * getRepAsExpr() const
static const TST TST_enum
AttributePool & getAttributePool() const
static const TST TST_float128
static const TST TST_decltype
SourceRange getTypeSpecWidthRange() const
SourceLocation getTypeSpecTypeNameLoc() const
SourceLocation getTypeSpecWidthLoc() const
SourceLocation getRestrictSpecLoc() const
static const TST TST_typeof_unqualExpr
static const TST TST_class
bool hasTagDefinition() const
static const TST TST_decimal64
unsigned getParsedSpecifiers() const
Return a bitmask of which flavors of specifiers this DeclSpec includes.
bool isTypeAltiVecBool() const
bool isConstrainedAuto() const
static const TST TST_wchar
SourceLocation getTypeSpecComplexLoc() const
static const TST TST_void
bool isTypeAltiVecVector() const
static const TST TST_bitint
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
static const TST TST_float
static const TST TST_atomic
static const TST TST_fract
Decl * getRepAsDecl() const
static const TST TST_float16
static bool isTransformTypeTrait(TST T)
static const TST TST_unspecified
SourceLocation getAtomicSpecLoc() const
TypeSpecifierSign getTypeSpecSign() const
CXXScopeSpec & getTypeSpecScope()
SourceLocation getTypeSpecTypeLoc() const
static const TST TST_decltype_auto
static const TST TST_error
void forEachQualifier(llvm::function_ref< void(TQ, StringRef, SourceLocation)> Handle)
This method calls the passed in handler on each qual being set.
static const TST TST_decimal32
TypeSpecifierWidth getTypeSpecWidth() const
static const TST TST_char32
static const TST TST_decimal128
bool isTypeSpecOwned() const
SourceLocation getTypeSpecSatLoc() const
SourceRange getTypeofParensRange() const
SourceLocation getUnalignedSpecLoc() const
static const TST TST_int128
SourceLocation getVolatileSpecLoc() const
FriendSpecified isFriendSpecified() const
static const TST TST_typeofType
static const TST TST_auto
ConstexprSpecKind getConstexprSpecifier() const
static const TST TST_struct
Decl - This represents one declaration (or definition), e.g.
ASTContext & getASTContext() const LLVM_READONLY
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setImplicit(bool I=true)
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
The name of a declaration.
std::string getAsString() const
Retrieve the human-readable string for this name.
NameKind getNameKind() const
Determine what kind of name this is.
Information about one declarator, including the parsed type information and the identifier.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
const DeclaratorChunk * getInnermostNonParenChunk() const
Return the innermost (closest to the declarator) chunk of this declarator that is not a parens chunk,...
void AddInnermostTypeInfo(const DeclaratorChunk &TI)
Add a new innermost chunk to this declarator.
bool isFunctionDeclarationContext() const
Return true if this declaration appears in a context where a function declarator would be a function ...
FunctionDefinitionKind getFunctionDefinitionKind() const
const ParsedAttributes & getAttributes() const
SourceLocation getIdentifierLoc() const
bool hasTrailingReturnType() const
Determine whether a trailing return type was written (at any level) within this declarator.
SourceLocation getEndLoc() const LLVM_READONLY
bool isExpressionContext() const
Determine whether this declaration appears in a context where an expression could appear.
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
void setInvalidType(bool Val=true)
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
const ParsedAttributesView & getDeclarationAttributes() const
SourceLocation getEllipsisLoc() const
DeclaratorContext getContext() const
SourceLocation getBeginLoc() const LLVM_READONLY
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
bool isFirstDeclarator() const
SourceLocation getCommaLoc() const
AttributePool & getAttributePool() const
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
ParsedType getTrailingReturnType() const
Get the trailing return type appearing (at any level) within this declarator.
IdentifierInfo * getIdentifier() const
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)
void setRParenLoc(SourceLocation Loc)
void setDecltypeLoc(SourceLocation Loc)
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
void setAttrNameLoc(SourceLocation loc)
void setAttrOperandParensRange(SourceRange range)
void setAttrExprOperand(Expr *e)
Represents an extended address space qualifier where the input address space value is dependent.
void copy(DependentNameTypeLoc Loc)
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
void setNameLoc(SourceLocation Loc)
void copy(DependentTemplateSpecializationTypeLoc Loc)
void setNameLoc(SourceLocation Loc)
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
bool getSuppressSystemWarnings() const
void copy(ElaboratedTypeLoc Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
TypeLoc getNamedTypeLoc() const
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
This represents one expression.
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
A SourceLocation and its associated SourceManager.
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration.
Represents a prototype with parameter type info, e.g.
Qualifiers getMethodQuals() const
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Wrapper for source info for functions.
unsigned getNumParams() const
void setLocalRangeBegin(SourceLocation L)
void setLParenLoc(SourceLocation Loc)
void setParam(unsigned i, ParmVarDecl *VD)
void setRParenLoc(SourceLocation Loc)
void setLocalRangeEnd(SourceLocation L)
void setExceptionSpecRange(SourceRange R)
A class which abstracts out some details necessary for making a call.
ExtInfo withCallingConv(CallingConv cc) const
CallingConv getCC() const
bool getProducesResult() const
ParameterABI getABI() const
Return the ABI treatment of this parameter.
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
static StringRef getNameForCallConv(CallingConv CC)
static ArmStateValue getArmZT0State(unsigned AttrBits)
static ArmStateValue getArmZAState(unsigned AttrBits)
CallingConv getCallConv() const
QualType getReturnType() const
bool getHasRegParm() const
AArch64SMETypeAttributes
The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number of function type attributes that...
@ SME_PStateSMEnabledMask
@ SME_PStateSMCompatibleMask
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void setAmpLoc(SourceLocation Loc)
An lvalue reference type, per C++11 [dcl.ref].
@ PPTMK_FullGeneralityMultipleInheritance
@ PPTMK_FullGeneralityVirtualInheritance
@ PPTMK_FullGeneralitySingleInheritance
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool requiresStrictPrototypes() const
Returns true if functions without prototypes or functions with an identifier list (aka K&R C function...
bool isImplicitIntAllowed() const
Returns true if implicit int is supported at all.
bool isImplicitIntRequired() const
Returns true if implicit int is part of the language requirements.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
Represents the results of name lookup.
TypeLoc getInnerLoc() const
void setExpansionLoc(SourceLocation Loc)
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.
void setAttrRowOperand(Expr *e)
void setAttrColumnOperand(Expr *e)
void setAttrOperandParensRange(SourceRange range)
void setAttrNameLoc(SourceLocation loc)
static bool isValidElementType(QualType T)
Valid elements types are the following:
Wrapper for source info for member pointers.
void setStarLoc(SourceLocation Loc)
void setClassTInfo(TypeSourceInfo *TI)
const Type * getClass() const
A pointer to member type per C++ 8.3.3 - Pointers to members.
QualType getPointeeType() const
const Type * getClass() const
Provides information a specialization of a member of a class template, which may be a member function...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
This represents a decl that may have a name.
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
A C++ nested-name-specifier augmented with source location information.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
SourceLocation getLocalBeginLoc() const
Retrieve the location of the beginning of this component of the nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
Represents an ObjC class declaration.
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
Wrapper for source info for ObjC interfaces.
void setNameLoc(SourceLocation Loc)
void setNameEndLoc(SourceLocation Loc)
Interfaces are the core concept in Objective-C for object oriented design.
Wraps an ObjCPointerType with source location information.
void setStarLoc(SourceLocation Loc)
Represents a pointer to an Objective C object.
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
void setHasBaseTypeAsWritten(bool HasBaseType)
Represents a class type in Objective C.
Represents an Objective-C protocol declaration.
Represents the declaration of an Objective-C type parameter.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
unsigned size() const
Determine the number of type parameters in this list.
ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for protocol qualifiers are stored aft...
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
Represents a pack expansion of types.
void setEllipsisLoc(SourceLocation Loc)
A parameter attribute which changes the argument-passing ABI rule for the parameter.
void setRParenLoc(SourceLocation Loc)
void setLParenLoc(SourceLocation Loc)
Represents a parameter to a function.
void setKNRPromoted(bool promoted)
ParsedAttr - Represents a syntactic attribute.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this attribute.
bool isArgIdent(unsigned Arg) const
Expr * getArgAsExpr(unsigned Arg) const
AttributeCommonInfo::Kind getKind() const
void setUsedAsTypeAttr(bool Used=true)
bool hasMSPropertyAttr() const
void addAtEnd(ParsedAttr *newAttr)
bool hasAttribute(ParsedAttr::Kind K) const
void remove(ParsedAttr *ToBeRemoved)
void takeOneFrom(ParsedAttributes &Other, ParsedAttr *PA)
TypeLoc getValueLoc() const
void setKWLoc(SourceLocation Loc)
Wrapper for source info for pointers.
void setStarLoc(SourceLocation Loc)
PointerType - C99 6.7.5.1 - Pointer Declarators.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
SourceLocation getPragmaAssumeNonNullLoc() const
The location of the currently-active #pragma clang assume_nonnull begin.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
QualType IgnoreParens() const
Returns the specified type after dropping any outer-level parentheses.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
void addConst()
Add the const type qualifier to this QualType.
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.
LangAS getAddressSpace() const
Return the address space of this type.
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
bool isReferenceable() const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
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 isConstQualified() const
Determine whether this type is const-qualified.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Wrapper of type source information for a type with non-trivial direct qualifiers.
UnqualTypeLoc getUnqualifiedLoc() const
The collection of all-type qualifiers we support.
@ MaxAddressSpace
The maximum supported address space number.
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)
bool hasObjCLifetime() const
ObjCLifetime getObjCLifetime() const
void setUnaligned(bool flag)
std::string getAsString() const
void addObjCLifetime(ObjCLifetime type)
void setAmpAmpLoc(SourceLocation Loc)
Represents a struct/union/class.
field_range fields() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
bool isSpelledAsLValue() const
Scope - A scope is a transient data structure that is used while parsing the program.
bool isFunctionDeclarationScope() const
isFunctionDeclarationScope - Return true if this scope is a function prototype scope.
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
A generic diagnostic builder for errors which may or may not be deferred.
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.
CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
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 CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC, const FunctionDecl *FD=nullptr, CUDAFunctionTarget CFT=CFT_InvalidTarget)
Check validaty of calling convention attribute attr.
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace, SourceLocation AttrLoc)
BuildAddressSpaceAttr - Builds a DependentAddressSpaceType if an expression is uninstantiated.
QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement)
Completely replace the auto in TypeWithAuto by Replacement.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc)
QualType BuildObjCObjectType(QualType BaseType, SourceLocation Loc, SourceLocation TypeArgsLAngleLoc, ArrayRef< TypeSourceInfo * > TypeArgs, SourceLocation TypeArgsRAngleLoc, SourceLocation ProtocolLAngleLoc, ArrayRef< ObjCProtocolDecl * > Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc, bool FailOnError, bool Rebuilding)
Build an Objective-C object pointer type.
@ AcceptSizeless
Relax the normal rules for complete types so that they include sizeless built-in types.
class clang::Sema::DelayedDiagnostics DelayedDiagnostics
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
QualType BuildExtVectorType(QualType T, Expr *ArraySize, SourceLocation AttrLoc)
Build an ext-vector type.
const AttributedType * getCallingConvAttributedType(QualType T) const
Get the outermost AttributedType node that sets a calling convention.
TypeResult actOnObjCTypeArgsAndProtocolQualifiers(Scope *S, SourceLocation Loc, ParsedType BaseType, SourceLocation TypeArgsLAngleLoc, ArrayRef< ParsedType > TypeArgs, SourceLocation TypeArgsRAngleLoc, SourceLocation ProtocolLAngleLoc, ArrayRef< Decl * > Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc)
Build a specialized and/or protocol-qualified Objective-C type.
bool isInOpenMPTaskUntiedContext() const
Return true if currently in OpenMP task with untied clause context.
bool hasMergedDefinitionInCurrentModule(const NamedDecl *Def)
QualType BuildFunctionType(QualType T, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc, DeclarationName Entity, const FunctionProtoType::ExtProtoInfo &EPI)
Build a function type.
void checkSpecializationReachability(SourceLocation Loc, NamedDecl *Spec)
ASTContext & getASTContext() const
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
void checkExceptionSpecification(bool IsTopLevel, ExceptionSpecificationType EST, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr, SmallVectorImpl< QualType > &Exceptions, FunctionProtoType::ExceptionSpecInfo &ESI)
Check the given exception-specification and update the exception specification information with the r...
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
ParsedType ActOnObjCInstanceType(SourceLocation Loc)
The parser has parsed the context-sensitive type 'instancetype' in an Objective-C message declaration...
std::string getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const
Get a string to suggest for zero-initialization of a type.
bool CheckAttrNoArgs(const ParsedAttr &CurrAttr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
QualType BuildBitIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc)
Build a bit-precise integer type.
LangAS getDefaultCXXMethodAddrSpace() const
Returns default addr space for method qualifiers.
QualType BuiltinRemoveReference(QualType BaseType, UTTKind UKind, SourceLocation Loc)
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
bool CheckFunctionReturnType(QualType T, SourceLocation Loc)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_TypeConstraint
A type constraint.
const LangOptions & getLangOpts() const
RecordDecl * CFError
The struct behind the CFErrorRef pointer.
bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type of the given expression is complete.
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type)
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM, TrivialABIHandling TAH=TAH_IgnoreTrivialABI, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
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.
SourceLocation ImplicitMSInheritanceAttrLoc
Source location for newly created implicit MSInheritanceAttrs.
SmallVector< InventedTemplateParameterInfo, 4 > InventedParameterInfos
Stack containing information needed when in C++2a an 'auto' is encountered in a function declaration ...
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
void completeExprArrayBound(Expr *E)
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
bool hasExplicitCallingConv(QualType T)
bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value)
Checks a regparm attribute, returning true if it is ill-formed and otherwise setting numParams to the...
FileNullabilityMap NullabilityMap
A mapping that describes the nullability we've seen in each header file.
sema::FunctionScopeInfo * getCurFunction() const
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
ExprResult DefaultLvalueConversion(Expr *E)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
QualType BuiltinDecay(QualType BaseType, SourceLocation Loc)
IdentifierInfo * getNullabilityKeyword(NullabilityKind nullability)
Retrieve the keyword associated.
@ TAH_IgnoreTrivialABI
The triviality of a method unaffected by "trivial_abi".
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
bool isAcceptable(const NamedDecl *D, AcceptableKind Kind)
Determine whether a declaration is acceptable (visible/reachable).
QualType getDecltypeForExpr(Expr *E)
getDecltypeForExpr - Given an expr, will return the decltype for that expression, according to the ru...
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
QualType BuiltinAddReference(QualType BaseType, UTTKind UKind, SourceLocation Loc)
bool isCFError(RecordDecl *D)
bool hasVisibleMergedDefinition(const NamedDecl *Def)
QualType BuildPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc, bool FullySubstituted=false, ArrayRef< QualType > Expansions={})
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
QualType BuildAtomicType(QualType T, SourceLocation Loc)
void diagnoseMissingImport(SourceLocation Loc, const NamedDecl *Decl, MissingImportKind MIK, bool Recover=true)
Diagnose that the specified declaration needs to be visible but isn't, and suggest a module import th...
TypeSourceInfo * ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, QualType Replacement)
TypeResult ActOnTypeName(Declarator &D)
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
void checkUnusedDeclAttributes(Declarator &D)
checkUnusedDeclAttributes - Given a declarator which is not being used to build a declaration,...
QualType BuildPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a pointer type.
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
bool CheckAttrTarget(const ParsedAttr &CurrAttr)
QualType BuiltinAddPointer(QualType BaseType, SourceLocation Loc)
@ CCEK_ArrayBound
Array bound in array declarator or new-expression.
TypeResult actOnObjCProtocolQualifierType(SourceLocation lAngleLoc, ArrayRef< Decl * > protocols, ArrayRef< SourceLocation > protocolLocs, SourceLocation rAngleLoc)
Build a an Objective-C protocol-qualified 'id' type where no base type was specified.
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...
bool CheckDistantExceptionSpec(QualType T)
CheckDistantExceptionSpec - Check if the given type is a pointer or pointer to member to a function w...
CUDAFunctionTarget CurrentCUDATarget()
Gets the CUDA target for the current context.
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.
IdentifierInfo * getNSErrorIdent()
Retrieve the identifier "NSError".
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 BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl, SourceLocation ProtocolLAngleLoc, ArrayRef< ObjCProtocolDecl * > Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc, bool FailOnError=false)
Build an Objective-C type parameter type.
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.
IdentifierInfo * InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName, unsigned Index)
Invent a new identifier for parameters of abbreviated templates.
QualType BuildMatrixType(QualType T, Expr *NumRows, Expr *NumColumns, SourceLocation AttrLoc)
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)
bool hasAcceptableDefinition(NamedDecl *D, NamedDecl **Suggested, AcceptableKind Kind, bool OnlyNeedComplete=false)
QualType BuiltinChangeSignedness(QualType BaseType, UTTKind UKind, SourceLocation Loc)
void adjustMemberFunctionCC(QualType &T, bool HasThisPointer, bool IsCtorOrDtor, SourceLocation Loc)
Adjust the calling convention of a method to be the ABI default if it wasn't specified explicitly.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
bool checkStringLiteralArgumentAttr(const AttributeCommonInfo &CI, const Expr *E, StringRef &Str, SourceLocation *ArgLocation=nullptr)
Check if the argument E is a ASCII string literal.
QualType BuildMemberPointerType(QualType T, QualType Class, SourceLocation Loc, DeclarationName Entity)
Build a member pointer type T Class::*.
QualType BuildBlockPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a block pointer type.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Information about a FileID, basically just the logical file that it represents and include stack info...
CharacteristicKind getFileCharacteristic() const
Return whether this is a system header or not.
SourceLocation getIncludeLoc() const
This is a discriminated union of FileInfo and ExpansionInfo.
const FileInfo & getFile() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
Represents the declaration of a struct/union/class/enum.
bool isBeingDefined() const
Return true if this decl is currently being defined.
void setEmbeddedInDeclarator(bool isInDeclarator)
True if this tag declaration is "embedded" (i.e., defined or declared for the very first time) in the...
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
TagKind getTagKind() const
Wrapper for source info for tag types.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Exposes information about the current target.
virtual bool hasBitIntType() const
Determine whether the _BitInt type is supported on this target.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
virtual size_t getMaxBitIntWidth() const
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
virtual bool allowHalfArgsAndReturns() const
Whether half args and returns are supported.
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
virtual bool hasFloat16Type() const
Determine whether the _Float16 type is supported on this target.
bool isVLASupported() const
Whether target supports variable-length arrays.
virtual bool hasIbm128Type() const
Determine whether the __ibm128 type is supported on this target.
virtual bool hasFloat128Type() const
Determine whether the __float128 type is supported on this target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool hasBFloat16Type() const
Determine whether the _BFloat16 type is supported on this target.
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
virtual std::optional< std::pair< unsigned, unsigned > > getVScaleRange(const LangOptions &LangOpts) const
Returns target-specific min and max values VScale_Range.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Location wrapper for a TemplateArgument.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
UsingShadowDecl * getAsUsingShadowDecl() const
Retrieve the using shadow declaration through which the underlying template declaration is introduced...
SourceLocation getRAngleLoc() const
void copy(TemplateSpecializationTypeLoc Loc)
Declaration of a template type parameter.
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
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 findExplicitQualifierLoc() const
Find a type with the location of an explicit type qualifier.
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.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
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)
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
ElaboratedTypeKeyword getKeyword() const
The base class of the type hierarchy.
bool isSizelessType() const
As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isBooleanType() const
QualType getRVVEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an RVV builtin type.
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isIncompleteArrayType() const
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isUndeducedAutoType() const
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isVariableArrayType() const
bool isSizelessBuiltinType() const
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool canHaveNullability(bool ResultIfUnknown=true) const
Determine whether the given type can have a nullability specifier applied to it, i....
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isBitIntType() const
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isChar16Type() const
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
bool isMemberPointerType() const
bool isAtomicType() const
bool isFunctionProtoType() const
bool isObjCIdType() const
bool isChar32Type() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isObjectType() const
Determine whether this type is an object type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isRVVVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'riscv_rvv_vector_bits' type attribute,...
bool isRealFloatingType() const
Floating point categories.
bool isWideCharType() const
bool isAnyPointerType() const
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
bool isRecordType() const
bool isObjCRetainableType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Base class for declarations which introduce a typedef-name.
QualType getUnderlyingType() const
Wrapper for source info for typedefs.
void setParensRange(SourceRange range)
void setTypeofLoc(SourceLocation Loc)
Wrapper of type source information for a type with no direct qualifiers.
TypeLocClass getTypeLocClass() const
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
void setNameLoc(SourceLocation Loc)
Represents a GCC generic vector type.
VectorKind getVectorKind() const
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
Retains information about a function, method, or block that is currently being parsed.
Defines the clang::TargetInfo interface.
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefDecl > typedefDecl
Matches typedef declarations.
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
const internal::VariadicDynCastAllOfMatcher< Decl, RecordDecl > recordDecl
Matches class, struct, and union declarations.
The JSON file list parser is used to communicate input to InstallAPI.
TypeSpecifierType
Specifies the kind of type.
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
@ ExpectedFunctionWithProtoType
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
@ GNUAutoType
__auto_type (GNU extension)
@ DecltypeAuto
decltype(auto)
llvm::StringRef getParameterABISpelling(ParameterABI kind)
LLVM_READONLY bool isAsciiIdentifierContinue(unsigned char c)
NullabilityKind
Describes the nullability of a particular type.
@ Nullable
Values of this type can be null.
@ Unspecified
Whether values of this type can be null is (explicitly) unspecified.
@ NonNull
Values of this type can never be null.
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
llvm::PointerUnion< Expr *, IdentifierLoc * > ArgsUnion
A union of the various pointer types that can be passed to an ParsedAttr as an argument.
@ IK_DeductionGuideName
A deduction-guide name (a template-name)
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_ConstructorTemplateId
A constructor named via a template-id.
@ IK_ConstructorName
A constructor name.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_DestructorName
A destructor name.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
@ IK_ConversionFunctionId
A conversion function name, e.g., operator int.
TypeOfKind
The kind of 'typeof' expression we're after.
@ AANT_ArgumentIntegerConstant
@ Result
The result type of a method or function.
llvm::StringRef getNullabilitySpelling(NullabilityKind kind, bool isContextSensitive=false)
Retrieve the spelling of the given nullability kind.
ArraySizeModifier
Capture whether this is a normal array (e.g.
@ SwiftAsyncContext
This parameter (which must have pointer type) uses the special Swift asynchronous context-pointer ABI...
@ SwiftErrorResult
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
@ Ordinary
This parameter uses ordinary ABI rules for its type.
@ SwiftIndirectResult
This parameter (which must have pointer type) is a Swift indirect result parameter.
@ SwiftContext
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment.
bool supportsVariadicCall(CallingConv CC)
Checks whether the given calling convention supports variadic calls.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
ActionResult< Expr * > ExprResult
TagTypeKind
The kind of a tag type.
@ Interface
The "__interface" keyword.
@ Struct
The "struct" keyword.
@ Class
The "class" keyword.
@ Union
The "union" keyword.
@ Enum
The "enum" keyword.
LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword.
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ FirstTargetAddressSpace
MSInheritanceModel
Assigned inheritance model for a class in the MS C++ ABI.
@ Incomplete
Template argument deduction did not deduce a value for every template parameter.
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ 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
LangAS getLangASFromTargetAS(unsigned TargetAS)
@ None
The alignment was not explicit in code.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ None
No keyword precedes the qualified type name.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Parens
New-expression has a C++98 paren-delimited initializer.
@ EST_DependentNoexcept
noexcept(expression), value-dependent
@ EST_Uninstantiated
not instantiated yet
@ EST_Unparsed
not parsed yet
@ EST_NoThrow
Microsoft __declspec(nothrow) extension.
@ EST_None
no exception specification
@ EST_MSAny
Microsoft throw(...) extension.
@ EST_BasicNoexcept
noexcept
@ EST_NoexceptFalse
noexcept(expression), evals to 'false'
@ EST_Unevaluated
not evaluated yet, for special member function
@ EST_NoexceptTrue
noexcept(expression), evals to 'true'
@ EST_Dynamic
throw(T1, T2)
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.
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.
enum clang::DeclaratorChunk::@216 Kind
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), SourceLocation TrailingReturnTypeLoc=SourceLocation(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
MemberPointerTypeInfo Mem
SourceLocation Loc
Loc - The place where this type was defined.
Describes whether we've seen any nullability information for the given file.
SourceLocation PointerEndLoc
The end location for the first pointer declarator in the file.
SourceLocation PointerLoc
The first pointer declarator (of any pointer kind) in the file that does not have a corresponding nul...
bool SawTypeNullability
Whether we saw any type nullability annotations in the given file.
uint8_t PointerKind
Which kind of pointer declarator we saw.
Holds information about the various types of exception specification.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
unsigned AArch64SMEAttributes
SourceLocation EllipsisLoc
const ExtParameterInfo * ExtParameterInfos
RefQualifierKind RefQualifier
unsigned HasTrailingReturn
void setArmSMEAttribute(AArch64SMETypeAttributes Kind, bool Enable=true)
FunctionType::ExtInfo ExtInfo
Wraps an identifier and optional source location for the identifier.
SmallVector< NamedDecl *, 4 > TemplateParams
Store the list of the template parameters for a generic lambda or an abbreviated function template.
unsigned AutoTemplateParameterDepth
If this is a generic lambda or abbreviated function template, use this as the depth of each 'auto' pa...
Describes how types, statements, expressions, and declarations should be printed.
@ Memoization
Added for Template instantiation observation.
Abstract class used to diagnose incomplete types.
virtual void diagnose(Sema &S, SourceLocation Loc, QualType T)=0
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
SplitQualType getSingleStepDesugaredType() const
const Type * Ty
The locally-unqualified type.
Qualifiers Quals
The local qualifiers.
bool IsEquivalent(Decl *D1, Decl *D2)
Determine whether the two declarations are structurally equivalent.
Information about a template-id annotation token.
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.
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.