45#include "llvm/ADT/ArrayRef.h"
46#include "llvm/ADT/STLForwardCompat.h"
47#include "llvm/ADT/StringExtras.h"
48#include "llvm/IR/DerivedTypes.h"
49#include "llvm/Support/ErrorHandling.h"
64 if (
D.getContext() != DeclaratorContext::BlockLiteral ||
65 D.getDeclSpec().hasTypeSpecifier())
68 if (
D.getNumTypeObjects() == 0)
71 if (
D.getNumTypeObjects() == 1 &&
83 bool useExpansionLoc =
true;
84 switch (
attr.getKind()) {
85 case ParsedAttr::AT_ObjCGC:
88 case ParsedAttr::AT_ObjCOwnership:
94 useExpansionLoc =
false;
99 StringRef name =
attr.getAttrName()->getName();
104 if (useExpansionLoc && loc.
isMacroID() && II) {
105 if (II->
isStr(
"strong")) {
107 }
else if (II->
isStr(
"weak")) {
112 S.
Diag(loc,
attr.isRegularKeywordAttribute()
113 ? diag::err_type_attribute_wrong_type
114 : diag::warn_type_attribute_wrong_type)
115 << name << WhichType <<
type;
120#define OBJC_POINTER_TYPE_ATTRS_CASELIST \
121 case ParsedAttr::AT_ObjCGC: \
122 case ParsedAttr::AT_ObjCOwnership
125#define CALLING_CONV_ATTRS_CASELIST \
126 case ParsedAttr::AT_CDecl: \
127 case ParsedAttr::AT_FastCall: \
128 case ParsedAttr::AT_StdCall: \
129 case ParsedAttr::AT_ThisCall: \
130 case ParsedAttr::AT_RegCall: \
131 case ParsedAttr::AT_Pascal: \
132 case ParsedAttr::AT_SwiftCall: \
133 case ParsedAttr::AT_SwiftAsyncCall: \
134 case ParsedAttr::AT_VectorCall: \
135 case ParsedAttr::AT_AArch64VectorPcs: \
136 case ParsedAttr::AT_AArch64SVEPcs: \
137 case ParsedAttr::AT_AMDGPUKernelCall: \
138 case ParsedAttr::AT_MSABI: \
139 case ParsedAttr::AT_SysVABI: \
140 case ParsedAttr::AT_Pcs: \
141 case ParsedAttr::AT_IntelOclBicc: \
142 case ParsedAttr::AT_PreserveMost: \
143 case ParsedAttr::AT_PreserveAll: \
144 case ParsedAttr::AT_M68kRTD: \
145 case ParsedAttr::AT_PreserveNone: \
146 case ParsedAttr::AT_RISCVVectorCC
149#define FUNCTION_TYPE_ATTRS_CASELIST \
150 case ParsedAttr::AT_NSReturnsRetained: \
151 case ParsedAttr::AT_NoReturn: \
152 case ParsedAttr::AT_NonBlocking: \
153 case ParsedAttr::AT_NonAllocating: \
154 case ParsedAttr::AT_Blocking: \
155 case ParsedAttr::AT_Allocating: \
156 case ParsedAttr::AT_Regparm: \
157 case ParsedAttr::AT_CmseNSCall: \
158 case ParsedAttr::AT_ArmStreaming: \
159 case ParsedAttr::AT_ArmStreamingCompatible: \
160 case ParsedAttr::AT_ArmPreserves: \
161 case ParsedAttr::AT_ArmIn: \
162 case ParsedAttr::AT_ArmOut: \
163 case ParsedAttr::AT_ArmInOut: \
164 case ParsedAttr::AT_ArmAgnostic: \
165 case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: \
166 case ParsedAttr::AT_AnyX86NoCfCheck: \
167 CALLING_CONV_ATTRS_CASELIST
170#define MS_TYPE_ATTRS_CASELIST \
171 case ParsedAttr::AT_Ptr32: \
172 case ParsedAttr::AT_Ptr64: \
173 case ParsedAttr::AT_SPtr: \
174 case ParsedAttr::AT_UPtr
177#define NULLABILITY_TYPE_ATTRS_CASELIST \
178 case ParsedAttr::AT_TypeNonNull: \
179 case ParsedAttr::AT_TypeNullable: \
180 case ParsedAttr::AT_TypeNullableResult: \
181 case ParsedAttr::AT_TypeNullUnspecified
186 class TypeProcessingState {
210 using TypeAttrPair = std::pair<const AttributedType*, const Attr*>;
212 bool AttrsForTypesSorted =
true;
216 llvm::DenseMap<const MacroQualifiedType *, SourceLocation> LocsForMacros;
224 bool ParsedHLSLParamMod;
228 : sema(sema), declarator(declarator),
230 ParsedHLSLParamMod(
false) {}
232 Sema &getSema()
const {
240 bool isProcessingDeclSpec()
const {
244 unsigned getCurrentChunkIndex()
const {
248 void setCurrentChunkIndex(
unsigned idx) {
254 if (isProcessingDeclSpec())
255 return getMutableDeclSpec().getAttributes();
260 void saveDeclSpecAttrs() {
262 if (!savedAttrs.empty())
265 DeclSpec &spec = getMutableDeclSpec();
266 llvm::append_range(savedAttrs,
273 ignoredTypeAttrs.push_back(&
attr);
279 for (
auto *
Attr : ignoredTypeAttrs)
289 AttrsForTypes.push_back({cast<AttributedType>(
T.getTypePtr()), A});
290 AttrsForTypesSorted =
false;
295 QualType getBTFTagAttributedType(
const BTFTypeTagAttr *BTFAttr,
307 auto *NewAttrTy = cast<AttributedType>(
T.getTypePtr());
308 for (TypeAttrPair &A : AttrsForTypes) {
309 if (A.first == AttrTy)
312 AttrsForTypesSorted =
false;
319 if (!AttrsForTypesSorted) {
320 llvm::stable_sort(AttrsForTypes, llvm::less_first());
321 AttrsForTypesSorted =
true;
326 for (
auto It = std::partition_point(
327 AttrsForTypes.begin(), AttrsForTypes.end(),
328 [=](
const TypeAttrPair &A) { return A.first < AT; });
329 It != AttrsForTypes.end() && It->first == AT; ++It) {
331 const Attr *Result = It->second;
332 It->second =
nullptr;
337 llvm_unreachable(
"no Attr* for AttributedType*");
342 auto FoundLoc = LocsForMacros.find(MQT);
343 assert(FoundLoc != LocsForMacros.end() &&
344 "Unable to find macro expansion location for MacroQualifedType");
345 return FoundLoc->second;
350 LocsForMacros[MQT] =
Loc;
353 void setParsedNoDeref(
bool parsed) { parsedNoDeref = parsed; }
355 bool didParseNoDeref()
const {
return parsedNoDeref; }
357 void setParsedHLSLParamMod(
bool Parsed) { ParsedHLSLParamMod = Parsed; }
359 bool didParseHLSLParamMod()
const {
return ParsedHLSLParamMod; }
361 ~TypeProcessingState() {
362 if (savedAttrs.empty())
365 getMutableDeclSpec().getAttributes().clearListOnly();
367 getMutableDeclSpec().getAttributes().addAtEnd(AL);
371 DeclSpec &getMutableDeclSpec()
const {
413 if (
attr.getKind() == ParsedAttr::AT_ObjCGC)
415 assert(
attr.getKind() == ParsedAttr::AT_ObjCOwnership);
430 bool onlyBlockPointers) {
436 for (; i != 0; --i) {
438 switch (fnChunk.
Kind) {
454 for (--i; i != 0; --i) {
456 switch (ptrChunk.
Kind) {
466 if (onlyBlockPointers)
475 llvm_unreachable(
"bad declarator chunk kind");
481 llvm_unreachable(
"bad declarator chunk kind");
498 Declarator &declarator = state.getDeclarator();
501 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
503 switch (chunk.
Kind) {
509 if (state.isProcessingDeclSpec() &&
510 attr.getKind() == ParsedAttr::AT_ObjCOwnership)
513 if (!destChunk) destChunk = &chunk;
526 if (state.isProcessingDeclSpec() &&
527 attr.getKind() == ParsedAttr::AT_ObjCOwnership) {
554 Declarator &declarator = state.getDeclarator();
558 unsigned innermost = -1U;
559 bool considerDeclSpec =
true;
562 switch (chunk.
Kind) {
576 considerDeclSpec =
false;
584 if (considerDeclSpec) {
589 state.saveDeclSpecAttrs();
598 if (innermost != -1U) {
606 state.addIgnoredTypeAttr(
attr);
615 Declarator &declarator = state.getDeclarator();
619 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
621 switch (chunk.
Kind) {
648 Declarator &declarator = state.getDeclarator();
668 state.saveDeclSpecAttrs();
672 state,
attr, state.getCurrentAttributes(), declSpecType, CFT))
677 state.addIgnoredTypeAttr(
attr);
688 Declarator &declarator = state.getDeclarator();
698 state.addIgnoredTypeAttr(
attr);
723 if (
attr.isStandardAttributeSyntax() ||
attr.isRegularKeywordAttribute())
726 switch (
attr.getKind()) {
743 case ParsedAttr::AT_ObjCKindOf:
756 Declarator &declarator = state.getDeclarator();
802 {}, loc, loc, declarator));
817 typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc;
822 if (!(RemoveTQs & Qual.first))
826 if (TypeQuals & Qual.first)
827 S.
Diag(Qual.second, DiagID)
832 TypeQuals &= ~Qual.first;
846 if (AL.isInvalid() || !AL.isTypeAttr())
849 diag::warn_block_literal_attributes_on_omitted_return_type)
851 ToBeRemoved.push_back(&AL);
861 diag::warn_block_literal_qualifiers_on_omitted_return_type);
867static OpenCLAccessAttr::Spelling
870 if (AL.getKind() == ParsedAttr::AT_OpenCLAccess)
871 return static_cast<OpenCLAccessAttr::Spelling
>(AL.getSemanticSpelling());
872 return OpenCLAccessAttr::Keyword_read_only;
878#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait) \
880 return UnaryTransformType::Enum;
881#include "clang/Basic/TransformTypeTraits.def"
883 llvm_unreachable(
"attempted to parse a non-unary transform builtin");
897 Sema &S = state.getSema();
898 Declarator &declarator = state.getDeclarator();
918 "Unknown TSS value");
932 "Unknown TSS value");
941 "Unknown TSS value");
946 "Unknown TSS value");
951 "Unknown TSS value");
960 declarator.
getContext() == DeclaratorContext::LambdaExpr) {
964 }
else if (declarator.
getContext() == DeclaratorContext::LambdaExpr ||
979 S.
Diag(DeclLoc, diag::warn_missing_type_specifier)
988 S.
Diag(DeclLoc, diag::err_missing_type_specifier)
997 S.
Diag(DeclLoc, diag::err_missing_actual_pipe_type)
1002 "implicit int is disabled?");
1003 S.
Diag(DeclLoc, diag::ext_missing_type_specifier)
1013 case TypeSpecifierWidth::Unspecified:
1014 Result = Context.
IntTy;
1016 case TypeSpecifierWidth::Short:
1019 case TypeSpecifierWidth::Long:
1022 case TypeSpecifierWidth::LongLong:
1030 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1038 case TypeSpecifierWidth::Unspecified:
1041 case TypeSpecifierWidth::Short:
1044 case TypeSpecifierWidth::Long:
1047 case TypeSpecifierWidth::LongLong:
1055 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1070 if (Result.isNull()) {
1071 Result = Context.
IntTy;
1078 case TypeSpecifierWidth::Short:
1081 case TypeSpecifierWidth::Unspecified:
1084 case TypeSpecifierWidth::Long:
1087 case TypeSpecifierWidth::LongLong:
1088 llvm_unreachable(
"Unable to specify long long as _Accum width");
1101 case TypeSpecifierWidth::Short:
1104 case TypeSpecifierWidth::Unspecified:
1107 case TypeSpecifierWidth::Long:
1110 case TypeSpecifierWidth::LongLong:
1111 llvm_unreachable(
"Unable to specify long long as _Fract width");
1162 ?
"cl_khr_fp64 and __opencl_c_fp64"
1190 Result = Context.
IntTy;
1201 Result = Context.
IntTy;
1212 "No qualifiers on tag names!");
1228 "Can't handle qualifiers on typedef names yet!");
1230 if (Result.isNull()) {
1241 assert(!Result.isNull() &&
"Didn't get a type for typeof?");
1242 if (!Result->isDependentType())
1248 ? TypeOfKind::Unqualified
1249 : TypeOfKind::Qualified);
1254 assert(
E &&
"Didn't get an expression for typeof?");
1258 ? TypeOfKind::Unqualified
1259 : TypeOfKind::Qualified);
1260 if (Result.isNull()) {
1261 Result = Context.
IntTy;
1268 assert(
E &&
"Didn't get an expression for decltype?");
1271 if (Result.isNull()) {
1272 Result = Context.
IntTy;
1279 assert(
E &&
"Didn't get an expression for pack indexing");
1283 if (Result.isNull()) {
1285 Result = Context.
IntTy;
1290#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
1291#include "clang/Basic/TransformTypeTraits.def"
1293 assert(!Result.isNull() &&
"Didn't get a type for the transformation?");
1297 if (Result.isNull()) {
1298 Result = Context.
IntTy;
1306 ? AutoTypeKeyword::DecltypeAuto
1307 : AutoTypeKeyword::Auto;
1313 TypeConstraintConcept =
1314 cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl());
1319 TemplateId->NumArgs);
1321 for (
const auto &ArgLoc : TemplateArgsInfo.
arguments())
1322 TemplateArgs.push_back(ArgLoc.getArgument());
1329 TypeConstraintConcept, TemplateArgs);
1343 assert(!Result.isNull() &&
"Didn't get a type for _Atomic?");
1345 if (Result.isNull()) {
1346 Result = Context.
IntTy;
1351#define GENERIC_IMAGE_TYPE(ImgType, Id) \
1352 case DeclSpec::TST_##ImgType##_t: \
1353 switch (getImageAccess(DS.getAttributes())) { \
1354 case OpenCLAccessAttr::Keyword_write_only: \
1355 Result = Context.Id##WOTy; \
1357 case OpenCLAccessAttr::Keyword_read_write: \
1358 Result = Context.Id##RWTy; \
1360 case OpenCLAccessAttr::Keyword_read_only: \
1361 Result = Context.Id##ROTy; \
1363 case OpenCLAccessAttr::SpellingNotCalculated: \
1364 llvm_unreachable("Spelling not yet calculated"); \
1367#include "clang/Basic/OpenCLImageTypes.def"
1369#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
1370 case DeclSpec::TST_##Name: \
1371 Result = Context.SingletonId; \
1373#include "clang/Basic/HLSLIntangibleTypes.def"
1376 Result = Context.
IntTy;
1384 if (Result->containsErrors())
1389 bool IsOpenCLC30Compatible =
1398 if ((Result->isImageType() || Result->isSamplerT()) &&
1399 (IsOpenCLC30Compatible &&
1402 << 0 << Result <<
"__opencl_c_images";
1404 }
else if (Result->isOCLImage3dWOType() &&
1409 << (IsOpenCLC30Compatible
1410 ?
"cl_khr_3d_image_writes and __opencl_c_3d_image_writes"
1411 :
"cl_khr_3d_image_writes");
1431 unsigned typeSize =
static_cast<unsigned>(Context.
getTypeSize(Result));
1432 assert(typeSize > 0 &&
"type size for vector must be greater than 0 bits");
1433 VectorKind VecKind = VectorKind::AltiVecVector;
1435 VecKind = VectorKind::AltiVecPixel;
1437 VecKind = VectorKind::AltiVecBool;
1438 Result = Context.
getVectorType(Result, 128/typeSize, VecKind);
1449 if (declarator.
getContext() == DeclaratorContext::BlockLiteral)
1463 if (AL.slidesFromDeclToDeclSpecLegacyBehavior()) {
1474 if (AL.isStandardAttributeSyntax() && AL.isClangScope() &&
1475 !(AL.getKind() == ParsedAttr::AT_MatrixType &&
1477 S.
Diag(AL.getLoc(), diag::warn_type_attribute_deprecated_on_decl)
1505 if (Result->isFunctionType()) {
1506 unsigned DiagId = diag::warn_typecheck_function_qualifiers_ignored;
1508 DiagId = diag::ext_typecheck_function_qualifiers_unspecified;
1524 if (TypeQuals && Result->isReferenceType()) {
1526 S, DS, TypeQuals, Result,
1528 diag::warn_typecheck_reference_qualifiers);
1535 && TypeQuals & Result.getCVRQualifiers()) {
1562 assert(!Result.isNull() &&
"This function should not return a null type");
1577 const auto *AT = dyn_cast<AutoType>(
T);
1578 return AT && AT->isGNUAutoType();
1595 unsigned DiagID = 0;
1611 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
1618 DiagID = diag::err_typecheck_invalid_restrict_not_pointer;
1632 unsigned CVRAU,
const DeclSpec *DS) {
1666 Split.Quals.addCVRQualifiers(CVR);
1684 if (!
type->isObjCLifetimeType() ||
1694 if (
type.isConstQualified()) {
1700 }
else if (
type->isObjCARCImplicitlyUnretainedType()) {
1718 diag::err_arc_indirect_no_ownership,
type, isReference));
1720 S.
Diag(loc, diag::err_arc_indirect_no_ownership) <<
type << isReference;
1724 assert(implicitLifetime &&
"didn't infer any lifetime!");
1765enum QualifiedFunctionKind { QFK_BlockPointer, QFK_Pointer, QFK_Reference };
1771 QualifiedFunctionKind QFK) {
1778 S.
Diag(
Loc, diag::err_compound_qualified_function_type)
1779 << QFK << isa<FunctionType>(
T.IgnoreParens()) <<
T
1790 Diag(
Loc, diag::err_qualified_function_typeid)
1809 Diag(
Loc, diag::err_illegal_decl_pointer_to_reference)
1817 Diag(
Loc, diag::err_opencl_function_pointer) << 0;
1822 Diag(
Loc, diag::err_hlsl_pointers_unsupported) << 0;
1841 if (
T.isWebAssemblyReferenceType()) {
1842 Diag(
Loc, diag::err_wasm_reference_pr) << 0;
1848 Diag(
Loc, diag::err_wasm_table_pr) << 0;
1861 "Unresolved overloaded function type");
1889 Diag(
Loc, diag::err_reference_to_void);
1894 Diag(
Loc, diag::err_hlsl_pointers_unsupported) << 1;
1904 Diag(
Loc, diag::err_opencl_function_pointer) << 1;
1917 T.isWebAssemblyReferenceType()) {
1918 Diag(
Loc, diag::err_wasm_reference_pr) << 1;
1922 Diag(
Loc, diag::err_wasm_table_pr) << 1;
1945 llvm::APSInt Bits(32);
1952 size_t NumBits = Bits.getZExtValue();
1953 if (!IsUnsigned && NumBits < 2) {
1954 Diag(
Loc, diag::err_bit_int_bad_size) << 0;
1958 if (IsUnsigned && NumBits < 1) {
1959 Diag(
Loc, diag::err_bit_int_bad_size) << 1;
1965 Diag(
Loc, diag::err_bit_int_max_size)
1979 llvm::APSInt &SizeVal,
unsigned VLADiag,
2004 VLADiagnoser(
unsigned VLADiag,
bool VLAIsError)
2005 : VLADiag(VLADiag), VLAIsError(VLAIsError) {}
2009 return S.
Diag(
Loc, diag::err_array_size_non_int) <<
T;
2014 IsVLA = !VLAIsError;
2020 return S.
Diag(
Loc, diag::ext_vla_folded_to_constant);
2022 } Diagnoser(VLADiag, VLAIsError);
2026 if (Diagnoser.IsVLA)
2040 if (Size.isMultipleOf(Alignment))
2043 Diag(
Loc, diag::err_array_element_alignment)
2044 << EltTy << Size.getQuantity() << Alignment.
getQuantity();
2049 Expr *ArraySize,
unsigned Quals,
2066 Diag(
Loc, diag::err_illegal_decl_array_of_references)
2072 Diag(
Loc, diag::err_array_incomplete_or_sizeless_type) << 0 <<
T;
2077 diag::err_array_of_abstract_type))
2084 if (!MPTy->getClass()->isDependentType())
2090 if (!
T.isWebAssemblyReferenceType() &&
2092 diag::err_array_incomplete_or_sizeless_type))
2098 const auto *ATy = dyn_cast<ArrayType>(
T);
2099 if (ATy && ATy->getElementType().isWebAssemblyReferenceType()) {
2100 Diag(
Loc, diag::err_wasm_reftype_multidimensional_array);
2106 Diag(
Loc, diag::err_array_incomplete_or_sizeless_type) << 1 <<
T;
2111 Diag(
Loc, diag::err_illegal_decl_array_of_functions)
2119 if (EltTy->getDecl()->hasFlexibleArrayMember())
2120 Diag(
Loc, diag::ext_flexible_array_in_array) <<
T;
2122 Diag(
Loc, diag::err_objc_array_of_interfaces) <<
T;
2133 ArraySize =
Result.get();
2137 if (ArraySize && !ArraySize->
isPRValue()) {
2142 ArraySize =
Result.get();
2165 if (
const auto *CondExpr = dyn_cast_if_present<ConditionalOperator>(
2167 std::optional<llvm::APSInt> LHS =
2168 CondExpr->getLHS()->getIntegerConstantExpr(
Context);
2169 std::optional<llvm::APSInt> RHS =
2170 CondExpr->getRHS()->getIntegerConstantExpr(
Context);
2171 return LHS && RHS && LHS->isNegative() != RHS->isNegative();
2181 VLADiag = diag::err_opencl_vla;
2184 VLADiag = diag::warn_vla_used;
2187 VLADiag = diag::err_vla_in_sfinae;
2190 VLADiag = diag::err_openmp_vla_in_task_untied;
2195 ? diag::ext_vla_cxx_in_gnu_mode_static_assert
2196 : diag::ext_vla_cxx_static_assert;
2198 VLADiag =
getLangOpts().GNUMode ? diag::ext_vla_cxx_in_gnu_mode
2199 : diag::ext_vla_cxx;
2202 VLADiag = diag::ext_vla;
2243 if (ConstVal.isSigned() && ConstVal.isNegative()) {
2250 diag::err_typecheck_negative_array_size)
2254 if (ConstVal == 0 && !
T.isWebAssemblyReferenceType()) {
2259 : diag::ext_typecheck_zero_array_size)
2264 unsigned ActiveSizeBits =
2268 : ConstVal.getActiveBits();
2284 IsCUDADevice ? diag::err_cuda_vla : diag::err_vla_unsupported)
2285 << (IsCUDADevice ? llvm::to_underlying(
CUDA().CurrentTarget()) : 0);
2289 FSI->setHasVLA(
Loc);
2297 : diag::ext_c99_array_usage)
2298 << llvm::to_underlying(ASM);
2308 Diag(
Loc, diag::err_opencl_invalid_type_array) << ArrType;
2318 bool ForMatrixType =
false) {
2321 if (!llvm::isPowerOf2_32(NumBits) || NumBits < 8)
2322 return S.
Diag(AttrLoc, diag::err_attribute_invalid_bitint_vector_type)
2323 << ForMatrixType << (NumBits < 8);
2336 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << CurType;
2348 std::optional<llvm::APSInt> VecSize =
2351 Diag(AttrLoc, diag::err_attribute_argument_type)
2362 if (!VecSize->isIntN(61)) {
2364 Diag(AttrLoc, diag::err_attribute_size_too_large)
2368 uint64_t VectorSizeBits = VecSize->getZExtValue() * 8;
2371 if (VectorSizeBits == 0) {
2372 Diag(AttrLoc, diag::err_attribute_zero_size)
2377 if (!TypeSize || VectorSizeBits % TypeSize) {
2378 Diag(AttrLoc, diag::err_attribute_invalid_size)
2383 if (VectorSizeBits / TypeSize > std::numeric_limits<uint32_t>::max()) {
2384 Diag(AttrLoc, diag::err_attribute_size_too_large)
2408 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) <<
T;
2417 std::optional<llvm::APSInt> vecSize =
2420 Diag(AttrLoc, diag::err_attribute_argument_type)
2426 if (!vecSize->isIntN(32)) {
2427 Diag(AttrLoc, diag::err_attribute_size_too_large)
2433 unsigned vectorSize =
static_cast<unsigned>(vecSize->getZExtValue());
2435 if (vectorSize == 0) {
2436 Diag(AttrLoc, diag::err_attribute_zero_size)
2450 "Should never build a matrix type when it is disabled");
2455 Diag(AttrLoc, diag::err_attribute_invalid_matrix_type) << ElementTy;
2469 std::optional<llvm::APSInt> ValueRows =
2471 std::optional<llvm::APSInt> ValueColumns =
2478 if (!ValueRows && !ValueColumns) {
2479 Diag(AttrLoc, diag::err_attribute_argument_type)
2487 Diag(AttrLoc, diag::err_attribute_argument_type)
2493 if (!ValueColumns) {
2494 Diag(AttrLoc, diag::err_attribute_argument_type)
2500 unsigned MatrixRows =
static_cast<unsigned>(ValueRows->getZExtValue());
2501 unsigned MatrixColumns =
static_cast<unsigned>(ValueColumns->getZExtValue());
2502 if (MatrixRows == 0 && MatrixColumns == 0) {
2503 Diag(AttrLoc, diag::err_attribute_zero_size)
2504 <<
"matrix" << RowRange << ColRange;
2507 if (MatrixRows == 0) {
2508 Diag(AttrLoc, diag::err_attribute_zero_size) <<
"matrix" << RowRange;
2511 if (MatrixColumns == 0) {
2512 Diag(AttrLoc, diag::err_attribute_zero_size) <<
"matrix" << ColRange;
2516 Diag(AttrLoc, diag::err_attribute_size_too_large)
2517 << RowRange <<
"matrix row";
2521 Diag(AttrLoc, diag::err_attribute_size_too_large)
2522 << ColRange <<
"matrix column";
2530 Diag(
Loc, diag::err_func_returning_array_function)
2538 Diag(
Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 <<
2546 Diag(
Loc, diag::err_object_cannot_be_passed_returned_by_value)
2551 if (
T.hasNonTrivialToPrimitiveDestructCUnion() ||
2552 T.hasNonTrivialToPrimitiveCopyCUnion())
2559 Diag(
Loc, diag::warn_deprecated_volatile_return) <<
T;
2574 bool emittedError =
false;
2576 enum class RequiredCC { OnlySwift, SwiftOrSwiftAsync };
2577 auto checkCompatible = [&](
unsigned paramIndex, RequiredCC required) {
2579 (required == RequiredCC::OnlySwift)
2582 if (isCompatible || emittedError)
2584 S.
Diag(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall)
2586 << (required == RequiredCC::OnlySwift);
2587 emittedError =
true;
2589 for (
size_t paramIndex = 0, numParams = paramTypes.size();
2590 paramIndex != numParams; ++paramIndex) {
2601 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
2602 if (paramIndex != 0 &&
2605 S.
Diag(getParamLoc(paramIndex),
2606 diag::err_swift_indirect_result_not_first);
2611 checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);
2620 checkCompatible(paramIndex, RequiredCC::OnlySwift);
2621 if (paramIndex == 0 ||
2624 S.
Diag(getParamLoc(paramIndex),
2625 diag::err_swift_error_result_not_after_swift_context);
2629 llvm_unreachable(
"bad ABI kind");
2641 for (
unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) {
2645 Diag(
Loc, diag::err_param_with_void_type);
2650 Diag(
Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<
2654 Diag(
Loc, diag::err_wasm_table_as_function_parameter);
2661 Diag(
Loc, diag::warn_deprecated_volatile_param) << ParamType;
2663 ParamTypes[Idx] = ParamType;
2668 [=](
unsigned i) {
return Loc; });
2688 Diag(
Loc, diag::err_distant_exception_spec);
2695 Diag(
Loc, diag::err_illegal_decl_mempointer_to_reference)
2701 Diag(
Loc, diag::err_illegal_decl_mempointer_to_void)
2706 if (!
Class->isDependentType() && !
Class->isRecordType()) {
2707 Diag(
Loc, diag::err_mempointer_in_nonclass_type) <<
Class;
2714 Diag(
Loc, diag::err_opencl_function_pointer) << 0;
2719 Diag(
Loc, diag::err_hlsl_pointers_unsupported) << 0;
2738 Diag(
Loc, diag::err_nonfunction_block_type);
2754 if (TInfo) *TInfo =
nullptr;
2759 if (
const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
2760 QT = LIT->getType();
2761 DI = LIT->getTypeSourceInfo();
2764 if (TInfo) *TInfo = DI;
2770 unsigned chunkIndex);
2777 Sema &S = state.getSema();
2778 Declarator &declarator = state.getDeclarator();
2784 unsigned outermostPointerIndex = 0;
2786 unsigned numPointers = 0;
2788 unsigned chunkIndex = i;
2790 switch (chunk.
Kind) {
2800 outermostPointerIndex = chunkIndex;
2808 if (numPointers != 1)
return;
2810 outermostPointerIndex = chunkIndex;
2828 if (numPointers == 1) {
2846 }
else if (numPointers == 2) {
2859 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership)
2863 outermostPointerIndex);
2885 }
const QualKinds[5] = {
2894 unsigned NumQuals = 0;
2899 for (
auto &
E : QualKinds) {
2900 if (Quals &
E.Mask) {
2901 if (!QualStr.empty()) QualStr +=
' ';
2918 << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];
2924 unsigned FunctionChunkIndex) {
2926 D.getTypeObject(FunctionChunkIndex).Fun;
2934 for (
unsigned OuterChunkIndex = FunctionChunkIndex + 1,
2935 End =
D.getNumTypeObjects();
2936 OuterChunkIndex != End; ++OuterChunkIndex) {
2938 switch (OuterChunk.
Kind) {
2945 diag::warn_qual_return_type,
2967 D.getIdentifierLoc());
2971 llvm_unreachable(
"unknown declarator chunk kind");
2983 D.getDeclSpec().getTypeQualifiers(),
2984 D.getIdentifierLoc(),
2985 D.getDeclSpec().getConstSpecLoc(),
2986 D.getDeclSpec().getVolatileSpecLoc(),
2987 D.getDeclSpec().getRestrictSpecLoc(),
2988 D.getDeclSpec().getAtomicSpecLoc(),
2989 D.getDeclSpec().getUnalignedSpecLoc());
2992static std::pair<QualType, TypeSourceInfo *>
2996 Sema &S = state.getSema();
3000 const unsigned AutoParameterPosition = Info.
TemplateParams.size();
3001 const bool IsParameterPack =
D.hasEllipsis();
3012 D.getDeclSpec().getTypeSpecTypeLoc(),
3013 D.getIdentifierLoc(),
3014 TemplateParameterDepth, AutoParameterPosition,
3016 D.getIdentifier(), AutoParameterPosition),
false,
3017 IsParameterPack,
Auto->isConstrained());
3022 if (
Auto->isConstrained()) {
3029 for (
unsigned Idx = 0; Idx < AutoLoc.
getNumArgs(); ++Idx) {
3030 if (
D.getEllipsisLoc().isInvalid() && !
Invalid &&
3042 InventedTemplateParam,
3044 D.getEllipsisLoc());
3058 if (
D.getEllipsisLoc().isInvalid()) {
3074 D.getDeclSpec().getTypeSpecScope().getWithLocInContext(S.
Context),
3079 USD ? cast<NamedDecl>(USD) : CD,
3081 InventedTemplateParam,
3083 D.getEllipsisLoc());
3093 QualType NewT = state.ReplaceAutoType(
T, Replacement);
3097 return {NewT, NewTSI};
3106 Sema &SemaRef = state.getSema();
3109 ReturnTypeInfo =
nullptr;
3112 TagDecl *OwnedTagDecl =
nullptr;
3122 if (!
D.isInvalidType() &&
D.getDeclSpec().isTypeSpecOwned()) {
3123 OwnedTagDecl = cast<TagDecl>(
D.getDeclSpec().getRepAsDecl());
3136 D.getMutableDeclSpec().getAttributes());
3163 bool DeducedIsTrailingReturnType =
false;
3164 if (Deduced && isa<AutoType>(Deduced) &&
D.hasTrailingReturnType()) {
3167 DeducedIsTrailingReturnType =
true;
3177 bool IsCXXAutoType =
3179 bool IsDeducedReturnType =
false;
3181 switch (
D.getContext()) {
3220 assert(Info &&
"No LambdaScopeInfo on the stack!");
3226 if (!DeducedIsTrailingReturnType)
3231 if (
D.isStaticMember() ||
D.isFunctionDeclarator())
3234 if (isa<ObjCContainerDecl>(SemaRef.
CurContext)) {
3237 switch (cast<TagDecl>(SemaRef.
CurContext)->getTagKind()) {
3239 llvm_unreachable(
"unhandled tag kind");
3241 Error = Cxx ? 1 : 2;
3244 Error = Cxx ? 3 : 4;
3254 if (
D.getDeclSpec().isFriendSpecified())
3263 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
3275 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
3276 !
D.getNumTypeObjects() &&
3289 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3291 IsDeducedReturnType =
true;
3294 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3296 IsDeducedReturnType =
true;
3299 if (isa<DeducedTemplateSpecializationType>(Deduced))
3301 if (SemaRef.
getLangOpts().CPlusPlus23 && IsCXXAutoType &&
3302 !
Auto->isDecltypeAuto())
3321 if (!IsCXXAutoType && !isa<DeducedTemplateSpecializationType>(Deduced))
3334 if (
D.isFunctionDeclarator() &&
3335 (!SemaRef.
getLangOpts().CPlusPlus11 || !IsCXXAutoType))
3338 SourceRange AutoRange =
D.getDeclSpec().getTypeSpecTypeLoc();
3345 switch (
Auto->getKeyword()) {
3351 assert(isa<DeducedTemplateSpecializationType>(Deduced) &&
3352 "unknown auto type");
3356 auto *DTST = dyn_cast<DeducedTemplateSpecializationType>(Deduced);
3359 SemaRef.
Diag(AutoRange.
getBegin(), diag::err_auto_not_allowed)
3361 <<
QualType(Deduced, 0) << AutoRange;
3366 D.setInvalidType(
true);
3372 ? diag::warn_cxx11_compat_generic_lambda
3373 : IsDeducedReturnType
3374 ? diag::warn_cxx11_compat_deduced_return_type
3375 : diag::warn_cxx98_compat_auto_type_specifier)
3384 unsigned DiagID = 0;
3385 switch (
D.getContext()) {
3390 llvm_unreachable(
"parser should not have allowed this");
3406 DiagID = diag::err_type_defined_in_alias_template;
3418 DiagID = diag::err_type_defined_in_type_specifier;
3428 DiagID = diag::err_type_defined_in_param_type;
3434 DiagID = diag::err_type_defined_in_condition;
3441 D.setInvalidType(
true);
3445 assert(!
T.isNull() &&
"This function should not return a null type");
3454 assert(FTI.
isAmbiguous &&
"no direct-initializer / function ambiguity");
3470 if (!
D.isFunctionDeclarator() ||
3484 FTI.
NumParams ? diag::warn_parens_disambiguated_as_function_declaration
3485 : diag::warn_empty_parens_are_function_decl)
3493 if (!
D.isFirstDeclarator() &&
D.getIdentifier()) {
3496 if (Comma.getFileID() != Name.getFileID() ||
3497 Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) {
3501 S.
Diag(
D.getCommaLoc(), diag::note_empty_parens_function_call)
3503 <<
D.getIdentifier();
3504 Result.suppressDiagnostics();
3517 S.
Diag(B, diag::note_additional_parens_for_variable_declaration)
3532 S.
Diag(DeclType.
Loc, diag::note_empty_parens_default_ctor)
3540 S.
Diag(DeclType.
Loc, diag::note_empty_parens_zero_initialize)
3551 "do not have redundant top-level parentheses");
3560 bool CouldBeTemporaryObject =
3561 S.
getLangOpts().CPlusPlus &&
D.isExpressionContext() &&
3562 !
D.isInvalidType() &&
D.getIdentifier() &&
3565 D.getDeclSpec().getTypeQualifiers() == 0 &&
D.isFirstDeclarator();
3567 bool StartsWithDeclaratorId =
true;
3568 for (
auto &
C :
D.type_objects()) {
3575 StartsWithDeclaratorId =
false;
3580 CouldBeTemporaryObject =
false;
3588 CouldBeTemporaryObject =
false;
3589 StartsWithDeclaratorId =
false;
3599 CouldBeTemporaryObject =
false;
3606 CouldBeTemporaryObject =
false;
3607 StartsWithDeclaratorId =
false;
3617 if (CouldBeTemporaryObject) {
3621 CouldBeTemporaryObject =
false;
3622 Result.suppressDiagnostics();
3627 if (!CouldBeTemporaryObject) {
3632 if (StartsWithDeclaratorId &&
D.getCXXScopeSpec().isValid()) {
3634 NNS = NNS->getPrefix()) {
3640 S.
Diag(
Paren.Loc, diag::warn_redundant_parens_around_declarator)
3646 S.
Diag(
Paren.Loc, diag::warn_parens_disambiguated_as_variable_declaration)
3647 << ParenRange <<
D.getIdentifier();
3649 if (!RD || !RD->hasDefinition() || RD->hasNonTrivialDestructor())
3650 S.
Diag(
Paren.Loc, diag::note_raii_guard_add_name)
3652 <<
D.getIdentifier();
3658 S.
Diag(
Paren.Loc, diag::note_remove_parens_for_variable_declaration)
3674 switch (AL.getKind()) {
3693 bool IsCXXInstanceMethod =
false;
3699 unsigned I = ChunkIndex;
3700 bool FoundNonParen =
false;
3701 while (I && !FoundNonParen) {
3704 FoundNonParen =
true;
3707 if (FoundNonParen) {
3710 IsCXXInstanceMethod =
3715 IsCXXInstanceMethod =
3719 assert(
D.isFunctionDeclarator());
3723 IsCXXInstanceMethod =
3724 D.isFirstDeclarationOfMember() &&
3726 !
D.isStaticMember();
3731 IsCXXInstanceMethod);
3738 for (
const ParsedAttr &AL :
D.getDeclSpec().getAttributes()) {
3739 if (AL.getKind() == ParsedAttr::AT_OpenCLKernel) {
3750 if (Triple.isSPIRV() && Triple.getVendor() != llvm::Triple::AMD) {
3751 for (
const ParsedAttr &AL :
D.getDeclSpec().getAttributes()) {
3752 if (AL.getKind() == ParsedAttr::AT_CUDAGlobal) {
3766 enum class SimplePointerKind {
3775 switch (nullability) {
3777 if (!Ident__Nonnull)
3779 return Ident__Nonnull;
3782 if (!Ident__Nullable)
3784 return Ident__Nullable;
3787 if (!Ident__Nullable_result)
3789 return Ident__Nullable_result;
3792 if (!Ident__Null_unspecified)
3794 return Ident__Null_unspecified;
3796 llvm_unreachable(
"Unknown nullability kind.");
3803 if (AL.getKind() == ParsedAttr::AT_TypeNonNull ||
3804 AL.getKind() == ParsedAttr::AT_TypeNullable ||
3805 AL.getKind() == ParsedAttr::AT_TypeNullableResult ||
3806 AL.getKind() == ParsedAttr::AT_TypeNullUnspecified)
3815 enum class PointerDeclaratorKind {
3823 MaybePointerToCFRef,
3827 NSErrorPointerPointer,
3833 enum class PointerWrappingDeclaratorKind {
3847static PointerDeclaratorKind
3849 PointerWrappingDeclaratorKind &wrappingKind) {
3850 unsigned numNormalPointers = 0;
3853 if (
type->isDependentType())
3854 return PointerDeclaratorKind::NonPointer;
3859 switch (chunk.
Kind) {
3861 if (numNormalPointers == 0)
3862 wrappingKind = PointerWrappingDeclaratorKind::Array;
3871 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3872 : PointerDeclaratorKind::SingleLevelPointer;
3878 if (numNormalPointers == 0)
3879 wrappingKind = PointerWrappingDeclaratorKind::Reference;
3883 ++numNormalPointers;
3884 if (numNormalPointers > 2)
3885 return PointerDeclaratorKind::MultiLevelPointer;
3891 unsigned numTypeSpecifierPointers = 0;
3895 ++numNormalPointers;
3897 if (numNormalPointers > 2)
3898 return PointerDeclaratorKind::MultiLevelPointer;
3900 type = ptrType->getPointeeType();
3901 ++numTypeSpecifierPointers;
3907 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3908 : PointerDeclaratorKind::SingleLevelPointer;
3913 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3914 : PointerDeclaratorKind::SingleLevelPointer;
3919 ++numNormalPointers;
3920 ++numTypeSpecifierPointers;
3923 if (
auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) {
3925 numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3926 return PointerDeclaratorKind::NSErrorPointerPointer;
3935 if (objcClass->getInterface()->getIdentifier() ==
3937 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2)
3938 return PointerDeclaratorKind::NSErrorPointerPointer;
3945 if (numNormalPointers == 0)
3946 return PointerDeclaratorKind::NonPointer;
3952 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2 &&
3954 return PointerDeclaratorKind::CFErrorRefPointer;
3962 switch (numNormalPointers) {
3964 return PointerDeclaratorKind::NonPointer;
3967 return PointerDeclaratorKind::SingleLevelPointer;
3970 return PointerDeclaratorKind::MaybePointerToCFRef;
3973 return PointerDeclaratorKind::MultiLevelPointer;
3982 if (ctx->isFunctionOrMethod())
3985 if (ctx->isFileContext())
3996 bool invalid =
false;
3998 if (invalid || !sloc.
isFile())
4016template <
typename DiagBuilderT>
4025 if (!FixItLoc.
isValid() || FixItLoc == PointerLoc)
4034 InsertionTextBuf +=
" ";
4035 StringRef InsertionText = InsertionTextBuf.str();
4038 InsertionText = InsertionText.drop_back();
4039 }
else if (NextChar[-1] ==
'[') {
4040 if (NextChar[0] ==
']')
4041 InsertionText = InsertionText.drop_back().drop_front();
4043 InsertionText = InsertionText.drop_front();
4046 InsertionText = InsertionText.drop_back().drop_front();
4053 SimplePointerKind PointerKind,
4058 if (PointerKind == SimplePointerKind::Array) {
4059 S.
Diag(PointerLoc, diag::warn_nullability_missing_array);
4061 S.
Diag(PointerLoc, diag::warn_nullability_missing)
4062 <<
static_cast<unsigned>(PointerKind);
4065 auto FixItLoc = PointerEndLoc.
isValid() ? PointerEndLoc : PointerLoc;
4066 if (FixItLoc.isMacroID())
4070 auto Diag = S.
Diag(FixItLoc, diag::note_nullability_fix_it);
4071 Diag << static_cast<unsigned>(Nullability);
4072 Diag << static_cast<unsigned>(PointerKind);
4101 if (pointerKind == SimplePointerKind::Array)
4102 diagKind = diag::warn_nullability_missing_array;
4104 diagKind = diag::warn_nullability_missing;
4110 fileNullability.
PointerKind =
static_cast<unsigned>(pointerKind);
4142 auto kind =
static_cast<SimplePointerKind
>(fileNullability.
PointerKind);
4157 unsigned i = endIndex;
4185template<
typename AttrT>
4188 return ::new (Ctx) AttrT(Ctx, AL);
4195 return createSimpleAttr<TypeNonNullAttr>(Ctx,
Attr);
4198 return createSimpleAttr<TypeNullableAttr>(Ctx,
Attr);
4201 return createSimpleAttr<TypeNullableResultAttr>(Ctx,
Attr);
4204 return createSimpleAttr<TypeNullUnspecifiedAttr>(Ctx,
Attr);
4206 llvm_unreachable(
"unknown NullabilityKind");
4217 if (ASOld != ASNew) {
4218 S.
Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
4223 diag::warn_attribute_address_multiple_identical_qualifiers);
4237 !isa<RecordType, TemplateSpecializationType>(
4248 Sema &S = state.getSema();
4254 if (
D.getIdentifier())
4255 Name =
D.getIdentifier();
4258 bool IsTypedefName =
4274 bool IsClassTemplateDeduction = isa<DeducedTemplateSpecializationType>(DT);
4276 for (
unsigned I = 0,
E =
D.getNumTypeObjects(); I !=
E; ++I) {
4277 unsigned Index =
E - I - 1;
4279 unsigned DiagId = IsClassTemplateDeduction
4280 ? diag::err_deduced_class_template_compound_type
4281 : diag::err_decltype_auto_compound_type;
4282 unsigned DiagKind = 0;
4283 switch (DeclChunk.
Kind) {
4286 if (IsClassTemplateDeduction) {
4292 if (IsClassTemplateDeduction) {
4297 if (
D.isFunctionDeclarationContext() &&
4298 D.isFunctionDeclarator(FnIndex) && FnIndex == Index)
4300 DiagId = diag::err_decltype_auto_function_declarator_not_declaration;
4318 S.
Diag(DeclChunk.
Loc, DiagId) << DiagKind;
4319 D.setInvalidType(
true);
4326 std::optional<NullabilityKind> inferNullability;
4327 bool inferNullabilityCS =
false;
4328 bool inferNullabilityInnerOnly =
false;
4329 bool inferNullabilityInnerOnlyComplete =
false;
4332 bool inAssumeNonNullRegion =
false;
4334 if (assumeNonNullLoc.
isValid()) {
4335 inAssumeNonNullRegion =
true;
4349 } complainAboutMissingNullability = CAMN_No;
4350 unsigned NumPointersRemaining = 0;
4351 auto complainAboutInferringWithinChunk = PointerWrappingDeclaratorKind::None;
4353 if (IsTypedefName) {
4357 complainAboutMissingNullability = CAMN_InnerPointers;
4361 ++NumPointersRemaining;
4364 for (
unsigned i = 0, n =
D.getNumTypeObjects(); i != n; ++i) {
4366 switch (chunk.
Kind) {
4374 ++NumPointersRemaining;
4382 ++NumPointersRemaining;
4387 bool isFunctionOrMethod =
false;
4388 switch (
auto context = state.getDeclarator().getContext()) {
4394 isFunctionOrMethod =
true;
4398 if (state.getDeclarator().isObjCIvar() && !isFunctionOrMethod) {
4399 complainAboutMissingNullability = CAMN_No;
4404 if (state.getDeclarator().isObjCWeakProperty()) {
4407 complainAboutMissingNullability = CAMN_No;
4408 if (inAssumeNonNullRegion) {
4418 complainAboutMissingNullability = CAMN_Yes;
4421 auto wrappingKind = PointerWrappingDeclaratorKind::None;
4423 case PointerDeclaratorKind::NonPointer:
4424 case PointerDeclaratorKind::MultiLevelPointer:
4428 case PointerDeclaratorKind::SingleLevelPointer:
4430 if (inAssumeNonNullRegion) {
4431 complainAboutInferringWithinChunk = wrappingKind;
4438 case PointerDeclaratorKind::CFErrorRefPointer:
4439 case PointerDeclaratorKind::NSErrorPointerPointer:
4442 if (isFunctionOrMethod && inAssumeNonNullRegion)
4446 case PointerDeclaratorKind::MaybePointerToCFRef:
4447 if (isFunctionOrMethod) {
4451 auto hasCFReturnsAttr =
4453 return AttrList.hasAttribute(ParsedAttr::AT_CFReturnsRetained) ||
4454 AttrList.hasAttribute(ParsedAttr::AT_CFReturnsNotRetained);
4456 if (
const auto *InnermostChunk =
D.getInnermostNonParenChunk()) {
4457 if (hasCFReturnsAttr(
D.getDeclarationAttributes()) ||
4458 hasCFReturnsAttr(
D.getAttributes()) ||
4459 hasCFReturnsAttr(InnermostChunk->getAttrs()) ||
4460 hasCFReturnsAttr(
D.getDeclSpec().getAttributes())) {
4462 inferNullabilityInnerOnly =
true;
4472 complainAboutMissingNullability = CAMN_Yes;
4500 auto isVaList = [&S](
QualType T) ->
bool {
4506 if (typedefTy->getDecl() == vaListTypedef)
4508 if (
auto *name = typedefTy->getDecl()->getIdentifier())
4509 if (name->isStr(
"va_list"))
4511 typedefTy = typedefTy->desugar()->getAs<
TypedefType>();
4512 }
while (typedefTy);
4518 auto inferPointerNullability =
4523 if (NumPointersRemaining > 0)
4524 --NumPointersRemaining;
4531 if (inferNullability && !inferNullabilityInnerOnlyComplete) {
4534 ? ParsedAttr::Form::ContextSensitiveKeyword()
4535 : ParsedAttr::Form::Keyword(
false ,
4541 attrs.addAtEnd(nullabilityAttr);
4543 if (inferNullabilityCS) {
4544 state.getDeclarator().getMutableDeclSpec().getObjCQualifiers()
4548 if (pointerLoc.isValid() &&
4549 complainAboutInferringWithinChunk !=
4550 PointerWrappingDeclaratorKind::None) {
4552 S.
Diag(pointerLoc, diag::warn_nullability_inferred_on_nested_type);
4553 Diag << static_cast<int>(complainAboutInferringWithinChunk);
4557 if (inferNullabilityInnerOnly)
4558 inferNullabilityInnerOnlyComplete =
true;
4559 return nullabilityAttr;
4564 switch (complainAboutMissingNullability) {
4568 case CAMN_InnerPointers:
4569 if (NumPointersRemaining == 0)
4585 if (NumPointersRemaining > 0)
4586 --NumPointersRemaining;
4588 SimplePointerKind pointerKind = SimplePointerKind::Pointer;
4590 pointerKind = SimplePointerKind::BlockPointer;
4592 pointerKind = SimplePointerKind::MemberPointer;
4594 if (
auto *
attr = inferPointerNullability(
4595 pointerKind,
D.getDeclSpec().getTypeSpecTypeLoc(),
4597 D.getMutableDeclSpec().getAttributes(),
4598 D.getMutableDeclSpec().getAttributePool())) {
4599 T = state.getAttributedType(
4605 if (complainAboutMissingNullability == CAMN_Yes &&
T->
isArrayType() &&
4609 D.getDeclSpec().getTypeSpecTypeLoc());
4613 bool ExpectNoDerefChunk =
4614 state.getCurrentAttributes().hasAttribute(ParsedAttr::AT_NoDeref);
4624 bool AreDeclaratorChunksValid =
true;
4625 for (
unsigned i = 0, e =
D.getNumTypeObjects(); i != e; ++i) {
4626 unsigned chunkIndex = e - i - 1;
4627 state.setCurrentChunkIndex(chunkIndex);
4630 switch (DeclType.
Kind) {
4638 if (!LangOpts.Blocks)
4639 S.
Diag(DeclType.
Loc, diag::err_blocks_disable) << LangOpts.OpenCL;
4642 inferPointerNullability(SimplePointerKind::BlockPointer, DeclType.
Loc,
4644 state.getDeclarator().getAttributePool());
4650 if (LangOpts.OpenCL)
4659 S.
Diag(
D.getIdentifierLoc(), diag::err_distant_exception_spec);
4660 D.setInvalidType(
true);
4665 inferPointerNullability(SimplePointerKind::Pointer, DeclType.
Loc,
4667 state.getDeclarator().getAttributePool());
4679 if (LangOpts.OpenCL) {
4682 S.
Diag(
D.getIdentifierLoc(), diag::err_opencl_pointer_to_type) <<
T;
4683 D.setInvalidType(
true);
4695 S.
Diag(
D.getIdentifierLoc(), diag::err_distant_exception_spec);
4696 D.setInvalidType(
true);
4709 S.
Diag(
D.getIdentifierLoc(), diag::err_distant_exception_spec);
4710 D.setInvalidType(
true);
4720 if (chunkIndex != 0 && !ArraySize &&
4721 D.getDeclSpec().getAttributes().hasMSPropertyAttr()) {
4739 S.
Diag(DeclType.
Loc, diag::err_array_star_outside_prototype);
4741 D.setInvalidType(
true);
4748 if (!(
D.isPrototypeContext() ||
4750 S.
Diag(DeclType.
Loc, diag::err_array_static_outside_prototype)
4752 :
"type qualifier");
4757 D.setInvalidType(
true);
4763 S.
Diag(DeclType.
Loc, diag::err_array_static_not_outermost)
4765 :
"type qualifier");
4769 D.setInvalidType(
true);
4775 if (complainAboutMissingNullability == CAMN_Yes &&
4791 IsQualifiedFunction =
4796 if (!
D.isInvalidType()) {
4800 return SS.isInvalid() ||
4822 ? dyn_cast_if_present<ParmVarDecl>(FTI.
Params[0].
Param)
4825 bool IsFunctionDecl =
D.getInnermostNonParenChunk() == &DeclType;
4826 if (
First &&
First->isExplicitObjectParameter() &&
4837 !IsClassType(
D.getCXXScopeSpec())) {
4840 diag::err_explicit_object_parameter_nonmember)
4842 <<
First->getSourceRange();
4845 diag::err_explicit_object_parameter_invalid)
4846 <<
First->getSourceRange();
4849 AreDeclaratorChunksValid =
false;
4854 if (
D.getDeclSpec().hasAutoTypeSpec() &&
4857 S.
Diag(
D.getDeclSpec().getTypeSpecTypeLoc(),
4859 ? diag::err_auto_missing_trailing_return
4860 : diag::err_deduced_return_type);
4862 D.setInvalidType(
true);
4863 AreDeclaratorChunksValid =
false;
4865 S.
Diag(
D.getDeclSpec().getTypeSpecTypeLoc(),
4866 diag::warn_cxx11_compat_deduced_return_type);
4870 if (isa<ParenType>(
T)) {
4873 D.setInvalidType(
true);
4875 AreDeclaratorChunksValid =
false;
4876 }
else if (
D.getName().
getKind() ==
4880 diag::err_deduction_guide_with_complex_decl)
4882 D.setInvalidType(
true);
4884 AreDeclaratorChunksValid =
false;
4887 (
T.hasQualifiers() || !isa<AutoType>(
T) ||
4888 cast<AutoType>(
T)->getKeyword() !=
4890 cast<AutoType>(
T)->isConstrained())) {
4901 S.
Diag(
Loc, diag::err_trailing_return_without_auto) <<
T << SR;
4902 D.setInvalidType(
true);
4904 AreDeclaratorChunksValid =
false;
4910 D.setInvalidType(
true);
4920 if (InventedParamInfo) {
4922 state,
T, TInfo,
Auto, *InventedParamInfo);
4936 unsigned diagID = diag::err_func_returning_array_function;
4939 if (chunkIndex == 0 &&
4941 diagID = diag::err_block_returning_array_function;
4944 D.setInvalidType(
true);
4945 AreDeclaratorChunksValid =
false;
4954 S.
Diag(
D.getIdentifierLoc(), diag::err_opencl_invalid_return)
4956 D.setInvalidType(
true);
4958 }
else if (!S.
getLangOpts().NativeHalfArgsAndReturns &&
4960 S.
Diag(
D.getIdentifierLoc(),
4961 diag::err_parameters_retval_cannot_have_fp16_type) << 1;
4962 D.setInvalidType(
true);
4966 if (LangOpts.OpenCL) {
4971 S.
Diag(
D.getIdentifierLoc(), diag::err_opencl_invalid_return)
4973 D.setInvalidType(
true);
4980 "__cl_clang_variadic_functions", S.
getLangOpts()) &&
4981 !(
D.getIdentifier() &&
4982 ((
D.getIdentifier()->getName() ==
"printf" &&
4984 D.getIdentifier()->getName().starts_with(
"__")))) {
4985 S.
Diag(
D.getIdentifierLoc(), diag::err_opencl_variadic_function);
4986 D.setInvalidType(
true);
4998 DiagLoc =
D.getDeclSpec().getTypeSpecTypeLoc();
5001 S.
Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value)
5013 AreDeclaratorChunksValid =
false;
5016 D.setInvalidType(
true);
5025 D.getFunctionDefinitionKind() ==
5030 S.
Diag(DeclType.
Loc, diag::err_func_returning_qualified_void) <<
T;
5036 if (
T.isVolatileQualified() && S.
getLangOpts().CPlusPlus20)
5037 S.
Diag(DeclType.
Loc, diag::warn_deprecated_volatile_return) <<
T;
5043 if (
T.getQualifiers().hasObjCLifetime()) {
5045 if (chunkIndex + 1 <
D.getNumTypeObjects()) {
5048 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5049 AttrLoc = AL.getLoc();
5055 for (
const ParsedAttr &AL :
D.getDeclSpec().getAttributes()) {
5056 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
5057 AttrLoc = AL.getLoc();
5071 S.
Diag(AttrLoc, diag::warn_arc_lifetime_result_type)
5072 <<
T.getQualifiers().getObjCLifetime();
5076 if (LangOpts.CPlusPlus &&
D.getDeclSpec().hasTagDefinition()) {
5079 TagDecl *Tag = cast<TagDecl>(
D.getDeclSpec().getRepAsDecl());
5080 S.
Diag(Tag->getLocation(), diag::err_type_defined_in_result_type)
5088 diag::err_exception_spec_in_typedef)
5114 diag::warn_c17_compat_ellipsis_only_parameter);
5115 else if (!
D.getDeclarationAttributes().hasAttribute(
5116 ParsedAttr::AT_Overloadable) &&
5117 !
D.getAttributes().hasAttribute(
5118 ParsedAttr::AT_Overloadable) &&
5119 !
D.getDeclSpec().getAttributes().hasAttribute(
5120 ParsedAttr::AT_Overloadable))
5128 diag::err_ident_list_in_fn_declaration);
5129 D.setInvalidType(
true);
5134 AreDeclaratorChunksValid =
false;
5157 bool HasAnyInterestingExtParameterInfos =
false;
5159 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
5162 assert(!ParamTy.
isNull() &&
"Couldn't parse type?");
5173 ParamTy = Context.
IntTy;
5178 ParamTy = Context.
IntTy;
5183 S.
Diag(DeclType.
Loc, diag::err_void_param_qualified);
5189 diag::err_void_explicit_object_param);
5207 }
else if (!S.
getLangOpts().NativeHalfArgsAndReturns &&
5210 diag::err_parameters_retval_cannot_have_fp16_type) << 0;
5218 if (BTy->getKind() == BuiltinType::Float) {
5230 if (LangOpts.ObjCAutoRefCount && Param->
hasAttr<NSConsumedAttr>()) {
5231 ExtParameterInfos[i] = ExtParameterInfos[i].withIsConsumed(
true);
5232 HasAnyInterestingExtParameterInfos =
true;
5236 ExtParameterInfos[i] =
5237 ExtParameterInfos[i].withABI(
attr->getABI());
5238 HasAnyInterestingExtParameterInfos =
true;
5241 if (Param->
hasAttr<PassObjectSizeAttr>()) {
5242 ExtParameterInfos[i] = ExtParameterInfos[i].withHasPassObjectSize();
5243 HasAnyInterestingExtParameterInfos =
true;
5246 if (Param->
hasAttr<NoEscapeAttr>()) {
5247 ExtParameterInfos[i] = ExtParameterInfos[i].withIsNoEscape(
true);
5248 HasAnyInterestingExtParameterInfos =
true;
5251 ParamTys.push_back(ParamTy);
5254 if (HasAnyInterestingExtParameterInfos) {
5263 Expr *NoexceptExpr =
nullptr;
5269 DynamicExceptions.reserve(N);
5270 DynamicExceptionRanges.reserve(N);
5271 for (
unsigned I = 0; I != N; ++I) {
5282 DynamicExceptionRanges,
5289 auto IsClassMember = [&]() {
5290 return (!state.getDeclarator().getCXXScopeSpec().isEmpty() &&
5291 state.getDeclarator()
5295 state.getDeclarator().getContext() ==
5297 state.getDeclarator().getContext() ==
5301 if (state.getSema().getLangOpts().OpenCLCPlusPlus && IsClassMember()) {
5310 D.setInvalidType(
true);
5331 inferPointerNullability(SimplePointerKind::MemberPointer, DeclType.
Loc,
5333 state.getDeclarator().getAttributePool());
5337 D.setInvalidType(
true);
5352 llvm_unreachable(
"Nested-name-specifier must name a type");
5364 if (isa<DependentTemplateSpecializationType>(NNSType)) {
5367 }
else if (isa<TemplateSpecializationType, RecordType>(NNSType)) {
5371 NNSPrefix, ClsType);
5377 diag::err_illegal_decl_mempointer_in_nonclass)
5378 << (
D.getIdentifier() ?
D.getIdentifier()->getName() :
"type name")
5380 D.setInvalidType(
true);
5387 AreDeclaratorChunksValid =
false;
5391 D.setInvalidType(
true);
5392 AreDeclaratorChunksValid =
false;
5402 D.getMutableDeclSpec().getAttributes());
5408 D.setInvalidType(
true);
5410 AreDeclaratorChunksValid =
false;
5419 S.
Diag(DeclType.
Loc, diag::warn_noderef_on_non_pointer_or_array);
5421 ExpectNoDerefChunk = state.didParseNoDeref();
5425 if (ExpectNoDerefChunk)
5426 S.
Diag(state.getDeclarator().getBeginLoc(),
5427 diag::warn_noderef_on_non_pointer_or_array);
5440 bool IsBlock =
false;
5442 switch (DeclType.Kind) {
5454 S.
Diag(DeclType.Loc, diag::warn_strict_prototypes)
5466 assert(!
T.isNull() &&
"T must not be null after this point");
5470 assert(FnTy &&
"Why oh why is there not a FunctionProtoType here?");
5483 ExplicitObjectMember,
5487 Kind = DeductionGuide;
5488 else if (!
D.getCXXScopeSpec().isSet()) {
5491 !
D.getDeclSpec().isFriendSpecified())
5501 if (
D.isFunctionDeclarator(I)) {
5505 if (
P &&
P->isExplicitObjectParameter())
5506 Kind = ExplicitObjectMember;
5532 if (IsQualifiedFunction &&
5535 (Kind !=
Member ||
D.isExplicitObjectMemberFunction() ||
5538 D.isStaticMember())) &&
5544 if (
D.isFunctionDeclarator(I)) {
5557 if (!RemovalLocs.empty()) {
5558 llvm::sort(RemovalLocs,
5560 RemovalRange =
SourceRange(RemovalLocs.front(), RemovalLocs.back());
5561 Loc = RemovalLocs.front();
5565 S.
Diag(
Loc, diag::err_invalid_qualified_function_type)
5566 << Kind <<
D.isFunctionDeclarator() <<
T
5578 for (
unsigned i = 0, e =
D.getNumTypeObjects(); i != e; ++i) {
5588 for (
ParsedAttr &AL :
D.getDeclarationAttributes()) {
5589 if (!AL.slidesFromDeclToDeclSpecLegacyBehavior()) {
5597 state.diagnoseIgnoredTypeAttrs(
T);
5608 if (
T.isVolatileQualified() && S.
getLangOpts().CPlusPlus20 &&
5611 S.
Diag(
D.getIdentifierLoc(), diag::warn_deprecated_volatile_param) <<
T;
5615 if (
D.hasEllipsis()) {
5620 switch (
D.getContext()) {
5635 S.
Diag(
D.getEllipsisLoc(),
5636 diag::err_function_parameter_pack_without_parameter_packs)
5656 S.
Diag(
D.getEllipsisLoc(),
5657 LangOpts.CPlusPlus11
5658 ? diag::warn_cxx98_compat_variadic_templates
5659 : diag::ext_variadic_templates);
5688 S.
Diag(
D.getEllipsisLoc(),
5689 diag::err_ellipsis_in_declarator_not_parameter);
5695 assert(!
T.isNull() &&
"T must not be null at the end of this function");
5696 if (!AreDeclaratorChunksValid)
5708 TypeProcessingState state(*
this,
D);
5712 if (
D.isPrototypeContext() &&
getLangOpts().ObjCAutoRefCount)
5731 unsigned chunkIndex) {
5732 Sema &S = state.getSema();
5740 const char *attrStr =
nullptr;
5741 switch (ownership) {
5760 &Args, 1, ParsedAttr::Form::GNU());
5769 Sema &S = state.getSema();
5773 bool hasIndirection =
false;
5774 for (
unsigned i = 0, e =
D.getNumTypeObjects(); i != e; ++i) {
5776 switch (chunk.
Kind) {
5785 hasIndirection =
true;
5818 TypeProcessingState state(*
this,
D);
5833 TypeProcessingState &State) {
5838 TypeProcessingState &State) {
5840 State.getSema().HLSL().TakeLocForHLSLAttribute(TL.
getTypePtr());
5848 if (AL.getKind() == ParsedAttr::AT_MatrixType) {
5857 llvm_unreachable(
"no matrix_type attribute found at the expected location!");
5862 switch (Chunk.
Kind) {
5867 llvm_unreachable(
"cannot be _Atomic qualified");
5885 class TypeSpecLocFiller :
public TypeLocVisitor<TypeSpecLocFiller> {
5888 TypeProcessingState &State;
5892 TypeSpecLocFiller(
Sema &S,
ASTContext &Context, TypeProcessingState &State,
5894 : SemaRef(S), Context(Context), State(State), DS(DS) {}
5910 State.getExpansionLocForMacroQualifiedType(TL.
getTypePtr()));
6033 void VisitDependentTemplateSpecializationTypeLoc(
6062 if (TemplateId->
NumArgs > 0) {
6074 FoundDecl = cast<NamedDecl>(USD);
6076 FoundDecl = cast_if_present<NamedDecl>(TN.getAsTemplateDecl());
6122 void VisitTypeLoc(
TypeLoc TL) {
6128 class DeclaratorLocFiller :
public TypeLocVisitor<DeclaratorLocFiller> {
6130 TypeProcessingState &State;
6134 DeclaratorLocFiller(
ASTContext &Context, TypeProcessingState &State,
6136 : Context(Context), State(State), Chunk(Chunk) {}
6139 llvm_unreachable(
"qualified type locs not expected here!");
6142 llvm_unreachable(
"decayed type locs not expected here!");
6145 llvm_unreachable(
"array parameter type locs not expected here!");
6184 assert(isa<DependentNameType>(ClsTy) &&
"Unexpected TypeLoc");
6195 if (isa<ElaboratedType>(ClsTy)) {
6210 llvm_unreachable(
"Nested-name-specifier must name a type");
6242 for (
unsigned i = 0, e = TL.
getNumParams(), tpi = 0; i != e; ++i) {
6281 void VisitTypeLoc(
TypeLoc TL) {
6282 llvm_unreachable(
"unsupported TypeLoc kind in declarator!");
6291 if (AL.getKind() == ParsedAttr::AT_AddressSpace) {
6300 "no address_space attribute found at the expected location!");
6314 Sema &S = State.getSema();
6321 if (isa<PackExpansionType>(
T)) {
6326 for (
unsigned i = 0, e =
D.getNumTypeObjects(); i != e; ++i) {
6330 D.getDeclSpec().getAttributes().hasMSPropertyAttr())
6340 bool HasDesugaredTypeLoc =
true;
6341 while (HasDesugaredTypeLoc) {
6343 case TypeLoc::MacroQualified: {
6346 State.getExpansionLocForMacroQualifiedType(TL.
getTypePtr()));
6351 case TypeLoc::Attributed: {
6358 case TypeLoc::Adjusted:
6359 case TypeLoc::BTFTagAttributed: {
6364 case TypeLoc::DependentAddressSpace: {
6372 HasDesugaredTypeLoc =
false;
6377 DeclaratorLocFiller(S.
Context, State,
D.getTypeObject(i)).Visit(CurrTL);
6383 if (ReturnTypeInfo) {
6388 TypeSpecLocFiller(S, S.
Context, State,
D.getDeclSpec()).Visit(CurrTL);
6403 "LocInfoType's TypeClass conflicts with an existing Type class");
6409 llvm_unreachable(
"LocInfoType leaked into the type system; an opaque TypeTy*"
6410 " was used directly instead of getting the QualType through"
6411 " GetTypeFromParser");
6417 assert(
D.getIdentifier() ==
nullptr &&
6418 "Type name should have no identifier!");
6422 if (
D.isInvalidType())
6455 const Expr *AddrSpace,
6458 std::optional<llvm::APSInt> OptAddrSpace =
6460 if (!OptAddrSpace) {
6461 S.
Diag(AttrLoc, diag::err_attribute_argument_type)
6466 llvm::APSInt &addrSpace = *OptAddrSpace;
6469 if (addrSpace.isSigned()) {
6470 if (addrSpace.isNegative()) {
6471 S.
Diag(AttrLoc, diag::err_attribute_address_space_negative)
6475 addrSpace.setIsSigned(
false);
6478 llvm::APSInt
max(addrSpace.getBitWidth());
6482 if (addrSpace >
max) {
6483 S.
Diag(AttrLoc, diag::err_attribute_address_space_too_high)
6514 Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
6530 TypeProcessingState &State) {
6531 Sema &S = State.getSema();
6537 if (!
Attr.diagnoseLangOpts(S)) {
6543 if (
Attr.getNumArgs() != 1) {
6544 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
6551 auto *StrLiteral = dyn_cast<StringLiteral>(
Attr.getArgAsExpr(0));
6560 StringRef BTFTypeTag = StrLiteral->getString();
6561 Type = State.getBTFTagAttributedType(
6562 ::new (Ctx) BTFTypeTagAttr(Ctx,
Attr, BTFTypeTag),
Type);
6570 TypeProcessingState &State) {
6571 Sema &S = State.getSema();
6576 S.
Diag(
Attr.
getLoc(), diag::err_attribute_address_function_type);
6582 if (
Attr.
getKind() == ParsedAttr::AT_AddressSpace) {
6585 if (
Attr.getNumArgs() != 1) {
6592 Expr *ASArgExpr =
static_cast<Expr *
>(
Attr.getArgAsExpr(0));
6601 ::new (Ctx) AddressSpaceAttr(Ctx,
Attr,
static_cast<unsigned>(ASIdx));
6613 if (EquivType.
isNull()) {
6617 T = State.getAttributedType(ASAttr,
Type, EquivType);
6619 T = State.getAttributedType(ASAttr,
Type,
Type);
6630 :
Attr.asOpenCLLangAS();
6632 ASIdx =
Attr.asHLSLLangAS();
6635 llvm_unreachable(
"Invalid address space");
6653 bool NonObjCPointer =
false;
6655 if (!
type->isDependentType() && !
type->isUndeducedType()) {
6663 NonObjCPointer =
true;
6664 }
else if (!
type->isObjCRetainableType()) {
6670 if (state.isProcessingDeclSpec()) {
6678 Sema &S = state.getSema();
6684 if (!
attr.isArgIdent(0)) {
6685 S.
Diag(AttrLoc, diag::err_attribute_argument_type) <<
attr
6693 if (II->
isStr(
"none"))
6695 else if (II->
isStr(
"strong"))
6697 else if (II->
isStr(
"weak"))
6699 else if (II->
isStr(
"autoreleasing"))
6702 S.
Diag(AttrLoc, diag::warn_attribute_type_not_supported) <<
attr << II;
6719 =
type.getQualifiers().getObjCLifetime()) {
6722 S.
Diag(AttrLoc, diag::err_attr_objc_ownership_redundant)
6729 if (previousLifetime != lifetime) {
6732 const Type *prevTy =
nullptr;
6733 while (!prevTy || prevTy != underlyingType.
Ty) {
6734 prevTy = underlyingType.
Ty;
6743 if (NonObjCPointer) {
6744 StringRef name =
attr.getAttrName()->getName();
6753 S.
Diag(AttrLoc, diag::warn_type_attribute_wrong_type) << name
6770 type = state.getAttributedType(
6771 createSimpleAttr<ObjCInertUnsafeUnretainedAttr>(S.
Context,
attr),
6777 if (!NonObjCPointer)
6794 diagnostic,
type, 0));
6796 S.
Diag(loc, diagnostic);
6805 unsigned diagnostic =
6806 (S.
getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled
6807 : diag::err_arc_weak_no_runtime);
6810 diagnoseOrDelay(S, AttrLoc, diagnostic,
type);
6822 if (
Class->isArcWeakrefUnavailable()) {
6823 S.
Diag(AttrLoc, diag::err_arc_unsupported_weak_class);
6824 S.
Diag(ObjT->getInterfaceDecl()->getLocation(),
6825 diag::note_class_declared);
6840 Sema &S = state.getSema();
6843 if (!
type->isPointerType() &&
6844 !
type->isObjCObjectPointerType() &&
6845 !
type->isBlockPointerType())
6849 S.
Diag(
attr.getLoc(), diag::err_attribute_multiple_objc_gc);
6855 if (!
attr.isArgIdent(0)) {
6856 S.
Diag(
attr.getLoc(), diag::err_attribute_argument_type)
6862 if (
attr.getNumArgs() > 1) {
6863 S.
Diag(
attr.getLoc(), diag::err_attribute_wrong_number_arguments) <<
attr
6870 if (II->
isStr(
"weak"))
6872 else if (II->
isStr(
"strong"))
6875 S.
Diag(
attr.getLoc(), diag::warn_attribute_type_not_supported)
6885 if (
attr.getLoc().isValid())
6886 type = state.getAttributedType(
6903 struct FunctionTypeUnwrapper {
6922 const Type *Ty =
T.getTypePtr();
6923 if (isa<FunctionType>(Ty)) {
6924 Fn = cast<FunctionType>(Ty);
6926 }
else if (isa<ParenType>(Ty)) {
6927 T = cast<ParenType>(Ty)->getInnerType();
6929 }
else if (isa<ConstantArrayType>(Ty) || isa<VariableArrayType>(Ty) ||
6930 isa<IncompleteArrayType>(Ty)) {
6931 T = cast<ArrayType>(Ty)->getElementType();
6932 Stack.push_back(Array);
6933 }
else if (isa<PointerType>(Ty)) {
6936 }
else if (isa<BlockPointerType>(Ty)) {
6938 Stack.push_back(BlockPointer);
6939 }
else if (isa<MemberPointerType>(Ty)) {
6941 Stack.push_back(MemberPointer);
6942 }
else if (isa<ReferenceType>(Ty)) {
6945 }
else if (isa<AttributedType>(Ty)) {
6946 T = cast<AttributedType>(Ty)->getEquivalentType();
6947 Stack.push_back(Attributed);
6948 }
else if (isa<MacroQualifiedType>(Ty)) {
6949 T = cast<MacroQualifiedType>(Ty)->getUnderlyingType();
6950 Stack.push_back(MacroQualified);
6959 Stack.push_back(Desugar);
6964 bool isFunctionType()
const {
return (Fn !=
nullptr); }
6969 if (New == get())
return Original;
6972 return wrap(S.
Context, Original, 0);
6977 if (I == Stack.size())
6986 return wrap(
C, SplitOld.
Ty, I);
6987 return C.getQualifiedType(wrap(
C, SplitOld.
Ty, I), SplitOld.
Quals);
6991 if (I == Stack.size())
return QualType(Fn, 0);
6993 switch (
static_cast<WrapKind
>(Stack[I++])) {
7000 return wrap(
C, cast<AttributedType>(Old)->getEquivalentType(), I);
7003 QualType New = wrap(
C, cast<ParenType>(Old)->getInnerType(), I);
7004 return C.getParenType(New);
7007 case MacroQualified:
7011 if (
const auto *CAT = dyn_cast<ConstantArrayType>(Old)) {
7012 QualType New = wrap(
C, CAT->getElementType(), I);
7013 return C.getConstantArrayType(New, CAT->getSize(), CAT->getSizeExpr(),
7014 CAT->getSizeModifier(),
7015 CAT->getIndexTypeCVRQualifiers());
7018 if (
const auto *VAT = dyn_cast<VariableArrayType>(Old)) {
7019 QualType New = wrap(
C, VAT->getElementType(), I);
7020 return C.getVariableArrayType(
7021 New, VAT->getSizeExpr(), VAT->getSizeModifier(),
7022 VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange());
7025 const auto *IAT = cast<IncompleteArrayType>(Old);
7026 QualType New = wrap(
C, IAT->getElementType(), I);
7027 return C.getIncompleteArrayType(New, IAT->getSizeModifier(),
7028 IAT->getIndexTypeCVRQualifiers());
7033 return C.getPointerType(New);
7036 case BlockPointer: {
7038 return C.getBlockPointerType(New);
7041 case MemberPointer: {
7044 return C.getMemberPointerType(New, OldMPT->
getClass());
7050 if (isa<LValueReferenceType>(OldRef))
7053 return C.getRValueReferenceType(New);
7057 llvm_unreachable(
"unknown wrapping kind");
7064 Sema &S = State.getSema();
7068 default: llvm_unreachable(
"Unknown attribute kind");
7069 case ParsedAttr::AT_Ptr32:
7070 A = createSimpleAttr<Ptr32Attr>(S.
Context, PAttr);
7072 case ParsedAttr::AT_Ptr64:
7073 A = createSimpleAttr<Ptr64Attr>(S.
Context, PAttr);
7075 case ParsedAttr::AT_SPtr:
7076 A = createSimpleAttr<SPtrAttr>(S.
Context, PAttr);
7078 case ParsedAttr::AT_UPtr:
7079 A = createSimpleAttr<UPtrAttr>(S.
Context, PAttr);
7083 std::bitset<attr::LastAttr> Attrs;
7086 if (
const TypedefType *TT = dyn_cast<TypedefType>(Desugared)) {
7087 Desugared = TT->desugar();
7089 }
else if (
const ElaboratedType *ET = dyn_cast<ElaboratedType>(Desugared)) {
7090 Desugared = ET->desugar();
7103 if (Attrs[NewAttrKind]) {
7104 S.
Diag(PAttr.
getLoc(), diag::warn_duplicate_attribute_exact) << PAttr;
7107 Attrs[NewAttrKind] =
true;
7111 if (Attrs[attr::Ptr32] && Attrs[attr::Ptr64]) {
7112 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
7114 <<
"'__ptr64'" << 0;
7116 }
else if (Attrs[attr::SPtr] && Attrs[attr::UPtr]) {
7117 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
7125 if (!isa<PointerType>(Desugared)) {
7129 S.
Diag(PAttr.
getLoc(), diag::err_attribute_no_member_pointers) << PAttr;
7131 S.
Diag(PAttr.
getLoc(), diag::err_attribute_pointers_only) << PAttr << 0;
7139 if (PtrWidth == 32) {
7140 if (Attrs[attr::Ptr64])
7142 else if (Attrs[attr::UPtr])
7144 }
else if (PtrWidth == 64 && Attrs[attr::Ptr32]) {
7161 assert(PAttr.
getKind() == ParsedAttr::AT_WebAssemblyFuncref);
7163 Sema &S = State.getSema();
7164 Attr *A = createSimpleAttr<WebAssemblyFuncrefAttr>(S.
Context, PAttr);
7166 std::bitset<attr::LastAttr> Attrs;
7168 const auto *AT = dyn_cast<AttributedType>(QT);
7170 Attrs[AT->getAttrKind()] =
true;
7171 AT = dyn_cast<AttributedType>(AT->getModifiedType());
7176 if (Attrs[NewAttrKind]) {
7177 S.
Diag(PAttr.
getLoc(), diag::warn_duplicate_attribute_exact) << PAttr;
7195 Sema &S = State.getSema();
7196 auto &
D = State.getDeclarator();
7202 if (State.isProcessingDeclSpec()) {
7203 if (!(
D.isPrototypeContext() ||
7207 if (
auto *chunk =
D.getInnermostNonParenChunk()) {
7230 auto chunkIdx = State.getCurrentChunkIndex();
7231 if (chunkIdx >= 1 &&
7234 D.getTypeObject(chunkIdx - 1).
getAttrs());
7239 auto *A = ::new (S.
Context) SwiftAttrAttr(S.
Context, PAttr, Str);
7240 QT = State.getAttributedType(A, QT, QT);
7247 auto Attributed = dyn_cast<AttributedType>(
Type.getTypePtr());
7252 if (Attributed->getImmediateNullability())
7253 return Attributed->getModifiedType();
7257 Ctx, Attributed->getModifiedType());
7258 assert(Modified.
getTypePtr() != Attributed->getModifiedType().getTypePtr());
7260 Attributed->getEquivalentType(),
7261 Attributed->getAttr());
7267 case ParsedAttr::AT_TypeNonNull:
7270 case ParsedAttr::AT_TypeNullable:
7273 case ParsedAttr::AT_TypeNullableResult:
7276 case ParsedAttr::AT_TypeNullUnspecified:
7280 llvm_unreachable(
"not a nullability attribute kind");
7287 bool IsContextSensitive,
bool AllowOnArrayType,
bool OverrideExisting) {
7288 bool Implicit = (State ==
nullptr);
7294 while (
auto *Attributed = dyn_cast<AttributedType>(Desugared.
getTypePtr())) {
7296 if (
auto ExistingNullability = Attributed->getImmediateNullability()) {
7298 if (Nullability == *ExistingNullability) {
7302 S.
Diag(NullabilityLoc, diag::warn_nullability_duplicate)
7309 if (!OverrideExisting) {
7311 S.
Diag(NullabilityLoc, diag::err_nullability_conflicting)
7321 Desugared = Attributed->getModifiedType();
7329 if (Nullability != *ExistingNullability && !
Implicit) {
7330 S.
Diag(NullabilityLoc, diag::err_nullability_conflicting)
7338 if (
auto typedefNullability =
7340 if (*typedefNullability == *ExistingNullability) {
7353 !(AllowOnArrayType && Desugared->
isArrayType())) {
7355 S.
Diag(NullabilityLoc, diag::err_nullability_nonpointer)
7363 if (IsContextSensitive) {
7365 const Type *pointeeType =
nullptr;
7374 S.
Diag(NullabilityLoc, diag::err_nullability_cs_multilevel)
7376 S.
Diag(NullabilityLoc, diag::note_nullability_type_specifier)
7388 QT = State->getAttributedType(A, QT, QT);
7397 bool AllowOnArrayType) {
7403 Nullability, NullabilityLoc,
7404 IsContextSensitive, AllowOnArrayType,
7411 bool AllowArrayTypes,
7412 bool OverrideExisting) {
7414 *
this,
nullptr,
nullptr,
Type, Nullability, DiagLoc,
7415 false, AllowArrayTypes, OverrideExisting);
7422 Sema &S = state.getSema();
7424 if (isa<ObjCTypeParamType>(
type)) {
7426 type = state.getAttributedType(
7439 S.
Diag(
attr.getLoc(), diag::err_objc_kindof_nonobject)
7448 objType->getBaseType(), objType->getTypeArgsAsWritten(),
7449 objType->getProtocols(),
7450 objType->isObjCUnqualifiedId() ?
false :
true);
7455 if (
auto nullability =
type->getNullability()) {
7458 assert(
attr.getAttributeSpellingListIndex() == 0 &&
7459 "multiple spellings for __kindof?");
7462 equivType = state.getAttributedType(A, equivType, equivType);
7467 type = state.getAttributedType(
7480 Declarator &declarator = state.getDeclarator();
7483 auto moveToChunk = [&](
DeclaratorChunk &chunk,
bool inFunction) ->
bool {
7496 PK_MemberFunctionPointer,
7501 : inFunction? PK_MemberFunctionPointer : PK_MemberPointer;
7503 auto diag = state.getSema().Diag(
attr.getLoc(),
7504 diag::warn_nullability_declspec)
7506 attr.isContextSensitiveKeywordAttribute())
7508 <<
static_cast<unsigned>(pointerKind);
7514 state.getSema().getPreprocessor().getLocForEndOfToken(
7516 " " +
attr.getAttrName()->getName().str() +
" ");
7526 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
7528 switch (chunk.
Kind) {
7532 return moveToChunk(chunk,
false);
7544 return moveToChunk(*dest,
true);
7560 assert(!
Attr.isInvalid());
7563 llvm_unreachable(
"not a calling convention attribute");
7564 case ParsedAttr::AT_CDecl:
7565 return createSimpleAttr<CDeclAttr>(Ctx,
Attr);
7566 case ParsedAttr::AT_FastCall:
7567 return createSimpleAttr<FastCallAttr>(Ctx,
Attr);
7568 case ParsedAttr::AT_StdCall:
7569 return createSimpleAttr<StdCallAttr>(Ctx,
Attr);
7570 case ParsedAttr::AT_ThisCall:
7571 return createSimpleAttr<ThisCallAttr>(Ctx,
Attr);
7572 case ParsedAttr::AT_RegCall:
7573 return createSimpleAttr<RegCallAttr>(Ctx,
Attr);
7574 case ParsedAttr::AT_Pascal:
7575 return createSimpleAttr<PascalAttr>(Ctx,
Attr);
7576 case ParsedAttr::AT_SwiftCall:
7577 return createSimpleAttr<SwiftCallAttr>(Ctx,
Attr);
7578 case ParsedAttr::AT_SwiftAsyncCall:
7579 return createSimpleAttr<SwiftAsyncCallAttr>(Ctx,
Attr);
7580 case ParsedAttr::AT_VectorCall:
7581 return createSimpleAttr<VectorCallAttr>(Ctx,
Attr);
7582 case ParsedAttr::AT_AArch64VectorPcs:
7583 return createSimpleAttr<AArch64VectorPcsAttr>(Ctx,
Attr);
7584 case ParsedAttr::AT_AArch64SVEPcs:
7585 return createSimpleAttr<AArch64SVEPcsAttr>(Ctx,
Attr);
7586 case ParsedAttr::AT_ArmStreaming:
7587 return createSimpleAttr<ArmStreamingAttr>(Ctx,
Attr);
7588 case ParsedAttr::AT_AMDGPUKernelCall:
7589 return createSimpleAttr<AMDGPUKernelCallAttr>(Ctx,
Attr);
7590 case ParsedAttr::AT_Pcs: {
7595 if (
Attr.isArgExpr(0))
7596 Str = cast<StringLiteral>(
Attr.getArgAsExpr(0))->getString();
7598 Str =
Attr.getArgAsIdent(0)->Ident->getName();
7599 PcsAttr::PCSType
Type;
7600 if (!PcsAttr::ConvertStrToPCSType(Str,
Type))
7601 llvm_unreachable(
"already validated the attribute");
7602 return ::new (Ctx) PcsAttr(Ctx,
Attr,
Type);
7604 case ParsedAttr::AT_IntelOclBicc:
7605 return createSimpleAttr<IntelOclBiccAttr>(Ctx,
Attr);
7606 case ParsedAttr::AT_MSABI:
7607 return createSimpleAttr<MSABIAttr>(Ctx,
Attr);
7608 case ParsedAttr::AT_SysVABI:
7609 return createSimpleAttr<SysVABIAttr>(Ctx,
Attr);
7610 case ParsedAttr::AT_PreserveMost:
7611 return createSimpleAttr<PreserveMostAttr>(Ctx,
Attr);
7612 case ParsedAttr::AT_PreserveAll:
7613 return createSimpleAttr<PreserveAllAttr>(Ctx,
Attr);
7614 case ParsedAttr::AT_M68kRTD:
7615 return createSimpleAttr<M68kRTDAttr>(Ctx,
Attr);
7616 case ParsedAttr::AT_PreserveNone:
7617 return createSimpleAttr<PreserveNoneAttr>(Ctx,
Attr);
7618 case ParsedAttr::AT_RISCVVectorCC:
7619 return createSimpleAttr<RISCVVectorCCAttr>(Ctx,
Attr);
7621 llvm_unreachable(
"unexpected attribute kind!");
7624std::optional<FunctionEffectMode>
7629 std::optional<llvm::APSInt> ConditionValue =
7631 if (!ConditionValue) {
7637 return std::nullopt;
7646 FunctionTypeUnwrapper &Unwrapped) {
7648 if (!Unwrapped.isFunctionType())
7651 Sema &S = TPState.getSema();
7655 if (FPT ==
nullptr) {
7656 S.
Diag(PAttr.
getLoc(), diag::err_func_with_effects_no_prototype)
7663 bool IsNonBlocking = PAttr.
getKind() == ParsedAttr::AT_NonBlocking ||
7664 PAttr.
getKind() == ParsedAttr::AT_Blocking;
7667 Expr *CondExpr =
nullptr;
7669 if (PAttr.
getKind() == ParsedAttr::AT_NonBlocking ||
7670 PAttr.
getKind() == ParsedAttr::AT_NonAllocating) {
7679 std::optional<FunctionEffectMode> MaybeMode =
7685 NewMode = *MaybeMode;
7720 assert(
Success &&
"effect conflicts should have been diagnosed above");
7724 FPT->getParamTypes(), EPI);
7733 auto OtherAttr = std::find_if(
7734 state.getCurrentAttributes().begin(), state.getCurrentAttributes().end(),
7735 [OtherKind](
const ParsedAttr &A) { return A.getKind() == OtherKind; });
7736 if (OtherAttr == state.getCurrentAttributes().end() || OtherAttr->isInvalid())
7739 Sema &S = state.getSema();
7741 << *OtherAttr <<
Attr
7742 << (OtherAttr->isRegularKeywordAttribute() ||
7744 S.
Diag(OtherAttr->getLoc(), diag::note_conflicting_attribute);
7752 if (!
Attr.getNumArgs()) {
7758 for (
unsigned I = 0; I <
Attr.getNumArgs(); ++I) {
7759 StringRef StateName;
7764 if (StateName !=
"sme_za_state") {
7765 S.
Diag(LiteralLoc, diag::err_unknown_arm_state) << StateName;
7772 S.
Diag(
Attr.
getLoc(), diag::err_conflicting_attributes_arm_agnostic);
7787 if (!
Attr.getNumArgs()) {
7793 for (
unsigned I = 0; I <
Attr.getNumArgs(); ++I) {
7794 StringRef StateName;
7801 if (StateName ==
"za") {
7804 }
else if (StateName ==
"zt0") {
7808 S.
Diag(LiteralLoc, diag::err_unknown_arm_state) << StateName;
7814 S.
Diag(LiteralLoc, diag::err_conflicting_attributes_arm_agnostic);
7823 S.
Diag(LiteralLoc, diag::err_conflicting_attributes_arm_state)
7839 Sema &S = state.getSema();
7841 FunctionTypeUnwrapper unwrapped(S,
type);
7843 if (
attr.getKind() == ParsedAttr::AT_NoReturn) {
7848 if (!unwrapped.isFunctionType())
7857 if (
attr.getKind() == ParsedAttr::AT_CmseNSCall) {
7859 if (!unwrapped.isFunctionType())
7864 S.
Diag(
attr.getLoc(), diag::warn_attribute_ignored) <<
attr;
7878 if (
attr.getKind() == ParsedAttr::AT_NSReturnsRetained) {
7879 if (
attr.getNumArgs())
return true;
7882 if (!unwrapped.isFunctionType())
7887 attr.getLoc(), unwrapped.get()->getReturnType()))
7892 if (state.getSema().getLangOpts().ObjCAutoRefCount) {
7897 type = state.getAttributedType(
7898 createSimpleAttr<NSReturnsRetainedAttr>(S.
Context,
attr),
7903 if (
attr.getKind() == ParsedAttr::AT_AnyX86NoCallerSavedRegisters) {
7908 if (!unwrapped.isFunctionType())
7917 if (
attr.getKind() == ParsedAttr::AT_AnyX86NoCfCheck) {
7919 S.
Diag(
attr.getLoc(), diag::warn_nocf_check_attribute_ignored);
7929 if (!unwrapped.isFunctionType())
7938 if (
attr.getKind() == ParsedAttr::AT_Regparm) {
7944 if (!unwrapped.isFunctionType())
7951 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
7953 <<
attr.isRegularKeywordAttribute();
7964 if (
attr.getKind() == ParsedAttr::AT_ArmStreaming ||
7965 attr.getKind() == ParsedAttr::AT_ArmStreamingCompatible ||
7966 attr.getKind() == ParsedAttr::AT_ArmPreserves ||
7967 attr.getKind() == ParsedAttr::AT_ArmIn ||
7968 attr.getKind() == ParsedAttr::AT_ArmOut ||
7969 attr.getKind() == ParsedAttr::AT_ArmInOut ||
7970 attr.getKind() == ParsedAttr::AT_ArmAgnostic) {
7974 if (
attr.getKind() == ParsedAttr::AT_ArmStreaming ||
7975 attr.getKind() == ParsedAttr::AT_ArmStreamingCompatible)
7979 if (!unwrapped.isFunctionType())
7986 S.
Diag(
attr.getLoc(), diag::warn_attribute_wrong_decl_type)
7987 <<
attr <<
attr.isRegularKeywordAttribute()
7994 switch (
attr.getKind()) {
7995 case ParsedAttr::AT_ArmStreaming:
7997 ParsedAttr::AT_ArmStreamingCompatible))
8001 case ParsedAttr::AT_ArmStreamingCompatible:
8006 case ParsedAttr::AT_ArmPreserves:
8010 case ParsedAttr::AT_ArmIn:
8014 case ParsedAttr::AT_ArmOut:
8018 case ParsedAttr::AT_ArmInOut:
8022 case ParsedAttr::AT_ArmAgnostic:
8027 llvm_unreachable(
"Unsupported attribute");
8031 FnTy->getParamTypes(), EPI);
8036 if (
attr.getKind() == ParsedAttr::AT_NoThrow) {
8038 if (!unwrapped.isFunctionType())
8051 if (Proto->hasExceptionSpec()) {
8052 switch (Proto->getExceptionSpecType()) {
8054 llvm_unreachable(
"This doesn't have an exception spec!");
8072 S.
Diag(
attr.getLoc(), diag::warn_nothrow_attribute_ignored);
8078 type = unwrapped.wrap(
8087 if (
attr.getKind() == ParsedAttr::AT_NonBlocking ||
8088 attr.getKind() == ParsedAttr::AT_NonAllocating ||
8089 attr.getKind() == ParsedAttr::AT_Blocking ||
8090 attr.getKind() == ParsedAttr::AT_Allocating) {
8095 if (!unwrapped.isFunctionType())
return false;
8110 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
8113 <<
attr.isRegularKeywordAttribute();
8132 return S.
Diag(
attr.getLoc(), diag::warn_cconv_unsupported)
8137 return S.
Diag(
attr.getLoc(), diag::err_cconv_varargs)
8144 S.
Diag(
attr.getLoc(), diag::err_attributes_are_not_compatible)
8146 <<
attr.isRegularKeywordAttribute();
8158 auto EI = unwrapped.get()->getExtInfo().withCallingConv(CC);
8182 FunctionTypeUnwrapper Unwrapped(*
this,
T);
8184 bool IsVariadic = (isa<FunctionProtoType>(FT) &&
8185 cast<FunctionProtoType>(FT)->isVariadic());
8199 Diag(
Loc, diag::warn_cconv_unsupported)
8210 if (CurCC != DefaultCC)
8218 QualType Wrapped = Unwrapped.wrap(*
this, FT);
8232 if (
Attr.getNumArgs() != 1) {
8239 Expr *SizeExpr =
Attr.getArgAsExpr(0);
8252 if (
Attr.getNumArgs() != 1) {
8258 Expr *SizeExpr =
Attr.getArgAsExpr(0);
8273 bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 ||
8274 Triple.getArch() == llvm::Triple::aarch64_32 ||
8275 Triple.getArch() == llvm::Triple::aarch64_be;
8277 if (IsPolyUnsigned) {
8279 return BTy->
getKind() == BuiltinType::UChar ||
8280 BTy->
getKind() == BuiltinType::UShort ||
8281 BTy->
getKind() == BuiltinType::ULong ||
8282 BTy->
getKind() == BuiltinType::ULongLong;
8285 return BTy->
getKind() == BuiltinType::SChar ||
8286 BTy->
getKind() == BuiltinType::Short ||
8287 BTy->
getKind() == BuiltinType::LongLong;
8293 if ((Triple.isArch64Bit() || Triple.getArch() == llvm::Triple::aarch64_32) &&
8294 BTy->
getKind() == BuiltinType::Double)
8297 return BTy->
getKind() == BuiltinType::SChar ||
8298 BTy->
getKind() == BuiltinType::UChar ||
8299 BTy->
getKind() == BuiltinType::Short ||
8300 BTy->
getKind() == BuiltinType::UShort ||
8301 BTy->
getKind() == BuiltinType::Int ||
8302 BTy->
getKind() == BuiltinType::UInt ||
8303 BTy->
getKind() == BuiltinType::Long ||
8304 BTy->
getKind() == BuiltinType::ULong ||
8305 BTy->
getKind() == BuiltinType::LongLong ||
8306 BTy->
getKind() == BuiltinType::ULongLong ||
8307 BTy->
getKind() == BuiltinType::Float ||
8308 BTy->
getKind() == BuiltinType::Half ||
8309 BTy->
getKind() == BuiltinType::BFloat16;
8314 const auto *AttrExpr =
Attr.getArgAsExpr(0);
8315 if (!AttrExpr->isTypeDependent()) {
8316 if (std::optional<llvm::APSInt> Res =
8317 AttrExpr->getIntegerConstantExpr(S.
Context)) {
8337 bool IsTargetCUDAAndHostARM =
false;
8340 IsTargetCUDAAndHostARM =
8364 if (
Attr.getNumArgs() != 1) {
8365 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8371 llvm::APSInt numEltsInt(32);
8377 !IsTargetCUDAAndHostARM) {
8378 S.
Diag(
Attr.
getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
8385 unsigned numElts =
static_cast<unsigned>(numEltsInt.getZExtValue());
8386 unsigned vecSize = typeSize * numElts;
8387 if (vecSize != 64 && vecSize != 128) {
8388 S.
Diag(
Attr.
getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType;
8412 S.
Diag(
Attr.
getLoc(), diag::err_attribute_arm_feature_sve_bits_unsupported)
8419 if (
Attr.getNumArgs() != 1) {
8420 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8427 llvm::APSInt SveVectorSizeInBits(32);
8431 unsigned VecSize =
static_cast<unsigned>(SveVectorSizeInBits.getZExtValue());
8454 if (BT->getKind() == BuiltinType::SveBool) {
8459 VecSize /= TypeSize;
8466 const VectorType *VT = dyn_cast<VectorType>(CurType);
8469 diag::err_attribute_arm_mve_polymorphism);
8475 State.getAttributedType(createSimpleAttr<ArmMveStrictPolymorphismAttr>(
8476 State.getSema().Context,
Attr),
8488 <<
Attr <<
"'zve32x'";
8494 if (!VScale || !VScale->first || VScale->first != VScale->second) {
8495 S.
Diag(
Attr.
getLoc(), diag::err_attribute_riscv_rvv_bits_unsupported)
8502 if (
Attr.getNumArgs() != 1) {
8503 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8510 llvm::APSInt RVVVectorSizeInBits(32);
8522 unsigned VecSize =
static_cast<unsigned>(RVVVectorSizeInBits.getZExtValue());
8526 unsigned MinElts = Info.
EC.getKnownMinValue();
8529 unsigned ExpectedSize = VScale->first * MinElts;
8551 ExpectedSize *= EltSize;
8552 NumElts = VecSize / EltSize;
8556 if (VecSize != ExpectedSize) {
8558 << VecSize << ExpectedSize;
8571 S.
Diag(
Attr.
getLoc(), diag::err_opencl_invalid_access_qualifier);
8577 QualType BaseTy = TypedefTy->desugar();
8579 std::string PrevAccessQual;
8581 if (TypedefTy->getDecl()->hasAttr<OpenCLAccessAttr>()) {
8582 OpenCLAccessAttr *
Attr =
8583 TypedefTy->getDecl()->getAttr<OpenCLAccessAttr>();
8586 PrevAccessQual =
"read_only";
8590 switch (ImgType->getKind()) {
8591 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8592 case BuiltinType::Id: \
8593 PrevAccessQual = #Access; \
8595 #include "clang/Basic/OpenCLImageTypes.def"
8597 llvm_unreachable(
"Unable to find corresponding image type.");
8600 llvm_unreachable(
"unexpected type");
8603 if (PrevAccessQual == AttrName.ltrim(
"_")) {
8609 S.
Diag(
Attr.
getLoc(), diag::err_opencl_multiple_access_qualifiers);
8612 S.
Diag(TypedefTy->getDecl()->getBeginLoc(),
8613 diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;
8615 if (
Attr.getSemanticSpelling() == OpenCLAccessAttr::Keyword_write_only) {
8630 if (
Attr.getNumArgs() != 2) {
8631 S.
Diag(
Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
8636 Expr *RowsExpr =
Attr.getArgAsExpr(0);
8637 Expr *ColsExpr =
Attr.getArgAsExpr(1);
8645 Sema &S = State.getSema();
8648 S.
Diag(PA.
getLoc(), diag::err_attribute_too_few_arguments) << PA << 1;
8660 for (
unsigned Idx = 1; Idx < PA.
getNumArgs(); Idx++) {
8666 auto *AnnotateTypeAttr =
8667 AnnotateTypeAttr::Create(S.
Context, Str, Args.data(), Args.size(), PA);
8668 CurType = State.getAttributedType(AnnotateTypeAttr, CurType, CurType);
8674 if (State.getDeclarator().isDeclarationOfFunction()) {
8675 CurType = State.getAttributedType(
8676 createSimpleAttr<LifetimeBoundAttr>(State.getSema().Context,
Attr),
8680 State.getSema().Diag(
Attr.
getLoc(), diag::err_attribute_wrong_decl_type)
8687 if (State.getDeclarator().isDeclarationOfFunction()) {
8688 auto *
Attr = State.getSema().ParseLifetimeCaptureByAttr(PA,
"this");
8690 CurType = State.getAttributedType(
Attr, CurType, CurType);
8702 if (
Attr.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_inout ||
8703 Attr.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_out) {
8704 State.setParsedHLSLParamMod(
true);
8713 state.setParsedNoDeref(
false);
8729 if (
attr.isInvalid())
8732 if (
attr.isStandardAttributeSyntax() ||
attr.isRegularKeywordAttribute()) {
8737 if (
attr.isGNUScope()) {
8738 assert(
attr.isStandardAttributeSyntax());
8739 bool IsTypeAttr =
attr.isTypeAttr();
8741 state.getSema().Diag(
attr.getLoc(),
8743 ? diag::warn_gcc_ignores_type_attr
8744 : diag::warn_cxx11_gnu_attribute_on_type)
8750 !
attr.isTypeAttr()) {
8763 switch (
attr.getKind()) {
8766 if ((
attr.isStandardAttributeSyntax() ||
8767 attr.isRegularKeywordAttribute()) &&
8769 state.getSema().Diag(
attr.getLoc(), diag::err_attribute_not_type_attr)
8770 <<
attr <<
attr.isRegularKeywordAttribute();
8771 attr.setUsedAsTypeAttr();
8776 if (
attr.isStandardAttributeSyntax()) {
8777 state.getSema().Diag(
attr.getLoc(),
8778 diag::warn_unknown_attribute_ignored)
8789 case ParsedAttr::AT_BTFTypeTag:
8791 attr.setUsedAsTypeAttr();
8794 case ParsedAttr::AT_MayAlias:
8797 attr.setUsedAsTypeAttr();
8799 case ParsedAttr::AT_OpenCLPrivateAddressSpace:
8800 case ParsedAttr::AT_OpenCLGlobalAddressSpace:
8801 case ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace:
8802 case ParsedAttr::AT_OpenCLGlobalHostAddressSpace:
8803 case ParsedAttr::AT_OpenCLLocalAddressSpace:
8804 case ParsedAttr::AT_OpenCLConstantAddressSpace:
8805 case ParsedAttr::AT_OpenCLGenericAddressSpace:
8806 case ParsedAttr::AT_HLSLGroupSharedAddressSpace:
8807 case ParsedAttr::AT_AddressSpace:
8809 attr.setUsedAsTypeAttr();
8814 attr.setUsedAsTypeAttr();
8816 case ParsedAttr::AT_VectorSize:
8818 attr.setUsedAsTypeAttr();
8820 case ParsedAttr::AT_ExtVectorType:
8822 attr.setUsedAsTypeAttr();
8824 case ParsedAttr::AT_NeonVectorType:
8826 attr.setUsedAsTypeAttr();
8828 case ParsedAttr::AT_NeonPolyVectorType:
8831 attr.setUsedAsTypeAttr();
8833 case ParsedAttr::AT_ArmSveVectorBits:
8835 attr.setUsedAsTypeAttr();
8837 case ParsedAttr::AT_ArmMveStrictPolymorphism: {
8839 attr.setUsedAsTypeAttr();
8842 case ParsedAttr::AT_RISCVRVVVectorBits:
8844 attr.setUsedAsTypeAttr();
8846 case ParsedAttr::AT_OpenCLAccess:
8848 attr.setUsedAsTypeAttr();
8850 case ParsedAttr::AT_LifetimeBound:
8854 case ParsedAttr::AT_LifetimeCaptureBy:
8859 case ParsedAttr::AT_NoDeref: {
8864 if (
attr.isStandardAttributeSyntax()) {
8865 state.getSema().Diag(
attr.getLoc(), diag::warn_attribute_ignored)
8870 type = state.getAttributedType(createSimpleAttr<NoDerefAttr>(Ctx,
attr),
8872 attr.setUsedAsTypeAttr();
8873 state.setParsedNoDeref(
true);
8877 case ParsedAttr::AT_MatrixType:
8879 attr.setUsedAsTypeAttr();
8882 case ParsedAttr::AT_WebAssemblyFuncref: {
8884 attr.setUsedAsTypeAttr();
8888 case ParsedAttr::AT_HLSLParamModifier: {
8890 attr.setUsedAsTypeAttr();
8894 case ParsedAttr::AT_SwiftAttr: {
8901 attr.setUsedAsTypeAttr();
8909 if (
type->canHaveNullability() ||
type->isDependentType() ||
8910 type->isArrayType() ||
8914 endIndex = state.getCurrentChunkIndex();
8916 endIndex = state.getDeclarator().getNumTypeObjects();
8917 bool allowOnArrayType =
8918 state.getDeclarator().isPrototypeContext() &&
8921 allowOnArrayType)) {
8925 attr.setUsedAsTypeAttr();
8929 case ParsedAttr::AT_ObjCKindOf:
8937 state.getSema().Diag(
attr.getLoc(),
8938 diag::err_objc_kindof_wrong_position)
8941 state.getDeclarator().getDeclSpec().getBeginLoc(),
8951 case ParsedAttr::AT_NoThrow:
8954 if (!state.getSema().getLangOpts().CPlusPlus)
8958 attr.setUsedAsTypeAttr();
8962 if (
attr.isStandardAttributeSyntax() ||
8963 attr.isRegularKeywordAttribute()) {
8980 case ParsedAttr::AT_AcquireHandle: {
8981 if (!
type->isFunctionType())
8984 if (
attr.getNumArgs() != 1) {
8985 state.getSema().Diag(
attr.getLoc(),
8986 diag::err_attribute_wrong_number_arguments)
8992 StringRef HandleType;
8993 if (!state.getSema().checkStringLiteralArgumentAttr(
attr, 0, HandleType))
8995 type = state.getAttributedType(
8996 AcquireHandleAttr::Create(state.getSema().Context, HandleType,
attr),
8998 attr.setUsedAsTypeAttr();
9001 case ParsedAttr::AT_AnnotateType: {
9003 attr.setUsedAsTypeAttr();
9006 case ParsedAttr::AT_HLSLResourceClass:
9007 case ParsedAttr::AT_HLSLROV:
9008 case ParsedAttr::AT_HLSLRawBuffer:
9009 case ParsedAttr::AT_HLSLContainedType: {
9014 state.getSema().HLSL().handleResourceTypeAttr(
type,
attr))
9015 attr.setUsedAsTypeAttr();
9022 if (isa<AttributedType>(
type) &&
attr.hasMacroIdentifier() &&
9023 !
type.getQualifiers().hasObjCLifetime() &&
9024 !
type.getQualifiers().hasObjCGCAttr() &&
9025 attr.getKind() != ParsedAttr::AT_ObjCGC &&
9026 attr.getKind() != ParsedAttr::AT_ObjCOwnership) {
9028 type = state.getSema().Context.getMacroQualifiedType(
type, MacroII);
9029 state.setExpansionLocForMacroQualifiedType(
9030 cast<MacroQualifiedType>(
type.getTypePtr()),
9031 attr.getMacroExpansionLoc());
9038 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
9040 auto *Def = Var->getDefinition();
9046 Def = Var->getDefinition();
9053 if (Var->getPointOfInstantiation().isInvalid() && Def) {
9054 assert(Var->getTemplateSpecializationKind() ==
9056 "explicit instantiation with no point of instantiation");
9057 Var->setTemplateSpecializationKind(
9058 Var->getTemplateSpecializationKind(), PointOfInstantiation);
9078 if (
const auto CastE = dyn_cast<ExplicitCastExpr>(
E)) {
9079 QualType DestType = CastE->getTypeAsWritten();
9085 IAT->getElementType(),
9122 if (RequireCompleteTypeImpl(
Loc,
T, Kind, &Diagnoser))
9125 if (!Tag->getDecl()->isCompleteDefinitionRequired()) {
9126 Tag->getDecl()->setCompleteDefinitionRequired();
9156 if (isa<TagDecl>(
D) && cast<TagDecl>(
D)->isBeingDefined()) {
9160 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(
D)) {
9161 if (
auto *Pattern = RD->getTemplateInstantiationPattern())
9163 D = RD->getDefinition();
9164 }
else if (
auto *ED = dyn_cast<EnumDecl>(
D)) {
9165 if (
auto *Pattern = ED->getTemplateInstantiationPattern())
9167 if (OnlyNeedComplete && (ED->isFixed() ||
getLangOpts().MSVCCompat)) {
9173 *Suggested =
nullptr;
9174 for (
auto *Redecl : ED->redecls()) {
9177 if (Redecl->isThisDeclarationADefinition() ||
9178 (Redecl->isCanonicalDecl() && !*Suggested))
9179 *Suggested = Redecl;
9184 D = ED->getDefinition();
9185 }
else if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
9186 if (
auto *Pattern = FD->getTemplateInstantiationPattern())
9188 D = FD->getDefinition();
9189 }
else if (
auto *VD = dyn_cast<VarDecl>(
D)) {
9190 if (
auto *Pattern = VD->getTemplateInstantiationPattern())
9192 D = VD->getDefinition();
9195 assert(
D &&
"missing definition for pattern of instantiated definition");
9199 auto DefinitionIsAcceptable = [&] {
9219 if (DefinitionIsAcceptable())
9225 Source->CompleteRedeclChain(
D);
9226 return DefinitionIsAcceptable();
9242 bool OnlyNeedComplete) {
9259 bool OnlyNeedComplete) {
9267 if (!RD->
hasAttr<MSInheritanceAttr>()) {
9269 bool BestCase =
false;
9289 RD->
addAttr(MSInheritanceAttr::CreateImplicit(
9296 CompleteTypeKind Kind,
9297 TypeDiagnoser *Diagnoser) {
9307 if (!MPTy->getClass()->isDependentType()) {
9309 !MPTy->getClass()->getAsCXXRecordDecl()->isBeingDefined() &&
9311 diag::err_memptr_incomplete))
9330 if (Def && !isa<EnumDecl>(Def))
9341 if (Diagnoser && Suggested)
9344 return !TreatAsComplete;
9346 CodeSynthesisContext TempInst;
9348 TempInst.Template = Def;
9349 TempInst.Entity = Def;
9350 TempInst.PointOfInstantiation =
Loc;
9358 TagDecl *
Tag = dyn_cast_or_null<TagDecl>(Def);
9372 if (Tag &&
Tag->hasExternalLexicalStorage())
9373 Source->CompleteType(Tag);
9375 Source->CompleteType(IFace);
9379 return RequireCompleteTypeImpl(
Loc,
T, Kind, Diagnoser);
9386 if (
auto *RD = dyn_cast_or_null<CXXRecordDecl>(Tag)) {
9387 bool Instantiated =
false;
9388 bool Diagnosed =
false;
9389 if (RD->isDependentContext()) {
9393 }
else if (
auto *ClassTemplateSpec =
9394 dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
9395 if (ClassTemplateSpec->getSpecializationKind() ==
TSK_Undeclared) {
9401 Instantiated =
true;
9405 if (!RD->isBeingDefined() && Pattern) {
9407 assert(MSI &&
"Missing member specialization information?");
9417 Instantiated =
true;
9425 if (Diagnoser && Diagnosed)
9431 return RequireCompleteTypeImpl(
Loc,
T, Kind, Diagnoser);
9441 Diagnoser->diagnose(*
this,
Loc,
T);
9445 if (Tag && !
Tag->isInvalidDecl() && !
Tag->getLocation().isInvalid())
9447 Tag->isBeingDefined() ? diag::note_type_being_defined
9448 : diag::note_forward_declaration)
9482 default: llvm_unreachable(
"Invalid tag kind for literal type diagnostic!");
9526 for (
const auto &I : RD->
vbases())
9527 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
9528 << I.getSourceRange();
9531 Diag(RD->
getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD;
9533 for (
const auto &I : RD->
bases()) {
9534 if (!I.getType()->isLiteralType(
Context)) {
9535 Diag(I.getBeginLoc(), diag::note_non_literal_base_class)
9536 << RD << I.getType() << I.getSourceRange();
9540 for (
const auto *I : RD->
fields()) {
9541 if (!I->getType()->isLiteralType(
Context) ||
9542 I->getType().isVolatileQualified()) {
9543 Diag(I->getLocation(), diag::note_non_literal_field)
9544 << RD << I << I->getType()
9545 << I->getType().isVolatileQualified();
9555 assert(Dtor &&
"class has literal fields and bases but no dtor?");
9564 ? diag::note_non_literal_user_provided_dtor
9565 : diag::note_non_literal_nontrivial_dtor)
9610 auto *CountDecl = cast<DeclRefExpr>(
E)->getDecl();
9634 if (
auto *ImplCastExpr = dyn_cast<ImplicitCastExpr>(
E))
9635 IDExpr = ImplCastExpr->getSubExpr();
9637 if (
auto *PackExpr = dyn_cast<PackIndexingExpr>(
E)) {
9639 IDExpr = PackExpr->getPackIdExpression();
9641 IDExpr = PackExpr->getSelectedExpr();
9657 if (
const auto *SNTTPE = dyn_cast<SubstNonTypeTemplateParmExpr>(IDExpr))
9658 return SNTTPE->getParameterType(
Context);
9666 if (
const auto *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
9669 return isa<TemplateParamObjectDecl>(VD) ?
T.getUnqualifiedType() :
T;
9671 if (
const auto *ME = dyn_cast<MemberExpr>(IDExpr)) {
9672 if (
const auto *VD = ME->getMemberDecl())
9673 if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
9674 return VD->getType();
9675 }
else if (
const auto *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
9676 return IR->getDecl()->getType();
9677 }
else if (
const auto *PR = dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {
9678 if (PR->isExplicitProperty())
9679 return PR->getExplicitProperty()->getType();
9680 }
else if (
const auto *PE = dyn_cast<PredefinedExpr>(IDExpr)) {
9681 return PE->getType();
9692 if (
auto *DRE = dyn_cast<DeclRefExpr>(IDExpr->
IgnoreParens())) {
9693 if (
auto *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
9726 Diag(
Loc, diag::err_expected_name_of_pack) << Pattern;
9732 : diag::ext_pack_indexing);
9739 bool FullySubstituted,
9742 std::optional<int64_t> Index;
9750 Index =
Value.getExtValue();
9751 IndexExpr = Res.
get();
9754 if (FullySubstituted && Index) {
9755 if (*Index < 0 || *Index >= int64_t(Expansions.size())) {
9757 << *Index << Pattern << Expansions.size();
9763 Expansions, Index.value_or(-1));
9770 assert(ED &&
"EnumType has no EnumDecl");
9775 assert(!Underlying.
isNull());
9783 Diag(
Loc, diag::err_only_enums_have_underlying_types);
9791 Diag(
Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
9792 Diag(FwdDecl->
getLocation(), diag::note_forward_declaration) << FwdDecl;
9828 Split.Quals.removeCVRQualifiers();
9838 UKind == UnaryTransformType::AddLvalueReference,
9846 if (UKind == UnaryTransformType::RemoveAllExtents)
9850 return AT->getElementType();
9859 if (UKind == UTTKind::RemoveCVRef &&
9860 (
T.isConstQualified() ||
T.isVolatileQualified())) {
9872 if ((BaseType->
isReferenceType() && UKind != UTTKind::RemoveRestrict) ||
9879 if (UKind == UTTKind::RemoveConst || UKind == UTTKind::RemoveCV)
9881 if (UKind == UTTKind::RemoveVolatile || UKind == UTTKind::RemoveCV)
9883 if (UKind == UTTKind::RemoveRestrict)
9894 if (
auto *
BitInt = dyn_cast<BitIntType>(Underlying)) {
9895 unsigned int Bits =
BitInt->getNumBits();
9899 S.
Diag(
Loc, diag::err_make_signed_integral_only)
9900 << IsMakeSigned <<
true << BaseType << 1 << Underlying;
9904 S.
Diag(
Loc, diag::err_make_signed_integral_only)
9905 << IsMakeSigned <<
false << BaseType << 1
9912 std::array<CanQualType *, 6> AllSignedIntegers = {
9916 AllSignedIntegers.data(), AllSignedIntegers.size() - Int128Unsupported);
9917 std::array<CanQualType *, 6> AllUnsignedIntegers = {
9922 AllUnsignedIntegers.size() -
9925 IsMakeSigned ? &AvailableSignedIntegers : &AvailableUnsignedIntegers;
9929 llvm::find_if(*Consider, [&S, BaseSize](
const CanQual<Type> *
T) {
9933 assert(
Result != Consider->end());
9934 return QualType((*Result)->getTypePtr(), 0);
9939 bool IsMakeSigned = UKind == UnaryTransformType::MakeSigned;
9944 Diag(
Loc, diag::err_make_signed_integral_only)
9945 << IsMakeSigned << BaseType->
isBitIntType() << BaseType << 0;
9949 bool IsNonIntIntegral =
9969 case UnaryTransformType::EnumUnderlyingType: {
9973 case UnaryTransformType::AddPointer: {
9977 case UnaryTransformType::RemovePointer: {
9981 case UnaryTransformType::Decay: {
9985 case UnaryTransformType::AddLvalueReference:
9986 case UnaryTransformType::AddRvalueReference: {
9990 case UnaryTransformType::RemoveAllExtents:
9991 case UnaryTransformType::RemoveExtent: {
9995 case UnaryTransformType::RemoveCVRef:
9996 case UnaryTransformType::RemoveReference: {
10000 case UnaryTransformType::RemoveConst:
10001 case UnaryTransformType::RemoveCV:
10002 case UnaryTransformType::RemoveRestrict:
10003 case UnaryTransformType::RemoveVolatile: {
10007 case UnaryTransformType::MakeSigned:
10008 case UnaryTransformType::MakeUnsigned: {
10026 int DisallowedKind = -1;
10028 DisallowedKind = 1;
10030 DisallowedKind = 2;
10032 DisallowedKind = 3;
10034 DisallowedKind = 4;
10035 else if (
T.hasQualifiers())
10036 DisallowedKind = 5;
10038 DisallowedKind = 6;
10041 DisallowedKind = 7;
10043 DisallowedKind = 8;
10046 DisallowedKind = 9;
10048 if (DisallowedKind != -1) {
10049 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.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Defines the clang::Preprocessor interface.
static QualType getUnderlyingType(const SubRegion *R)
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
This file declares semantic analysis for HLSL constructs.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
static void HandleNeonVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S, VectorKind VecKind)
HandleNeonVectorTypeAttr - The "neon_vector_type" and "neon_polyvector_type" attributes are used to c...
static QualType deduceOpenCLPointeeAddrSpace(Sema &S, QualType PointeeType)
static bool isPermittedNeonBaseType(QualType &Ty, VectorKind VecKind, Sema &S)
static void distributeObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType type)
Given that an objc_gc attribute was written somewhere on a declaration other than on the declarator i...
static void maybeSynthesizeBlockSignature(TypeProcessingState &state, QualType declSpecType)
Add a synthetic '()' to a block-literal declarator if it is required, given the return type.
#define MS_TYPE_ATTRS_CASELIST
#define CALLING_CONV_ATTRS_CASELIST
static void emitNullabilityConsistencyWarning(Sema &S, SimplePointerKind PointerKind, SourceLocation PointerLoc, SourceLocation PointerEndLoc)
static void fixItNullability(Sema &S, DiagBuilderT &Diag, SourceLocation PointerLoc, NullabilityKind Nullability)
Creates a fix-it to insert a C-style nullability keyword at pointerLoc, taking into account whitespac...
static ExprResult checkArraySize(Sema &S, Expr *&ArraySize, llvm::APSInt &SizeVal, unsigned VLADiag, bool VLAIsError)
Check whether the specified array bound can be evaluated using the relevant language rules.
static Attr * createNullabilityAttr(ASTContext &Ctx, ParsedAttr &Attr, NullabilityKind NK)
static void HandleVectorSizeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
HandleVectorSizeAttribute - this attribute is only applicable to integral and float scalars,...
static void inferARCWriteback(TypeProcessingState &state, QualType &declSpecType)
Given that this is the declaration of a parameter under ARC, attempt to infer attributes and such for...
static TypeSourceInfo * GetTypeSourceInfoForDeclarator(TypeProcessingState &State, QualType T, TypeSourceInfo *ReturnTypeInfo)
Create and instantiate a TypeSourceInfo with type source information.
static bool BuildAddressSpaceIndex(Sema &S, LangAS &ASIdx, const Expr *AddrSpace, SourceLocation AttrLoc)
Build an AddressSpace index from a constant expression and diagnose any errors related to invalid add...
static void HandleBTFTypeTagAttribute(QualType &Type, const ParsedAttr &Attr, TypeProcessingState &State)
static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, Qualifiers::ObjCLifetime ownership, unsigned chunkIndex)
static bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
handleObjCGCTypeAttr - Process the attribute((objc_gc)) type attribute on the specified type.
static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk)
static void HandleExtVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
Process the OpenCL-like ext_vector_type attribute when it occurs on a type.
static void HandleHLSLParamModifierAttr(TypeProcessingState &State, QualType &CurType, const ParsedAttr &Attr, Sema &S)
static void HandleLifetimeBoundAttr(TypeProcessingState &State, QualType &CurType, ParsedAttr &Attr)
static bool handleArmStateAttribute(Sema &S, FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr, FunctionType::ArmStateValue State)
static bool handleArmAgnosticAttribute(Sema &S, FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr)
static void distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType, CUDAFunctionTarget CFT)
A function type attribute was written in the decl spec.
static bool handleObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
static QualType inferARCLifetimeForPointee(Sema &S, QualType type, SourceLocation loc, bool isReference)
Given that we're building a pointer or reference to the given.
static bool handleNonBlockingNonAllocatingTypeAttr(TypeProcessingState &TPState, ParsedAttr &PAttr, QualType &QT, FunctionTypeUnwrapper &Unwrapped)
static QualType ChangeIntegralSignedness(Sema &S, QualType BaseType, bool IsMakeSigned, SourceLocation Loc)
static bool CheckNullabilityTypeSpecifier(Sema &S, TypeProcessingState *State, ParsedAttr *PAttr, QualType &QT, NullabilityKind Nullability, SourceLocation NullabilityLoc, bool IsContextSensitive, bool AllowOnArrayType, bool OverrideExisting)
#define OBJC_POINTER_TYPE_ATTRS_CASELIST
static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr, QualType type)
diagnoseBadTypeAttribute - Diagnoses a type attribute which doesn't apply to the given type.
static PointerDeclaratorKind classifyPointerDeclarator(Sema &S, QualType type, Declarator &declarator, PointerWrappingDeclaratorKind &wrappingKind)
Classify the given declarator, whose type-specified is type, based on what kind of pointer it refers ...
static bool verifyValidIntegerConstantExpr(Sema &S, const ParsedAttr &Attr, llvm::APSInt &Result)
static void HandleSwiftAttr(TypeProcessingState &State, TypeAttrLocation TAL, QualType &QT, ParsedAttr &PAttr)
static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
static bool shouldHaveNullability(QualType T)
static void HandleArmMveStrictPolymorphismAttr(TypeProcessingState &State, QualType &CurType, ParsedAttr &Attr)
static void warnAboutAmbiguousFunction(Sema &S, Declarator &D, DeclaratorChunk &DeclType, QualType RT)
Produce an appropriate diagnostic for an ambiguity between a function declarator and a C++ direct-ini...
static void distributeObjCPointerTypeAttrFromDeclarator(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType)
Distribute an objc_gc type attribute that was written on the declarator.
static FileID getNullabilityCompletenessCheckFileID(Sema &S, SourceLocation loc)
static void HandleArmSveVectorBitsTypeAttr(QualType &CurType, ParsedAttr &Attr, Sema &S)
HandleArmSveVectorBitsTypeAttr - The "arm_sve_vector_bits" attribute is used to create fixed-length v...
#define FUNCTION_TYPE_ATTRS_CASELIST
static void HandleLifetimeCaptureByAttr(TypeProcessingState &State, QualType &CurType, ParsedAttr &PA)
static bool distributeNullabilityTypeAttr(TypeProcessingState &state, QualType type, ParsedAttr &attr)
Distribute a nullability type attribute that cannot be applied to the type specifier to a pointer,...
static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state, QualType &declSpecType, CUDAFunctionTarget CFT)
Given that there are attributes written on the declarator or declaration itself, try to distribute an...
static void fillHLSLAttributedResourceTypeLoc(HLSLAttributedResourceTypeLoc TL, TypeProcessingState &State)
static bool isDependentOrGNUAutoType(QualType T)
static void distributeFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType type)
A function type attribute was written somewhere in a declaration other than on the declarator itself ...
static void HandleMatrixTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
HandleMatrixTypeAttr - "matrix_type" attribute, like ext_vector_type.
static bool HandleWebAssemblyFuncrefAttr(TypeProcessingState &State, QualType &QT, ParsedAttr &PAttr)
static bool hasOuterPointerLikeChunk(const Declarator &D, unsigned endIndex)
Returns true if any of the declarator chunks before endIndex include a level of indirection: array,...
static void HandleOpenCLAccessAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
Handle OpenCL Access Qualifier Attribute.
static NullabilityKind mapNullabilityAttrKind(ParsedAttr::Kind kind)
Map a nullability attribute kind to a nullability kind.
static bool distributeFunctionTypeAttrToInnermost(TypeProcessingState &state, ParsedAttr &attr, ParsedAttributesView &attrList, QualType &declSpecType, CUDAFunctionTarget CFT)
Try to distribute a function type attribute to the innermost function chunk or type.
#define NULLABILITY_TYPE_ATTRS_CASELIST
static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, TypeSourceInfo *&ReturnTypeInfo)
static void checkNullabilityConsistency(Sema &S, SimplePointerKind pointerKind, SourceLocation pointerLoc, SourceLocation pointerEndLoc=SourceLocation())
Complains about missing nullability if the file containing pointerLoc has other uses of nullability (...
static void transferARCOwnership(TypeProcessingState &state, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership)
Used for transferring ownership in casts resulting in l-values.
static std::string getPrintableNameForEntity(DeclarationName Entity)
static std::string getFunctionQualifiersAsString(const FunctionProtoType *FnTy)
static QualType rebuildAttributedTypeWithoutNullability(ASTContext &Ctx, QualType Type)
Rebuild an attributed type without the nullability attribute on it.
static DeclaratorChunk * maybeMovePastReturnType(Declarator &declarator, unsigned i, bool onlyBlockPointers)
Given the index of a declarator chunk, check whether that chunk directly specifies the return type of...
static OpenCLAccessAttr::Spelling getImageAccess(const ParsedAttributesView &Attrs)
static void fillMatrixTypeLoc(MatrixTypeLoc MTL, const ParsedAttributesView &Attrs)
static UnaryTransformType::UTTKind TSTToUnaryTransformType(DeclSpec::TST SwitchTST)
static void HandleRISCVRVVVectorBitsTypeAttr(QualType &CurType, ParsedAttr &Attr, Sema &S)
HandleRISCVRVVVectorBitsTypeAttr - The "riscv_rvv_vector_bits" attribute is used to create fixed-leng...
static void HandleAddressSpaceTypeAttribute(QualType &Type, const ParsedAttr &Attr, TypeProcessingState &State)
HandleAddressSpaceTypeAttribute - Process an address_space attribute on the specified type.
static bool checkQualifiedFunction(Sema &S, QualType T, SourceLocation Loc, QualifiedFunctionKind QFK)
Check whether the type T is a qualified function type, and if it is, diagnose that it cannot be conta...
static bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator, QualType Result)
Return true if this is omitted block return type.
static bool DiagnoseMultipleAddrSpaceAttributes(Sema &S, LangAS ASOld, LangAS ASNew, SourceLocation AttrLoc)
static void warnAboutRedundantParens(Sema &S, Declarator &D, QualType T)
Produce an appropriate diagnostic for a declarator with top-level parentheses.
static QualType ConvertDeclSpecToType(TypeProcessingState &state)
Convert the specified declspec to the appropriate type object.
static std::pair< QualType, TypeSourceInfo * > InventTemplateParameter(TypeProcessingState &state, QualType T, TypeSourceInfo *TrailingTSI, AutoType *Auto, InventedTemplateParameterInfo &Info)
static void distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType, CUDAFunctionTarget CFT)
A function type attribute was written on the declarator or declaration.
static void diagnoseAndRemoveTypeQualifiers(Sema &S, const DeclSpec &DS, unsigned &TypeQuals, QualType TypeSoFar, unsigned RemoveTQs, unsigned DiagID)
static CallingConv getCCForDeclaratorChunk(Sema &S, Declarator &D, const ParsedAttributesView &AttrList, const DeclaratorChunk::FunctionTypeInfo &FTI, unsigned ChunkIndex)
Helper for figuring out the default CC for a function declarator type.
static unsigned getLiteralDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for literal type diagnostic message.
static void recordNullabilitySeen(Sema &S, SourceLocation loc)
Marks that a nullability feature has been used in the file containing loc.
static bool CheckBitIntElementType(Sema &S, SourceLocation AttrLoc, const BitIntType *BIT, bool ForMatrixType=false)
static void checkExtParameterInfos(Sema &S, ArrayRef< QualType > paramTypes, const FunctionProtoType::ExtProtoInfo &EPI, llvm::function_ref< SourceLocation(unsigned)> getParamLoc)
Check the extended parameter information.
static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type, CUDAFunctionTarget CFT)
Process an individual function attribute.
static void transferARCOwnershipToDeclSpec(Sema &S, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership)
static void BuildTypeCoupledDecls(Expr *E, llvm::SmallVectorImpl< TypeCoupledDeclRefInfo > &Decls)
static void assignInheritanceModel(Sema &S, CXXRecordDecl *RD)
Locks in the inheritance model for the given class and all of its bases.
static bool checkObjCKindOfType(TypeProcessingState &state, QualType &type, ParsedAttr &attr)
Check the application of the Objective-C '__kindof' qualifier to the given type.
static bool hasNullabilityAttr(const ParsedAttributesView &attrs)
Check whether there is a nullability attribute of any kind in the given attribute list.
static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
handleObjCOwnershipTypeAttr - Process an objc_ownership attribute on the specified type.
static void moveAttrFromListToList(ParsedAttr &attr, ParsedAttributesView &fromList, ParsedAttributesView &toList)
static void HandleAnnotateTypeAttr(TypeProcessingState &State, QualType &CurType, const ParsedAttr &PA)
static void fillAttributedTypeLoc(AttributedTypeLoc TL, TypeProcessingState &State)
static void fillDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc DASTL, const ParsedAttributesView &Attrs)
TypeAttrLocation
The location of a type attribute.
@ TAL_DeclChunk
The attribute is part of a DeclaratorChunk.
@ TAL_DeclSpec
The attribute is in the decl-specifier-seq.
@ TAL_DeclName
The attribute is immediately after the declaration's name.
static bool isOmittedBlockReturnType(const Declarator &D)
isOmittedBlockReturnType - Return true if this declarator is missing a return type because this is a ...
static TypeSourceInfo * GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo)
static QualType GetEnumUnderlyingType(Sema &S, QualType BaseType, SourceLocation Loc)
static bool IsNoDerefableChunk(const DeclaratorChunk &Chunk)
static AttrT * createSimpleAttr(ASTContext &Ctx, ParsedAttr &AL)
static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy, Declarator &D, unsigned FunctionChunkIndex)
static void processTypeAttrs(TypeProcessingState &state, QualType &type, TypeAttrLocation TAL, const ParsedAttributesView &attrs, CUDAFunctionTarget CFT=CUDAFunctionTarget::HostDevice)
static bool checkMutualExclusion(TypeProcessingState &state, const FunctionProtoType::ExtProtoInfo &EPI, ParsedAttr &Attr, AttributeCommonInfo::Kind OtherKind)
static Attr * getCCTypeAttr(ASTContext &Ctx, ParsedAttr &Attr)
Defines the clang::SourceLocation class and associated facilities.
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
__DEVICE__ int max(int __a, int __b)
virtual void 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.
QualType getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr, QualType Wrapped) const
unsigned getIntWidth(QualType T) const
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
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 getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType, const Attr *attr=nullptr) const
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
QualType getCountAttributedType(QualType T, Expr *CountExpr, bool CountInBytes, bool OrNull, ArrayRef< TypeCoupledDeclRefInfo > DependentDecls) const
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
QualType getDependentVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc, VectorKind VecKind) const
Return the unique reference to the type for a dependently sized vector of the specified element type.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getReadPipeType(QualType T) const
Return a read_only pipe type for the specified type.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
QualType getDependentBitIntType(bool Unsigned, Expr *BitsExpr) const
Return a dependent bit-precise integer type with the specified signedness and bit count.
QualType getReferenceQualifiedType(const Expr *e) const
getReferenceQualifiedType - Given an expr, will return the type for that expression,...
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const
Get a function type and produce the equivalent function type with the specified exception specificati...
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
const TargetInfo * getAuxTargetInfo() const
CanQualType UnsignedLongTy
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
QualType getCorrespondingSaturatedType(QualType Ty) const
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getPackExpansionType(QualType Pattern, std::optional< unsigned > NumExpansions, bool ExpectPackInType=true) const
Form a pack expansion type with the given pattern.
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
LangAS getDefaultOpenCLPointeeAddrSpace()
Returns default address space based on OpenCL version and enabled features.
const clang::PrintingPolicy & getPrintingPolicy() const
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
QualType getUnsignedWCharType() const
Return the type of "unsigned wchar_t".
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
QualType getWritePipeType(QualType T) const
Return a write_only pipe type for the specified type.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CanQualType UnsignedInt128Ty
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type.
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
CanQualType UnsignedLongLongTy
CanQualType UnsignedShortTy
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
QualType getDependentAddressSpaceType(QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttrLoc) const
QualType getPackIndexingType(QualType Pattern, Expr *IndexExpr, bool FullySubstituted=false, ArrayRef< QualType > Expansions={}, int Index=-1) const
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind UKind) const
Unary type transforms.
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const
Recurses in pointer/array types until it finds an Objective-C retainable type and returns its ownersh...
DiagnosticsEngine & getDiagnostics() const
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
const TargetInfo & getTargetInfo() const
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
QualType getCorrespondingUnsignedType(QualType T) const
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
QualType getTypeOfType(QualType QT, TypeOfKind Kind) const
getTypeOfType - Unlike many "get<Type>" functions, we don't unique TypeOfType nodes.
QualType getCorrespondingSignedType(QualType T) const
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const
Return the uniqued reference to the type for an Objective-C gc-qualified type.
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const
C++11 decltype.
QualType getIncompleteArrayType(QualType EltTy, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type.
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
QualType getTypeOfExprType(Expr *E, TypeOfKind Kind) const
C23 feature and GCC extension.
QualType getSignedWCharType() const
Return the type of "signed wchar_t".
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
QualType getBitIntType(bool Unsigned, unsigned NumBits) const
Return a bit-precise integer type with the specified signedness and bit count.
Wrapper for source info for array parameter types.
Wrapper for source info for arrays.
void setLBracketLoc(SourceLocation Loc)
void setRBracketLoc(SourceLocation Loc)
void setSizeExpr(Expr *Size)
TypeLoc getValueLoc() const
void setKWLoc(SourceLocation Loc)
void setParensRange(SourceRange Range)
Attr - This represents one attribute.
attr::Kind getKind() const
const char * getSpelling() const
SourceRange getRange() const
bool isContextSensitiveKeywordAttribute() const
bool isRegularKeywordAttribute() const
SourceLocation getLoc() const
const IdentifierInfo * getAttrName() const
Type source information for an attributed type.
TypeLoc getModifiedLoc() const
The modified type, which is generally canonically different from the attribute type.
void setAttr(const Attr *A)
An attributed type is a type to which a type attribute has been applied.
QualType getModifiedType() const
bool isCallingConv() const
static std::optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
bool hasExplicitTemplateArgs() const
const NestedNameSpecifierLoc getNestedNameSpecifierLoc() const
SourceLocation getRAngleLoc() const
ConceptDecl * getNamedConcept() const
SourceLocation getLAngleLoc() const
void setConceptReference(ConceptReference *CR)
NamedDecl * getFoundDecl() const
TemplateArgumentLoc getArgLoc(unsigned i) const
unsigned getNumArgs() const
DeclarationNameInfo getConceptNameInfo() const
void setRParenLoc(SourceLocation Loc)
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
bool isDecltypeAuto() const
ConceptDecl * getTypeConstraintConcept() const
Type source information for an btf_tag attributed type.
TypeLoc getWrappedLoc() const
Comparison function object.
A fixed int type of a specified bitwidth.
unsigned getNumBits() const
Wrapper for source info for block pointers.
void setCaretLoc(SourceLocation Loc)
Wrapper for source info for builtin types.
TypeSpecifierWidth getWrittenWidthSpec() const
bool needsExtraLocalData() const
void setBuiltinLoc(SourceLocation Loc)
WrittenBuiltinSpecs & getWrittenBuiltinSpecs()
TypeSpecifierSign getWrittenSignSpec() const
void expandBuiltinRange(SourceRange Range)
This class is used for builtin types like 'int'.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
bool isAggregate() const
Determine whether this class is an aggregate (C++ [dcl.init.aggr]), which is a class with no user-dec...
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
bool isLambda() const
Determine whether this class describes a lambda function object.
bool hasConstexprNonCopyMoveConstructor() const
Determine whether this class has at least one constexpr constructor other than the copy or move const...
bool hasConstexprDestructor() const
Determine whether this class has a constexpr destructor.
bool hasNonLiteralTypeFieldsOrBases() const
Determine whether this class has a non-literal or/ volatile type non-static data member or base class...
CXXRecordDecl * getMostRecentNonInjectedDecl()
base_class_range vbases()
bool hasUserProvidedDefaultConstructor() const
Whether this class has a user-provided default constructor per C++11.
bool hasDefinition() const
MSInheritanceModel calculateInheritanceModel() const
Calculate what the inheritance model would be for this class.
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Represents a C++ nested-name-specifier or a global scope specifier.
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
bool isValid() const
A scope specifier is present, and it refers to a real scope.
SourceRange getRange() const
SourceLocation getBeginLoc() const
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Represents a canonical, potentially-qualified type.
SourceLocation getBegin() const
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a C++20 concept.
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten)
const TypeClass * getTypePtr() const
TypeLoc getNextTypeLoc() const
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
static constexpr bool isDimensionValid(size_t NumElements)
Returns true if NumElements is a valid matrix dimension.
Wrapper for source info for pointers decayed from arrays and functions.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
bool isFunctionOrMethod() const
A reference to a declared variable, function, enum, etc.
Captures information about "declaration specifiers".
const WrittenBuiltinSpecs & getWrittenBuiltinSpecs() const
bool isTypeSpecPipe() const
static const TST TST_typeof_unqualType
SourceLocation getTypeSpecSignLoc() const
static const TST TST_typename
SourceLocation getEndLoc() const LLVM_READONLY
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
static const TST TST_char8
static const TST TST_BFloat16
Expr * getPackIndexingExpr() const
TST getTypeSpecType() const
SCS getStorageClassSpec() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isTypeSpecSat() const
SourceRange getSourceRange() const LLVM_READONLY
static const TST TST_auto_type
static const TST TST_interface
static const TST TST_double
static const TST TST_typeofExpr
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
TemplateIdAnnotation * getRepAsTemplateId() const
static const TST TST_union
static const TST TST_typename_pack_indexing
static const TST TST_char
static const TST TST_bool
static const TST TST_char16
static const TST TST_unknown_anytype
TSC getTypeSpecComplex() const
ParsedType getRepAsType() const
static const TST TST_accum
static const TST TST_half
ParsedAttributes & getAttributes()
SourceLocation getEllipsisLoc() const
bool isTypeAltiVecPixel() const
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
SourceLocation getConstSpecLoc() const
static const TST TST_ibm128
Expr * getRepAsExpr() const
static const TST TST_enum
static const TST TST_float128
static const TST TST_decltype
SourceRange getTypeSpecWidthRange() const
SourceLocation getTypeSpecTypeNameLoc() const
SourceLocation getTypeSpecWidthLoc() const
SourceLocation getRestrictSpecLoc() const
static const TST TST_typeof_unqualExpr
static const TST TST_class
static const TST TST_decimal64
bool isTypeAltiVecBool() const
bool isConstrainedAuto() const
static const TST TST_wchar
SourceLocation getTypeSpecComplexLoc() const
static const TST TST_void
bool isTypeAltiVecVector() const
static const TST TST_bitint
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
static const TST TST_float
static const TST TST_atomic
static const TST TST_fract
Decl * getRepAsDecl() const
static const TST TST_float16
static bool isTransformTypeTrait(TST T)
static const TST TST_unspecified
SourceLocation getAtomicSpecLoc() const
TypeSpecifierSign getTypeSpecSign() const
CXXScopeSpec & getTypeSpecScope()
SourceLocation getTypeSpecTypeLoc() const
static const TST TST_decltype_auto
static const TST TST_error
void forEachQualifier(llvm::function_ref< void(TQ, StringRef, SourceLocation)> Handle)
This method calls the passed in handler on each qual being set.
static const TST TST_decimal32
TypeSpecifierWidth getTypeSpecWidth() const
static const TST TST_char32
static const TST TST_decimal128
bool isTypeSpecOwned() const
SourceLocation getTypeSpecSatLoc() const
SourceRange getTypeofParensRange() const
static const TST TST_int128
SourceLocation getVolatileSpecLoc() const
static const TST TST_typeofType
static const TST TST_auto
static const TST TST_struct
Decl - This represents one declaration (or definition), e.g.
SourceLocation getEndLoc() const LLVM_READONLY
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined.
ASTContext & getASTContext() const LLVM_READONLY
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Kind
Lists the kind of concrete classes of Decl.
bool isInvalidDecl() const
SourceLocation getLocation() const
void setImplicit(bool I=true)
SourceLocation getBeginLoc() const LLVM_READONLY
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
The name of a declaration.
std::string getAsString() const
Retrieve the human-readable string for this name.
NameKind getNameKind() const
Determine what kind of name this is.
Information about one declarator, including the parsed type information and the identifier.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
void AddInnermostTypeInfo(const DeclaratorChunk &TI)
Add a new innermost chunk to this declarator.
const ParsedAttributes & getAttributes() const
SourceLocation getIdentifierLoc() const
void setInvalidType(bool Val=true)
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
const ParsedAttributesView & getDeclarationAttributes() const
DeclaratorContext getContext() const
SourceLocation getBeginLoc() const LLVM_READONLY
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
void setRParenLoc(SourceLocation Loc)
void setDecltypeLoc(SourceLocation Loc)
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
void setAttrNameLoc(SourceLocation loc)
void setAttrOperandParensRange(SourceRange range)
void setAttrExprOperand(Expr *e)
Represents an extended address space qualifier where the input address space value is dependent.
void copy(DependentNameTypeLoc Loc)
void setNameLoc(SourceLocation Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
void setNameLoc(SourceLocation Loc)
void copy(DependentTemplateSpecializationTypeLoc Loc)
void setNameLoc(SourceLocation Loc)
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
bool getSuppressSystemWarnings() const
Wrap a function effect's condition expression in another struct so that FunctionProtoType's TrailingO...
void copy(ElaboratedTypeLoc Loc)
void setElaboratedKeywordLoc(SourceLocation Loc)
TypeLoc getNamedTypeLoc() const
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
This represents one expression.
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
A SourceLocation and its associated SourceManager.
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration.
A mutable set of FunctionEffects and possibly conditions attached to them.
bool insert(const FunctionEffectWithCondition &NewEC, Conflicts &Errs)
Represents an abstract function effect, using just an enumeration describing its kind.
Kind
Identifies the particular effect.
An immutable set of FunctionEffects and possibly conditions attached to them.
Represents a prototype with parameter type info, e.g.
Qualifiers getMethodQuals() const
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Wrapper for source info for functions.
unsigned getNumParams() const
void setLocalRangeBegin(SourceLocation L)
void setLParenLoc(SourceLocation Loc)
void setParam(unsigned i, ParmVarDecl *VD)
void setRParenLoc(SourceLocation Loc)
void setLocalRangeEnd(SourceLocation L)
void setExceptionSpecRange(SourceRange R)
A class which abstracts out some details necessary for making a call.
ExtInfo withNoCfCheck(bool noCfCheck) const
ExtInfo withCallingConv(CallingConv cc) const
CallingConv getCC() const
ExtInfo withProducesResult(bool producesResult) const
ExtInfo withNoReturn(bool noReturn) const
bool getProducesResult() const
ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const
ExtInfo withCmseNSCall(bool cmseNSCall) const
ExtInfo withRegParm(unsigned RegParm) const
ParameterABI getABI() const
Return the ABI treatment of this parameter.
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
static StringRef getNameForCallConv(CallingConv CC)
static ArmStateValue getArmZT0State(unsigned AttrBits)
static ArmStateValue getArmZAState(unsigned AttrBits)
CallingConv getCallConv() const
QualType getReturnType() const
bool getHasRegParm() const
AArch64SMETypeAttributes
The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number of function type attributes that...
@ SME_PStateSMEnabledMask
@ SME_PStateSMCompatibleMask
@ SME_AgnosticZAStateMask
Type source information for HLSL attributed resource type.
TypeLoc getWrappedLoc() const
void setContainedTypeSourceInfo(TypeSourceInfo *TSI) const
void setSourceRange(const SourceRange &R)
One of these records is kept for each identifier that is lexed.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void setAmpLoc(SourceLocation Loc)
An lvalue reference type, per C++11 [dcl.ref].
@ PPTMK_FullGeneralityMultipleInheritance
@ PPTMK_FullGeneralityVirtualInheritance
@ PPTMK_FullGeneralitySingleInheritance
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool requiresStrictPrototypes() const
Returns true if functions without prototypes or functions with an identifier list (aka K&R C function...
bool isImplicitIntAllowed() const
Returns true if implicit int is supported at all.
bool isImplicitIntRequired() const
Returns true if implicit int is part of the language requirements.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
Represents the results of name lookup.
TypeLoc getInnerLoc() const
void setExpansionLoc(SourceLocation Loc)
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.
void setAttrRowOperand(Expr *e)
void setAttrColumnOperand(Expr *e)
void setAttrOperandParensRange(SourceRange range)
void setAttrNameLoc(SourceLocation loc)
static bool isValidElementType(QualType T)
Valid elements types are the following:
Wrapper for source info for member pointers.
void setStarLoc(SourceLocation Loc)
void setClassTInfo(TypeSourceInfo *TI)
const Type * getClass() const
A pointer to member type per C++ 8.3.3 - Pointers to members.
QualType getPointeeType() const
const Type * getClass() const
Provides information a specialization of a member of a class template, which may be a member function...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
This represents a decl that may have a name.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
A C++ nested-name-specifier augmented with source location information.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
SourceLocation getLocalBeginLoc() const
Retrieve the location of the beginning of this component of the nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
Represents an ObjC class declaration.
Wrapper for source info for ObjC interfaces.
void setNameLoc(SourceLocation Loc)
void setNameEndLoc(SourceLocation Loc)
Interfaces are the core concept in Objective-C for object oriented design.
Wraps an ObjCPointerType with source location information.
void setStarLoc(SourceLocation Loc)
Represents a pointer to an Objective C object.
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Represents a class type in Objective C.
static OpaquePtr make(QualType P)
OpenCL supported extensions and optional core features.
bool isAvailableOption(llvm::StringRef Ext, const LangOptions &LO) const
bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const
void setEllipsisLoc(SourceLocation Loc)
A parameter attribute which changes the argument-passing ABI rule for the parameter.
void setRParenLoc(SourceLocation Loc)
void setLParenLoc(SourceLocation Loc)
Represents a parameter to a function.
bool isExplicitObjectParameter() const
void setKNRPromoted(bool promoted)
void setExplicitObjectParameterLoc(SourceLocation Loc)
ParsedAttr - Represents a syntactic attribute.
void setInvalid(bool b=true) const
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this attribute.
bool isArgIdent(unsigned Arg) const
Expr * getArgAsExpr(unsigned Arg) const
AttributeCommonInfo::Kind getKind() const
void setUsedAsTypeAttr(bool Used=true)
bool checkAtMostNumArgs(class Sema &S, unsigned Num) const
Check if the attribute has at most as many args as Num.
void addAtEnd(ParsedAttr *newAttr)
bool hasAttribute(ParsedAttr::Kind K) const
void remove(ParsedAttr *ToBeRemoved)
void takeOneFrom(ParsedAttributes &Other, ParsedAttr *PA)
TypeLoc getValueLoc() const
void setKWLoc(SourceLocation Loc)
Wrapper for source info for pointers.
void setStarLoc(SourceLocation Loc)
PointerType - C99 6.7.5.1 - Pointer Declarators.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
SourceLocation getPragmaAssumeNonNullLoc() const
The location of the currently-active #pragma clang assume_nonnull begin.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
bool isReferenceable() const
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
SplitQualType getSplitUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool hasAddressSpace() const
Check if this type has any address space qualifier.
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Wrapper of type source information for a type with non-trivial direct qualifiers.
UnqualTypeLoc getUnqualifiedLoc() const
The collection of all-type qualifiers we support.
void removeCVRQualifiers(unsigned mask)
void addAddressSpace(LangAS space)
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
void removeObjCLifetime()
void addCVRUQualifiers(unsigned mask)
static Qualifiers fromCVRMask(unsigned CVR)
@ MaxAddressSpace
The maximum supported address space number.
void setUnaligned(bool flag)
std::string getAsString() const
void addObjCLifetime(ObjCLifetime type)
void setAmpAmpLoc(SourceLocation Loc)
Represents a struct/union/class.
field_range fields() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
bool isSpelledAsLValue() const
bool isFunctionDeclarationScope() const
isFunctionDeclarationScope - Return true if this scope is a function prototype scope.
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
QualType ProcessResourceTypeAttributes(QualType Wrapped)
QualType getInoutParameterType(QualType Ty)
bool isCFError(RecordDecl *D)
IdentifierInfo * getNSErrorIdent()
Retrieve the identifier "NSError".
bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type)
bool isInOpenMPTaskUntiedContext() const
Return true if currently in OpenMP task with untied clause context.
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
Abstract base class used for diagnosing integer constant expression violations.
Sema - This implements semantic analysis and AST building for C.
bool hasReachableDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a reachable definition.
QualType BuildParenType(QualType T)
Build a paren type including T.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
bool ConstantFoldAttrArgs(const AttributeCommonInfo &CI, MutableArrayRef< Expr * > Args)
ConstantFoldAttrArgs - Folds attribute arguments into ConstantExprs (unless they are value dependent ...
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Scope * getCurScope() const
Retrieve the parser's current scope.
bool hasStructuralCompatLayout(Decl *D, Decl *Suggested)
Determine if D and Suggested have a structurally compatible layout as described in C11 6....
bool checkArrayElementAlignment(QualType EltTy, SourceLocation Loc)
bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID, const Ts &...Args)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace, SourceLocation AttrLoc)
BuildAddressSpaceAttr - Builds a DependentAddressSpaceType if an expression is uninstantiated.
QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement)
Completely replace the auto in TypeWithAuto by Replacement.
QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc)
std::optional< FunctionEffectMode > ActOnEffectExpression(Expr *CondExpr, StringRef AttributeName)
Try to parse the conditional expression attached to an effect attribute (e.g.
@ AcceptSizeless
Relax the normal rules for complete types so that they include sizeless built-in types.
class clang::Sema::DelayedDiagnostics DelayedDiagnostics
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
QualType BuildExtVectorType(QualType T, Expr *ArraySize, SourceLocation AttrLoc)
Build an ext-vector type.
const AttributedType * getCallingConvAttributedType(QualType T) const
Get the outermost AttributedType node that sets a calling convention.
bool hasMergedDefinitionInCurrentModule(const NamedDecl *Def)
QualType BuildFunctionType(QualType T, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc, DeclarationName Entity, const FunctionProtoType::ExtProtoInfo &EPI)
Build a function type.
void checkSpecializationReachability(SourceLocation Loc, NamedDecl *Spec)
ASTContext & getASTContext() const
void translateTemplateArguments(const ASTTemplateArgsPtr &In, TemplateArgumentListInfo &Out)
Translates template arguments as provided by the parser into template arguments used by semantic anal...
void checkExceptionSpecification(bool IsTopLevel, ExceptionSpecificationType EST, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr, SmallVectorImpl< QualType > &Exceptions, FunctionProtoType::ExceptionSpecInfo &ESI)
Check the given exception-specification and update the exception specification information with the r...
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC, const FunctionDecl *FD=nullptr, CUDAFunctionTarget CFT=CUDAFunctionTarget::InvalidTarget)
Check validaty of calling convention attribute attr.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
QualType BuildCountAttributedArrayOrPointerType(QualType WrappedTy, Expr *CountExpr, bool CountInBytes, bool OrNull)
std::string getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const
Get a string to suggest for zero-initialization of a type.
bool CheckAttrNoArgs(const ParsedAttr &CurrAttr)
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
QualType BuildBitIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc)
Build a bit-precise integer type.
LangAS getDefaultCXXMethodAddrSpace() const
Returns default addr space for method qualifiers.
QualType BuiltinRemoveReference(QualType BaseType, UTTKind UKind, SourceLocation Loc)
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
bool InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation, ClassTemplateSpecializationDecl *ClassTemplateSpec, TemplateSpecializationKind TSK, bool Complain=true)
bool CheckFunctionReturnType(QualType T, SourceLocation Loc)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_TypeConstraint
A type constraint.
const LangOptions & getLangOpts() const
bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type of the given expression is complete.
bool AttachTypeConstraint(NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo, ConceptDecl *NamedConcept, NamedDecl *FoundDecl, const TemplateArgumentListInfo *TemplateArgs, TemplateTypeParmDecl *ConstrainedParameter, QualType ConstrainedType, SourceLocation EllipsisLoc)
Attach a type-constraint to a template parameter.
void NoteTemplateLocation(const NamedDecl &Decl, std::optional< SourceRange > ParamRange={})
QualType BuiltinEnumUnderlyingType(QualType BaseType, SourceLocation Loc)
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
const LangOptions & LangOpts
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
IdentifierInfo * InventAbbreviatedTemplateParameterTypeName(const IdentifierInfo *ParamName, unsigned Index)
Invent a new identifier for parameters of abbreviated templates.
SourceLocation ImplicitMSInheritanceAttrLoc
Source location for newly created implicit MSInheritanceAttrs.
SmallVector< InventedTemplateParameterInfo, 4 > InventedParameterInfos
Stack containing information needed when in C++2a an 'auto' is encountered in a function declaration ...
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
void completeExprArrayBound(Expr *E)
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
bool hasExplicitCallingConv(QualType T)
bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value)
Checks a regparm attribute, returning true if it is ill-formed and otherwise setting numParams to the...
FileNullabilityMap NullabilityMap
A mapping that describes the nullability we've seen in each header file.
sema::FunctionScopeInfo * getCurFunction() const
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
ExprResult DefaultLvalueConversion(Expr *E)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
MultiLevelTemplateArgumentList getTemplateInstantiationArgs(const NamedDecl *D, const DeclContext *DC=nullptr, bool Final=false, std::optional< ArrayRef< TemplateArgument > > Innermost=std::nullopt, bool RelativeToPrimary=false, const FunctionDecl *Pattern=nullptr, bool ForConstraintInstantiation=false, bool SkipForSpecialization=false, bool ForDefaultArgumentSubstitution=false)
Retrieve the template argument list(s) that should be used to instantiate the definition of the given...
QualType BuiltinDecay(QualType BaseType, SourceLocation Loc)
IdentifierInfo * getNullabilityKeyword(NullabilityKind nullability)
Retrieve the keyword associated.
@ TAH_IgnoreTrivialABI
The triviality of a method unaffected by "trivial_abi".
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
bool isAcceptable(const NamedDecl *D, AcceptableKind Kind)
Determine whether a declaration is acceptable (visible/reachable).
QualType getDecltypeForExpr(Expr *E)
getDecltypeForExpr - Given an expr, will return the decltype for that expression, according to the ru...
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
QualType BuiltinAddReference(QualType BaseType, UTTKind UKind, SourceLocation Loc)
bool hasVisibleMergedDefinition(const NamedDecl *Def)
QualType BuildPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc, bool FullySubstituted=false, ArrayRef< QualType > Expansions={})
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
QualType BuildAtomicType(QualType T, SourceLocation Loc)
void diagnoseMissingImport(SourceLocation Loc, const NamedDecl *Decl, MissingImportKind MIK, bool Recover=true)
Diagnose that the specified declaration needs to be visible but isn't, and suggest a module import th...
bool diagnoseConflictingFunctionEffect(const FunctionEffectsRef &FX, const FunctionEffectWithCondition &EC, SourceLocation NewAttrLoc)
Warn and return true if adding a function effect to a set would create a conflict.
TypeSourceInfo * ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, QualType Replacement)
TypeResult ActOnTypeName(Declarator &D)
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool isCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind=CompleteTypeKind::Default)
bool InstantiateClass(SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs, TemplateSpecializationKind TSK, bool Complain=true)
Instantiate the definition of a class from a given pattern.
void checkUnusedDeclAttributes(Declarator &D)
checkUnusedDeclAttributes - Given a declarator which is not being used to build a declaration,...
QualType BuildPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a pointer type.
bool CheckAttrTarget(const ParsedAttr &CurrAttr)
QualType BuiltinAddPointer(QualType BaseType, SourceLocation Loc)
@ CCEK_ArrayBound
Array bound in array declarator or new-expression.
bool CheckImplicitNullabilityTypeSpecifier(QualType &Type, NullabilityKind Nullability, SourceLocation DiagLoc, bool AllowArrayTypes, bool OverrideExisting)
Check whether a nullability type specifier can be added to the given type through some means not writ...
void CheckConstrainedAuto(const AutoType *AutoT, SourceLocation Loc)
bool CheckDistantExceptionSpec(QualType T)
CheckDistantExceptionSpec - Check if the given type is a pointer or pointer to member to a function w...
QualType BuildDecltypeType(Expr *E, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
QualType BuildUnaryTransformType(QualType BaseType, UTTKind UKind, SourceLocation Loc)
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
TypeSourceInfo * GetTypeForDeclaratorCast(Declarator &D, QualType FromTy)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
QualType getCapturedDeclRefType(ValueDecl *Var, SourceLocation Loc)
Given a variable, determine the type that a reference to that variable will have in the given scope.
QualType BuiltinRemoveExtent(QualType BaseType, UTTKind UKind, SourceLocation Loc)
QualType getCompletedType(Expr *E)
Get the type of expression E, triggering instantiation to complete the type if necessary – that is,...
QualType BuiltinChangeCVRQualifiers(QualType BaseType, UTTKind UKind, SourceLocation Loc)
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
SourceManager & SourceMgr
DiagnosticsEngine & Diags
OpenCLOptions & getOpenCLOptions()
QualType BuiltinRemovePointer(QualType BaseType, SourceLocation Loc)
QualType BuildArrayType(QualType T, ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity)
Build an array type.
bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc)
QualType BuildReadPipeType(QualType T, SourceLocation Loc)
Build a Read-only Pipe type.
void diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, SourceLocation FallbackLoc, SourceLocation ConstQualLoc=SourceLocation(), SourceLocation VolatileQualLoc=SourceLocation(), SourceLocation RestrictQualLoc=SourceLocation(), SourceLocation AtomicQualLoc=SourceLocation(), SourceLocation UnalignedQualLoc=SourceLocation())
LangOptions::PragmaMSPointersToMembersKind MSPointerToMemberRepresentationMethod
Controls member pointer representation format under the MS ABI.
llvm::BumpPtrAllocator BumpAlloc
QualType BuildWritePipeType(QualType T, SourceLocation Loc)
Build a Write-only Pipe type.
QualType ActOnPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc)
QualType BuildTypeofExprType(Expr *E, TypeOfKind Kind)
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
QualType BuildMatrixType(QualType T, Expr *NumRows, Expr *NumColumns, SourceLocation AttrLoc)
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)
bool hasAcceptableDefinition(NamedDecl *D, NamedDecl **Suggested, AcceptableKind Kind, bool OnlyNeedComplete=false)
QualType BuiltinChangeSignedness(QualType BaseType, UTTKind UKind, SourceLocation Loc)
void adjustMemberFunctionCC(QualType &T, bool HasThisPointer, bool IsCtorOrDtor, SourceLocation Loc)
Adjust the calling convention of a method to be the ABI default if it wasn't specified explicitly.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMemberKind CSM, TrivialABIHandling TAH=TAH_IgnoreTrivialABI, bool Diagnose=false)
Determine whether a defaulted or deleted special member function is trivial, as specified in C++11 [c...
bool checkStringLiteralArgumentAttr(const AttributeCommonInfo &CI, const Expr *E, StringRef &Str, SourceLocation *ArgLocation=nullptr)
Check if the argument E is a ASCII string literal.
QualType BuildMemberPointerType(QualType T, QualType Class, SourceLocation Loc, DeclarationName Entity)
Build a member pointer type T Class::*.
QualType BuildBlockPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a block pointer type.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Information about a FileID, basically just the logical file that it represents and include stack info...
CharacteristicKind getFileCharacteristic() const
Return whether this is a system header or not.
SourceLocation getIncludeLoc() const
This is a discriminated union of FileInfo and ExpansionInfo.
const FileInfo & getFile() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
Represents the declaration of a struct/union/class/enum.
void setEmbeddedInDeclarator(bool isInDeclarator)
True if this tag declaration is "embedded" (i.e., defined or declared for the very first time) in the...
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
TagKind getTagKind() const
Wrapper for source info for tag types.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Exposes information about the current target.
virtual bool hasBitIntType() const
Determine whether the _BitInt type is supported on this target.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
virtual size_t getMaxBitIntWidth() const
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
virtual bool allowHalfArgsAndReturns() const
Whether half args and returns are supported.
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
virtual bool hasFloat16Type() const
Determine whether the _Float16 type is supported on this target.
bool isVLASupported() const
Whether target supports variable-length arrays.
virtual bool hasIbm128Type() const
Determine whether the __ibm128 type is supported on this target.
virtual bool hasFloat128Type() const
Determine whether the __float128 type is supported on this target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
virtual bool hasBFloat16Type() const
Determine whether the _BFloat16 type is supported on this target.
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
virtual std::optional< std::pair< unsigned, unsigned > > getVScaleRange(const LangOptions &LangOpts) const
Returns target-specific min and max values VScale_Range.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Location wrapper for a TemplateArgument.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) const
Retrieve the underlying template declaration that this template name refers to, if known.
UsingShadowDecl * getAsUsingShadowDecl() const
Retrieve the using shadow declaration through which the underlying template declaration is introduced...
SourceLocation getRAngleLoc() const
void copy(TemplateSpecializationTypeLoc Loc)
Declaration of a template type parameter.
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
[BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by a...
const Type * getTypeForDecl() const
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
Base wrapper for a particular "section" of type source info.
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same type.
unsigned getFullDataSize() const
Returns the size of the type source info data block.
AutoTypeLoc getContainedAutoTypeLoc() const
Get the typeloc of an AutoType whose type will be deduced for a variable with an initializer of this ...
void * getOpaqueData() const
Get the pointer where source information is stored.
void copy(TypeLoc other)
Copies the other type loc into this one.
void initialize(ASTContext &Context, SourceLocation Loc) const
Initializes this to state that every location in this type is the given location.
SourceLocation getEndLoc() const
Get the end source location.
SourceLocation getBeginLoc() const
Get the begin source location.
void setUnmodifiedTInfo(TypeSourceInfo *TI) const
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
void setNameLoc(SourceLocation Loc)
The base class of the type hierarchy.
bool isSizelessType() const
As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isBooleanType() const
QualType getRVVEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an RVV builtin type.
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
bool isIncompleteArrayType() const
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
bool isUndeducedAutoType() const
bool isConstantArrayType() const
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
bool isVariableArrayType() const
bool isSizelessBuiltinType() const
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool canHaveNullability(bool ResultIfUnknown=true) const
Determine whether the given type can have a nullability specifier applied to it, i....
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isBitIntType() const
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isChar16Type() const
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
QualType getCanonicalTypeInternal() const
bool isWebAssemblyTableType() const
Returns true if this is a WebAssembly table type: either an array of reference types,...
bool isMemberPointerType() const
bool isAtomicType() const
bool isFunctionProtoType() const
bool isObjCIdType() const
bool isChar32Type() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isObjectType() const
Determine whether this type is an object type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isRVVVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'riscv_rvv_vector_bits' type attribute,...
bool isRealFloatingType() const
Floating point categories.
bool isWideCharType() const
bool isAnyPointerType() const
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
bool isRecordType() const
bool isObjCRetainableType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Base class for declarations which introduce a typedef-name.
Wrapper for source info for typedefs.
void setParensRange(SourceRange range)
void setTypeofLoc(SourceLocation Loc)
Wrapper of type source information for a type with no direct qualifiers.
TypeLocClass getTypeLocClass() const
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
void setNameLoc(SourceLocation Loc)
Represents a GCC generic vector type.
VectorKind getVectorKind() const
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
Retains information about a function, method, or block that is currently being parsed.
Defines the clang::TargetInfo interface.
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefDecl > typedefDecl
Matches typedef declarations.
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
const internal::VariadicDynCastAllOfMatcher< Decl, RecordDecl > recordDecl
Matches class, struct, and union declarations.
The JSON file list parser is used to communicate input to InstallAPI.
TypeSpecifierType
Specifies the kind of type.
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
@ ExpectedParameterOrImplicitObjectParameter
@ ExpectedFunctionWithProtoType
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
@ GNUAutoType
__auto_type (GNU extension)
@ DecltypeAuto
decltype(auto)
llvm::StringRef getParameterABISpelling(ParameterABI kind)
FunctionEffectMode
Used with attributes/effects with a boolean condition, e.g. nonblocking.
LLVM_READONLY bool isAsciiIdentifierContinue(unsigned char c)
NullabilityKind
Describes the nullability of a particular type.
@ Nullable
Values of this type can be null.
@ Unspecified
Whether values of this type can be null is (explicitly) unspecified.
@ NonNull
Values of this type can never be null.
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
llvm::PointerUnion< Expr *, IdentifierLoc * > ArgsUnion
A union of the various pointer types that can be passed to an ParsedAttr as an argument.
@ IK_DeductionGuideName
A deduction-guide name (a template-name)
@ IK_ImplicitSelfParam
An implicit 'self' parameter.
@ IK_TemplateId
A template-id, e.g., f<int>.
@ IK_ConstructorTemplateId
A constructor named via a template-id.
@ IK_ConstructorName
A constructor name.
@ IK_LiteralOperatorId
A user-defined literal name, e.g., operator "" _i.
@ IK_Identifier
An identifier.
@ IK_DestructorName
A destructor name.
@ IK_OperatorFunctionId
An overloaded operator name, e.g., operator+.
@ IK_ConversionFunctionId
A conversion function name, e.g., operator int.
TypeOfKind
The kind of 'typeof' expression we're after.
@ AANT_ArgumentIntegerConstant
@ Result
The result type of a method or function.
llvm::StringRef getNullabilitySpelling(NullabilityKind kind, bool isContextSensitive=false)
Retrieve the spelling of the given nullability kind.
ArraySizeModifier
Capture whether this is a normal array (e.g.
@ SwiftAsyncContext
This parameter (which must have pointer type) uses the special Swift asynchronous context-pointer ABI...
@ SwiftErrorResult
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
@ Ordinary
This parameter uses ordinary ABI rules for its type.
@ SwiftIndirectResult
This parameter (which must have pointer type) is a Swift indirect result parameter.
@ SwiftContext
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment.
bool supportsVariadicCall(CallingConv CC)
Checks whether the given calling convention supports variadic calls.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
static bool isBlockPointer(Expr *Arg)
ActionResult< Expr * > ExprResult
TagTypeKind
The kind of a tag type.
@ Interface
The "__interface" keyword.
@ Struct
The "struct" keyword.
@ Class
The "class" keyword.
@ Union
The "union" keyword.
@ Enum
The "enum" keyword.
LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t',...
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword.
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ FirstTargetAddressSpace
const FunctionProtoType * T
MSInheritanceModel
Assigned inheritance model for a class in the MS C++ ABI.
@ Incomplete
Template argument deduction did not deduce a value for every template parameter.
@ Success
Template argument deduction was successful.
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ SveFixedLengthData
is AArch64 SVE fixed-length data vector
@ Generic
not a target-specific vector type
@ RVVFixedLengthData
is RISC-V RVV fixed-length data vector
@ RVVFixedLengthMask
is RISC-V RVV fixed-length mask vector
@ NeonPoly
is ARM Neon polynomial vector
@ SveFixedLengthPredicate
is AArch64 SVE fixed-length predicate vector
LangAS getLangASFromTargetAS(unsigned TargetAS)
@ None
The alignment was not explicit in code.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ None
No keyword precedes the qualified type name.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Parens
New-expression has a C++98 paren-delimited initializer.
@ EST_DependentNoexcept
noexcept(expression), value-dependent
@ EST_Uninstantiated
not instantiated yet
@ EST_Unparsed
not parsed yet
@ EST_NoThrow
Microsoft __declspec(nothrow) extension.
@ EST_None
no exception specification
@ EST_MSAny
Microsoft throw(...) extension.
@ EST_BasicNoexcept
noexcept
@ EST_NoexceptFalse
noexcept(expression), evals to 'false'
@ EST_Unevaluated
not evaluated yet, for special member function
@ EST_NoexceptTrue
noexcept(expression), evals to 'true'
@ EST_Dynamic
throw(T1, T2)
@ Implicit
An implicit conversion.
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
unsigned isStar
True if this dimension was [*]. In this case, NumElts is null.
unsigned TypeQuals
The type qualifiers for the array: const/volatile/restrict/__unaligned/_Atomic.
unsigned hasStatic
True if this dimension included the 'static' keyword.
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
unsigned TypeQuals
For now, sema will catch these as invalid.
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with ',...)',...
SourceLocation getTrailingReturnTypeLoc() const
Get the trailing-return-type location for this function declarator.
SourceLocation getLParenLoc() const
bool hasTrailingReturnType() const
Determine whether this function declarator had a trailing-return-type.
TypeAndRange * Exceptions
Pointer to a new[]'d array of TypeAndRange objects that contain the types in the function's dynamic e...
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
ParsedType getTrailingReturnType() const
Get the trailing-return-type for this function declarator.
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
SourceLocation getExceptionSpecLocBeg() const
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
SourceLocation getRParenLoc() const
SourceLocation getEllipsisLoc() const
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
unsigned getNumExceptions() const
Get the number of dynamic exception specifications.
bool hasMethodTypeQualifiers() const
Determine whether this method has qualifiers.
unsigned isAmbiguous
Can this declaration be a constructor-style initializer?
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
SourceRange getExceptionSpecRange() const
ExceptionSpecificationType getExceptionSpecType() const
Get the type of exception specification this function has.
Expr * NoexceptExpr
Pointer to the expression in the noexcept-specifier of this function, if it has one.
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
SourceLocation StarLoc
Location of the '*' token.
const IdentifierInfo * Ident
SourceLocation RestrictQualLoc
The location of the restrict-qualifier, if any.
SourceLocation ConstQualLoc
The location of the const-qualifier, if any.
SourceLocation VolatileQualLoc
The location of the volatile-qualifier, if any.
SourceLocation UnalignedQualLoc
The location of the __unaligned-qualifier, if any.
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/unaligned/atomic.
SourceLocation AtomicQualLoc
The location of the _Atomic-qualifier, if any.
bool LValueRef
True if this is an lvalue reference, false if it's an rvalue reference.
bool HasRestrict
The type qualifier: restrict. [GNU] C++ extension.
One instance of this struct is used for each type in a declarator that is parsed.
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
enum clang::DeclaratorChunk::@224 Kind
SourceLocation EndLoc
EndLoc - If valid, the place where this chunck ends.
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), SourceLocation TrailingReturnTypeLoc=SourceLocation(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
MemberPointerTypeInfo Mem
SourceLocation Loc
Loc - The place where this type was defined.
Describes whether we've seen any nullability information for the given file.
SourceLocation PointerEndLoc
The end location for the first pointer declarator in the file.
SourceLocation PointerLoc
The first pointer declarator (of any pointer kind) in the file that does not have a corresponding nul...
bool SawTypeNullability
Whether we saw any type nullability annotations in the given file.
uint8_t PointerKind
Which kind of pointer declarator we saw.
A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e....
Holds information about the various types of exception specification.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
unsigned AArch64SMEAttributes
SourceLocation EllipsisLoc
FunctionEffectsRef FunctionEffects
const ExtParameterInfo * ExtParameterInfos
RefQualifierKind RefQualifier
unsigned HasTrailingReturn
void setArmSMEAttribute(AArch64SMETypeAttributes Kind, bool Enable=true)
FunctionType::ExtInfo ExtInfo
TypeSourceInfo * ContainedTyInfo
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.
llvm::DenseSet< std::tuple< Decl *, Decl *, int > > NonEquivalentDeclSet
Store declaration pairs already found to be non-equivalent.
bool IsEquivalent(Decl *D1, Decl *D2)
Determine whether the two declarations are structurally equivalent.
Information about a template-id annotation token.
const IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
unsigned NumArgs
NumArgs - The number of template arguments.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
SourceLocation TemplateKWLoc
TemplateKWLoc - The location of the template keyword.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.