RetroSearch Browse

.getKind()) {

85 case

ParsedAttr::AT_ObjCGC:

88 case

ParsedAttr::AT_ObjCOwnership:

94

useExpansionLoc =

false

;

99

StringRef name =

.getAttrName()->getName();

104 if

(useExpansionLoc && loc.

isMacroID

() && II) {

105 if

(II->

(

"strong"

)) {

107

}

else if

(II->

(

"weak"

)) {

112

(loc,

.isRegularKeywordAttribute()

113

? diag::err_type_attribute_wrong_type

114

: diag::warn_type_attribute_wrong_type)

115

<< name << WhichType <<

;

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(&

);

279 for

(

auto

: ignoredTypeAttrs)

289

AttrsForTypes.push_back({cast<AttributedType>(

.getTypePtr()), A});

290

AttrsForTypesSorted =

false

;

295 QualType

getBTFTagAttributedType(

const

BTFTypeTagAttr *BTFAttr,

307 auto

*NewAttrTy = cast<AttributedType>(

.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] =

;

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

(

.getKind() == ParsedAttr::AT_ObjCGC)

415

assert(

.getKind() == ParsedAttr::AT_ObjCOwnership);

430 bool

onlyBlockPointers) {

436 for

(; i != 0; --i) {

438 switch

(fnChunk.

) {

454 for

(--i; i != 0; --i) {

456 switch

(ptrChunk.

) {

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.

) {

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.

) {

576

considerDeclSpec =

false

;

584 if

(considerDeclSpec) {

589

state.saveDeclSpecAttrs();

598 if

(innermost != -1U) {

606

state.addIgnoredTypeAttr(

);

615 Declarator

&declarator = state.getDeclarator();

619 for

(

unsigned

i = state.getCurrentChunkIndex(); i != 0; --i) {

621 switch

(chunk.

) {

648 Declarator

&declarator = state.getDeclarator();

668

state.saveDeclSpecAttrs();

672

state,

, state.getCurrentAttributes(), declSpecType, CFT))

677

state.addIgnoredTypeAttr(

);

688 Declarator

&declarator = state.getDeclarator();

698

state.addIgnoredTypeAttr(

);

723 if

(

.isStandardAttributeSyntax() ||

.isRegularKeywordAttribute())

726 switch

(

.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

(Qual.second, DiagID)

832

TypeQuals &= ~Qual.first;

846 if

(AL.isInvalid() || !AL.isTypeAttr())

848

(AL.getLoc(),

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();

909

Result = Context.

VoidTy

;

913

Result = Context.

CharTy

;

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

(DeclLoc, diag::warn_missing_type_specifier)

988

(DeclLoc, diag::err_missing_type_specifier)

997

(DeclLoc, diag::err_missing_actual_pipe_type)

1002 "implicit int is disabled?"

);

1003

(DeclLoc, diag::ext_missing_type_specifier)

1013 case

TypeSpecifierWidth::Unspecified:

1014

Result = Context.

;

1016 case

TypeSpecifierWidth::Short:

1019 case

TypeSpecifierWidth::Long:

1020

Result = Context.

LongTy

;

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.

;

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" 1184

Result = Context.

BoolTy

;

1190

Result = Context.

;

1201

Result = Context.

;

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(

"Didn't get an expression for typeof?"

);

1258

? TypeOfKind::Unqualified

1259

: TypeOfKind::Qualified);

1260 if

(Result.isNull()) {

1261

Result = Context.

;

1268

assert(

"Didn't get an expression for decltype?"

);

1271 if

(Result.isNull()) {

1272

Result = Context.

;

1279

assert(

"Didn't get an expression for pack indexing"

);

1283 if

(Result.isNull()) {

1285

Result = Context.

;

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.

;

1306

? AutoTypeKeyword::DecltypeAuto

1307

: AutoTypeKeyword::Auto;

1313

TypeConstraintConcept =

1314

cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl());

1316

TemplateArgsInfo.

setLAngleLoc

(TemplateId->LAngleLoc);

1317

TemplateArgsInfo.

setRAngleLoc

(TemplateId->RAngleLoc);

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.

;

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.

;

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

(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"

);

1570 return "type name"

;

1577 const auto

*AT = dyn_cast<AutoType>(

);

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

->isObjCLifetimeType() ||

1694 if

(

.isConstQualified()) {

1700

}

else if

(

->isObjCARCImplicitlyUnretainedType()) {

1718

diag::err_arc_indirect_no_ownership,

, isReference));

1720

(loc, diag::err_arc_indirect_no_ownership) <<

<< isReference;

1724

assert(implicitLifetime &&

"didn't infer any lifetime!"

);

1765enum

QualifiedFunctionKind { QFK_BlockPointer, QFK_Pointer, QFK_Reference };

1771

QualifiedFunctionKind QFK) {

1778

(

, diag::err_compound_qualified_function_type)

1779

<< QFK << isa<FunctionType>(

.IgnoreParens()) <<

T 1790 Diag

(

, diag::err_qualified_function_typeid)

1809 Diag

(

, diag::err_illegal_decl_pointer_to_reference)

1817 Diag

(

, diag::err_opencl_function_pointer) <<

1822 Diag

(

, diag::err_hlsl_pointers_unsupported) << 0;

1841 if

(

getASTContext

().getTargetInfo().getTriple().isWasm()) {

1842 if

(

.isWebAssemblyReferenceType()) {

1843 Diag

(

, diag::err_wasm_reference_pr) << 0;

1849 Diag

(

, diag::err_wasm_table_pr) << 0;

1862 "Unresolved overloaded function type"

);

1890 Diag

(

, diag::err_reference_to_void);

1895 Diag

(

, diag::err_hlsl_pointers_unsupported) << 1;

1905 Diag

(

, diag::err_opencl_function_pointer) <<

1917 if

(

getASTContext

().getTargetInfo().getTriple().isWasm() &&

1918 T

.isWebAssemblyReferenceType()) {

1919 Diag

(

, diag::err_wasm_reference_pr) << 1;

1923 Diag

(

, diag::err_wasm_table_pr) << 1;

1946

llvm::APSInt Bits(32);

1953 size_t

NumBits = Bits.getZExtValue();

1954 if

(!IsUnsigned && NumBits < 2) {

1955 Diag

(

, diag::err_bit_int_bad_size) << 0;

1959 if

(IsUnsigned && NumBits < 1) {

1960 Diag

(

, diag::err_bit_int_bad_size) << 1;

1966 Diag

(

, diag::err_bit_int_max_size)

1980

llvm::APSInt &SizeVal,

unsigned

VLADiag,

2003 bool

IsVLA =

false

;

2005

VLADiagnoser(

unsigned

VLADiag,

bool

VLAIsError)

2006

: VLADiag(VLADiag), VLAIsError(VLAIsError) {}

2010 return

(

, diag::err_array_size_non_int) <<

;

2015

IsVLA = !VLAIsError;

2016 return

(

, VLADiag);

2021 return

(

, diag::ext_vla_folded_to_constant);

2023

} Diagnoser(VLADiag, VLAIsError);

2027 if

(Diagnoser.IsVLA)

2041 if

(Size.isMultipleOf(Alignment))

2044 Diag

(

, diag::err_array_element_alignment)

2045

<< EltTy << Size.getQuantity() << Alignment.

getQuantity

();

2050 Expr

*ArraySize,

unsigned

Quals,

2067 Diag

(

, diag::err_illegal_decl_array_of_references)

2073 Diag

(

, diag::err_array_incomplete_or_sizeless_type) << 0 <<

;

2078

diag::err_array_of_abstract_type))

2085 if

(!MPTy->getClass()->isDependentType())

2091 if

.isWebAssemblyReferenceType() &&

2093

diag::err_array_incomplete_or_sizeless_type))

2099 const auto

*ATy = dyn_cast<ArrayType>(

);

2100 if

(ATy && ATy->getElementType().isWebAssemblyReferenceType()) {

2101 Diag

(

, diag::err_wasm_reftype_multidimensional_array);

2107 Diag

(

, diag::err_array_incomplete_or_sizeless_type) << 1 <<

;

2112 Diag

(

, diag::err_illegal_decl_array_of_functions)

2120 if

(EltTy->getDecl()->hasFlexibleArrayMember())

2121 Diag

(

, diag::ext_flexible_array_in_array) <<

;

2123 Diag

(

, diag::err_objc_array_of_interfaces) <<

;

2134

ArraySize =

.get();

2138 if

(ArraySize && !ArraySize->

isPRValue

()) {

2140 if

(

.isInvalid())

2143

ArraySize =

.get();

2166 if

(

const auto

*CondExpr = dyn_cast_if_present<ConditionalOperator>(

2168

std::optional<llvm::APSInt> LHS =

2169

CondExpr->getLHS()->getIntegerConstantExpr(

);

2170

std::optional<llvm::APSInt> RHS =

2171

CondExpr->getRHS()->getIntegerConstantExpr(

);

2172 return

LHS && RHS && LHS->isNegative() != RHS->isNegative();

2182

VLADiag = diag::err_opencl_vla;

2185

VLADiag = diag::warn_vla_used;

2186

VLAIsError =

false

;

2188

VLADiag = diag::err_vla_in_sfinae;

2191

VLADiag = diag::err_openmp_vla_in_task_untied;

2196

? diag::ext_vla_cxx_in_gnu_mode_static_assert

2197

: diag::ext_vla_cxx_static_assert;

2199

VLADiag =

().GNUMode ? diag::ext_vla_cxx_in_gnu_mode

2200

: diag::ext_vla_cxx;

2201

VLAIsError =

false

;

2203

VLADiag = diag::ext_vla;

2204

VLAIsError =

false

;

2222 checkArraySize

this

, ArraySize, ConstVal, VLADiag, VLAIsError);

2244 if

(ConstVal.isSigned() && ConstVal.isNegative()) {

2251

diag::err_typecheck_negative_array_size)

2255 if

(ConstVal == 0 && !

.isWebAssemblyReferenceType()) {

2260

: diag::ext_typecheck_zero_array_size)

2265 unsigned

ActiveSizeBits =

2269

: ConstVal.getActiveBits();

2285

IsCUDADevice ? diag::err_cuda_vla : diag::err_vla_unsupported)

2286

<< (IsCUDADevice ? llvm::to_underlying(

CUDA

().CurrentTarget()) : 0);

2290

FSI->setHasVLA(

);

2298

: diag::ext_c99_array_usage)

2299

<< llvm::to_underlying(ASM);

2309 Diag

(

, diag::err_opencl_invalid_type_array) << ArrType;

2319 bool

ForMatrixType =

false

) {

2322 if

(!llvm::isPowerOf2_32(NumBits) || NumBits < 8)

2323 return

(AttrLoc, diag::err_attribute_invalid_bitint_vector_type)

2324

<< ForMatrixType << (NumBits < 8);

2337 Diag

(AttrLoc, diag::err_attribute_invalid_vector_type) << CurType;

2349

std::optional<llvm::APSInt> VecSize =

2352 Diag

(AttrLoc, diag::err_attribute_argument_type)

2363 if

(!VecSize->isIntN(61)) {

2365 Diag

(AttrLoc, diag::err_attribute_size_too_large)

2369

uint64_t VectorSizeBits = VecSize->getZExtValue() * 8;

2372 if

(VectorSizeBits == 0) {

2373 Diag

(AttrLoc, diag::err_attribute_zero_size)

2378 if

(!TypeSize || VectorSizeBits % TypeSize) {

2379 Diag

(AttrLoc, diag::err_attribute_invalid_size)

2384 if

(VectorSizeBits / TypeSize > std::numeric_limits<uint32_t>::max()) {

2385 Diag

(AttrLoc, diag::err_attribute_size_too_large)

2409 Diag

(AttrLoc, diag::err_attribute_invalid_vector_type) <<

;

2418

std::optional<llvm::APSInt> vecSize =

2421 Diag

(AttrLoc, diag::err_attribute_argument_type)

2427 if

(!vecSize->isIntN(32)) {

2428 Diag

(AttrLoc, diag::err_attribute_size_too_large)

2434 unsigned

vectorSize =

static_cast<unsigned>

(vecSize->getZExtValue());

2436 if

(vectorSize == 0) {

2437 Diag

(AttrLoc, diag::err_attribute_zero_size)

2451 "Should never build a matrix type when it is disabled"

);

2456 Diag

(AttrLoc, diag::err_attribute_invalid_matrix_type) << ElementTy;

2470

std::optional<llvm::APSInt> ValueRows =

2472

std::optional<llvm::APSInt> ValueColumns =

2479 if

(!ValueRows && !ValueColumns) {

2480 Diag

(AttrLoc, diag::err_attribute_argument_type)

2488 Diag

(AttrLoc, diag::err_attribute_argument_type)

2494 if

(!ValueColumns) {

2495 Diag

(AttrLoc, diag::err_attribute_argument_type)

2501 unsigned

MatrixRows =

static_cast<unsigned>

(ValueRows->getZExtValue());

2502 unsigned

MatrixColumns =

static_cast<unsigned>

(ValueColumns->getZExtValue());

2503 if

(MatrixRows == 0 && MatrixColumns == 0) {

2504 Diag

(AttrLoc, diag::err_attribute_zero_size)

2505

"matrix"

<< RowRange << ColRange;

2508 if

(MatrixRows == 0) {

2509 Diag

(AttrLoc, diag::err_attribute_zero_size) <<

"matrix"

<< RowRange;

2512 if

(MatrixColumns == 0) {

2513 Diag

(AttrLoc, diag::err_attribute_zero_size) <<

"matrix"

<< ColRange;

2517 Diag

(AttrLoc, diag::err_attribute_size_too_large)

2518

<< RowRange <<

"matrix row"

;

2522 Diag

(AttrLoc, diag::err_attribute_size_too_large)

2523

<< ColRange <<

"matrix column"

;

2531 Diag

(

, diag::err_func_returning_array_function)

2539 Diag

(

, diag::err_parameters_retval_cannot_have_fp16_type) << 1 <<

2547 Diag

(

, diag::err_object_cannot_be_passed_returned_by_value)

2552 if

(

.hasNonTrivialToPrimitiveDestructCUnion() ||

2553 T

.hasNonTrivialToPrimitiveCopyCUnion())

2560 Diag

(

, diag::warn_deprecated_volatile_return) <<

;

2575 bool

emittedError =

false

;

2577 enum class

RequiredCC { OnlySwift, SwiftOrSwiftAsync };

2578 auto

checkCompatible = [&](

unsigned

paramIndex, RequiredCC required) {

2580

(required == RequiredCC::OnlySwift)

2583 if

(isCompatible || emittedError)

2585

(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall)

2587

<< (required == RequiredCC::OnlySwift);

2588

emittedError =

true

;

2590 for

(

size_t

paramIndex = 0, numParams = paramTypes.size();

2591

paramIndex != numParams; ++paramIndex) {

2602

checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);

2603 if

(paramIndex != 0 &&

2606

(getParamLoc(paramIndex),

2607

diag::err_swift_indirect_result_not_first);

2612

checkCompatible(paramIndex, RequiredCC::SwiftOrSwiftAsync);

2621

checkCompatible(paramIndex, RequiredCC::OnlySwift);

2622 if

(paramIndex == 0 ||

2625

(getParamLoc(paramIndex),

2626

diag::err_swift_error_result_not_after_swift_context);

2630

llvm_unreachable(

"bad ABI kind"

);

2642 for

(

unsigned

Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) {

2646 Diag

(

, diag::err_param_with_void_type);

2651 Diag

(

, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<

2655 Diag

(

, diag::err_wasm_table_as_function_parameter);

2662 Diag

(

, diag::warn_deprecated_volatile_param) << ParamType;

2664

ParamTypes[Idx] = ParamType;

2669

[=](

unsigned

i) {

return Loc

; });

2689 Diag

(

, diag::err_distant_exception_spec);

2696 Diag

(

, diag::err_illegal_decl_mempointer_to_reference)

2702 Diag

(

, diag::err_illegal_decl_mempointer_to_void)

2707 if

->isDependentType() && !

->isRecordType()) {

2708 Diag

(

, diag::err_mempointer_in_nonclass_type) <<

;

2715 Diag

(

, diag::err_opencl_function_pointer) <<

2720 Diag

(

, diag::err_hlsl_pointers_unsupported) << 0;

2739 Diag

(

, diag::err_nonfunction_block_type);

2755 if

(TInfo) *TInfo =

nullptr

;

2760 if

(

const LocInfoType

*LIT = dyn_cast<LocInfoType>(QT)) {

2761

QT = LIT->getType();

2762

DI = LIT->getTypeSourceInfo();

2765 if

(TInfo) *TInfo = DI;

2771 unsigned

chunkIndex);

2778 Sema

&S = state.getSema();

2779 Declarator

&declarator = state.getDeclarator();

2785 unsigned

outermostPointerIndex = 0;

2787 unsigned

numPointers = 0;

2789 unsigned

chunkIndex = i;

2791 switch

(chunk.

) {

2801

outermostPointerIndex = chunkIndex;

2809 if

(numPointers != 1)

return

;

2811

outermostPointerIndex = chunkIndex;

2829 if

(numPointers == 1) {

2847

}

else if

(numPointers == 2) {

2860 if

(AL.getKind() == ParsedAttr::AT_ObjCOwnership)

2864

outermostPointerIndex);

2886

}

const

QualKinds[5] = {

2895 unsigned

NumQuals = 0;

2900 for

(

auto

: QualKinds) {

2901 if

(Quals &

.Mask) {

2902 if

(!QualStr.empty()) QualStr +=

' '

;

2919

<< QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];

2925 unsigned

FunctionChunkIndex) {

2927 D

.getTypeObject(FunctionChunkIndex).Fun;

2935 for

(

unsigned

OuterChunkIndex = FunctionChunkIndex + 1,

2936

End =

.getNumTypeObjects();

2937

OuterChunkIndex != End; ++OuterChunkIndex) {

2939 switch

(OuterChunk.

) {

2946

diag::warn_qual_return_type,

2968 D

.getIdentifierLoc());

2972

llvm_unreachable(

"unknown declarator chunk kind"

);

2984 D

.getDeclSpec().getTypeQualifiers(),

2985 D

.getIdentifierLoc(),

2986 D

.getDeclSpec().getConstSpecLoc(),

2987 D

.getDeclSpec().getVolatileSpecLoc(),

2988 D

.getDeclSpec().getRestrictSpecLoc(),

2989 D

.getDeclSpec().getAtomicSpecLoc(),

2990 D

.getDeclSpec().getUnalignedSpecLoc());

2993static

std::pair<QualType, TypeSourceInfo *>

2997 Sema

&S = state.getSema();

3001 const unsigned

AutoParameterPosition = Info.

TemplateParams

.size();

3002 const bool

IsParameterPack =

.hasEllipsis();

3013 D

.getDeclSpec().getTypeSpecTypeLoc(),

3014 D

.getIdentifierLoc(),

3015

TemplateParameterDepth, AutoParameterPosition,

3017 D

.getIdentifier(), AutoParameterPosition),

false

3018

IsParameterPack,

->isConstrained());

3023 if

(

->isConstrained()) {

3030 for

(

unsigned

Idx = 0; Idx < AutoLoc.

getNumArgs

(); ++Idx) {

3031 if

(

.getEllipsisLoc().isInvalid() && !

Invalid

3043

InventedTemplateParam,

3045 D

.getEllipsisLoc());

3059 if

(

.getEllipsisLoc().isInvalid()) {

3075 D

.getDeclSpec().getTypeSpecScope().getWithLocInContext(S.

3080

USD ? cast<NamedDecl>(USD) : CD,

3082

InventedTemplateParam,

3084 D

.getEllipsisLoc());

3094 QualType

NewT = state.ReplaceAutoType(

, Replacement);

3098 return

{NewT, NewTSI};

3107 Sema

&SemaRef = state.getSema();

3110

ReturnTypeInfo =

nullptr

;

3113 TagDecl

*OwnedTagDecl =

nullptr

;

3115 switch

(

.getName().

()) {

3123 if

.isInvalidType() &&

.getDeclSpec().isTypeSpecOwned()) {

3124

OwnedTagDecl = cast<TagDecl>(

.getDeclSpec().getRepAsDecl());

3137 D

.getMutableDeclSpec().getAttributes());

3164 bool

DeducedIsTrailingReturnType =

false

;

3165 if

(Deduced && isa<AutoType>(Deduced) &&

.hasTrailingReturnType()) {

3168

DeducedIsTrailingReturnType =

true

;

3178 bool

IsCXXAutoType =

3180 bool

IsDeducedReturnType =

false

;

3182 switch

(

.getContext()) {

3221

assert(Info &&

"No LambdaScopeInfo on the stack!"

);

3227 if

(!DeducedIsTrailingReturnType)

3232 if

(

.isStaticMember() ||

.isFunctionDeclarator())

3235 if

(isa<ObjCContainerDecl>(SemaRef.

CurContext

)) {

3238 switch

(cast<TagDecl>(SemaRef.

CurContext

)->getTagKind()) {

3240

llvm_unreachable(

"unhandled tag kind"

);

3242

Error = Cxx ? 1 : 2;

3245

Error = Cxx ? 3 : 4;

3255 if

(

.getDeclSpec().isFriendSpecified())

3264 if

(isa<DeducedTemplateSpecializationType>(Deduced) &&

3276 if

(isa<DeducedTemplateSpecializationType>(Deduced) &&

3277

.getNumTypeObjects() &&

3290 if

(!SemaRef.

().CPlusPlus14 || !IsCXXAutoType)

3292

IsDeducedReturnType =

true

;

3295 if

(!SemaRef.

().CPlusPlus14 || !IsCXXAutoType)

3297

IsDeducedReturnType =

true

;

3300 if

(isa<DeducedTemplateSpecializationType>(Deduced))

3302 if

(SemaRef.

().CPlusPlus23 && IsCXXAutoType &&

3303

->isDecltypeAuto())

3322 if

(!IsCXXAutoType && !isa<DeducedTemplateSpecializationType>(Deduced))

3335 if

(

.isFunctionDeclarator() &&

3336

(!SemaRef.

().CPlusPlus11 || !IsCXXAutoType))

3339 SourceRange

AutoRange =

.getDeclSpec().getTypeSpecTypeLoc();

3346 switch

(

->getKeyword()) {

3352

assert(isa<DeducedTemplateSpecializationType>(Deduced) &&

3353 "unknown auto type"

);

3357 auto

*DTST = dyn_cast<DeducedTemplateSpecializationType>(Deduced);

3360

SemaRef.

(AutoRange.

getBegin

(), diag::err_auto_not_allowed)

3362

QualType

(Deduced, 0) << AutoRange;

3367 D

.setInvalidType(

true

);

3373

? diag::warn_cxx11_compat_generic_lambda

3374

: IsDeducedReturnType

3375

? diag::warn_cxx11_compat_deduced_return_type

3376

: diag::warn_cxx98_compat_auto_type_specifier)

3385 unsigned

DiagID = 0;

3386 switch

(

.getContext()) {

3391

llvm_unreachable(

"parser should not have allowed this"

);

3407

DiagID = diag::err_type_defined_in_alias_template;

3419

DiagID = diag::err_type_defined_in_type_specifier;

3429

DiagID = diag::err_type_defined_in_param_type;

3435

DiagID = diag::err_type_defined_in_condition;

3442 D

.setInvalidType(

true

);

3446

assert(!

.isNull() &&

"This function should not return a null type"

);

3455

assert(FTI.

isAmbiguous

"no direct-initializer / function ambiguity"

);

3471 if

.isFunctionDeclarator() ||

3485

FTI.

NumParams

? diag::warn_parens_disambiguated_as_function_declaration

3486

: diag::warn_empty_parens_are_function_decl)

3494 if

.isFirstDeclarator() &&

.getIdentifier()) {

3497 if

(Comma.getFileID() != Name.getFileID() ||

3498

Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) {

3502

(

.getCommaLoc(), diag::note_empty_parens_function_call)

3504

.getIdentifier();

3505 Result

.suppressDiagnostics();

3518

(B, diag::note_additional_parens_for_variable_declaration)

3533

(DeclType.

, diag::note_empty_parens_default_ctor)

3540 if

Init

.empty())

3541

(DeclType.

, diag::note_empty_parens_zero_initialize)

3552 "do not have redundant top-level parentheses"

);

3561 bool

CouldBeTemporaryObject =

3562

().CPlusPlus &&

.isExpressionContext() &&

3563

.isInvalidType() &&

.getIdentifier() &&

3566 D

.getDeclSpec().getTypeQualifiers() == 0 &&

.isFirstDeclarator();

3568 bool

StartsWithDeclaratorId =

true

;

3569 for

(

auto

.type_objects()) {

3576

StartsWithDeclaratorId =

false

;

3580 if

.Arr.NumElts)

3581

CouldBeTemporaryObject =

false

;

3589

CouldBeTemporaryObject =

false

;

3590

StartsWithDeclaratorId =

false

;

3600

CouldBeTemporaryObject =

false

;

3607

CouldBeTemporaryObject =

false

;

3608

StartsWithDeclaratorId =

false

;

3618 if

(CouldBeTemporaryObject) {

3622

CouldBeTemporaryObject =

false

;

3623 Result

.suppressDiagnostics();

3628 if

(!CouldBeTemporaryObject) {

3633 if

(StartsWithDeclaratorId &&

.getCXXScopeSpec().isValid()) {

3635

NNS = NNS->getPrefix()) {

3641

(

.Loc, diag::warn_redundant_parens_around_declarator)

3647

(

.Loc, diag::warn_parens_disambiguated_as_variable_declaration)

3648

<< ParenRange <<

.getIdentifier();

3650 if

(!RD || !RD->hasDefinition() || RD->hasNonTrivialDestructor())

3651

(

.Loc, diag::note_raii_guard_add_name)

3653

.getIdentifier();

3656

(

getBeginLoc

(), diag::note_function_style_cast_add_parentheses)

3659

(

.Loc, diag::note_remove_parens_for_variable_declaration)

3675 switch

(AL.getKind()) {

3694 bool

IsCXXInstanceMethod =

false

;

3700 unsigned

I = ChunkIndex;

3701 bool

FoundNonParen =

false

;

3702 while

(I && !FoundNonParen) {

3705

FoundNonParen =

true

;

3708 if

(FoundNonParen) {

3711

IsCXXInstanceMethod =

3716

IsCXXInstanceMethod =

3720

assert(

.isFunctionDeclarator());

3724

IsCXXInstanceMethod =

3725 D

.isFirstDeclarationOfMember() &&

3727

.isStaticMember();

3732

IsCXXInstanceMethod);

3739 for

(

const ParsedAttr

&AL :

.getDeclSpec().getAttributes()) {

3740 if

(AL.getKind() == ParsedAttr::AT_OpenCLKernel) {

3751 if

(Triple.isSPIRV() && Triple.getVendor() != llvm::Triple::AMD) {

3752 for

(

const ParsedAttr

&AL :

.getDeclSpec().getAttributes()) {

3753 if

(AL.getKind() == ParsedAttr::AT_CUDAGlobal) {

3767 enum class

SimplePointerKind {

3776 switch

(nullability) {

3778 if

(!Ident__Nonnull)

3780 return

Ident__Nonnull;

3783 if

(!Ident__Nullable)

3785 return

Ident__Nullable;

3788 if

(!Ident__Nullable_result)

3790 return

Ident__Nullable_result;

3793 if

(!Ident__Null_unspecified)

3795 return

Ident__Null_unspecified;

3797

llvm_unreachable(

"Unknown nullability kind."

);

3804 if

(AL.getKind() == ParsedAttr::AT_TypeNonNull ||

3805

AL.getKind() == ParsedAttr::AT_TypeNullable ||

3806

AL.getKind() == ParsedAttr::AT_TypeNullableResult ||

3807

AL.getKind() == ParsedAttr::AT_TypeNullUnspecified)

3816 enum class

PointerDeclaratorKind {

3824

MaybePointerToCFRef,

3828

NSErrorPointerPointer,

3834 enum class

PointerWrappingDeclaratorKind {

3848static

PointerDeclaratorKind

3850

PointerWrappingDeclaratorKind &wrappingKind) {

3851 unsigned

numNormalPointers = 0;

3854 if

(

->isDependentType())

3855 return

PointerDeclaratorKind::NonPointer;

3860 switch

(chunk.

) {

3862 if

(numNormalPointers == 0)

3863

wrappingKind = PointerWrappingDeclaratorKind::Array;

3872 return

numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer

3873

: PointerDeclaratorKind::SingleLevelPointer;

3879 if

(numNormalPointers == 0)

3880

wrappingKind = PointerWrappingDeclaratorKind::Reference;

3884

++numNormalPointers;

3885 if

(numNormalPointers > 2)

3886 return

PointerDeclaratorKind::MultiLevelPointer;

3892 unsigned

numTypeSpecifierPointers = 0;

3896

++numNormalPointers;

3898 if

(numNormalPointers > 2)

3899 return

PointerDeclaratorKind::MultiLevelPointer;

3901 type

= ptrType->getPointeeType();

3902

++numTypeSpecifierPointers;

3908 return

numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer

3909

: PointerDeclaratorKind::SingleLevelPointer;

3914 return

numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer

3915

: PointerDeclaratorKind::SingleLevelPointer;

3920

++numNormalPointers;

3921

++numTypeSpecifierPointers;

3924 if

(

auto

objcClassDecl = objcObjectPtr->getInterfaceDecl()) {

3926

numNormalPointers == 2 && numTypeSpecifierPointers < 2) {

3927 return

PointerDeclaratorKind::NSErrorPointerPointer;

3936 if

(objcClass->getInterface()->getIdentifier() ==

3938 if

(numNormalPointers == 2 && numTypeSpecifierPointers < 2)

3939 return

PointerDeclaratorKind::NSErrorPointerPointer;

3946 if

(numNormalPointers == 0)

3947 return

PointerDeclaratorKind::NonPointer;

3953 if

(numNormalPointers == 2 && numTypeSpecifierPointers < 2 &&

3955 return

PointerDeclaratorKind::CFErrorRefPointer;

3963 switch

(numNormalPointers) {

3965 return

PointerDeclaratorKind::NonPointer;

3968 return

PointerDeclaratorKind::SingleLevelPointer;

3971 return

PointerDeclaratorKind::MaybePointerToCFRef;

3974 return

PointerDeclaratorKind::MultiLevelPointer;

3983 if

(ctx->isFunctionOrMethod())

3986 if

(ctx->isFileContext())

3997 bool

invalid =

false

;

3999 if

(invalid || !sloc.

isFile

())

4017template

typename

DiagBuilderT>

4021

assert(PointerLoc.

());

4026 if

(!FixItLoc.

() || FixItLoc == PointerLoc)

4035

InsertionTextBuf +=

" "

;

4036

StringRef InsertionText = InsertionTextBuf.str();

4039

InsertionText = InsertionText.drop_back();

4040

}

else if

(NextChar[-1] ==

'['

) {

4041 if

(NextChar[0] ==

']'

)

4042

InsertionText = InsertionText.drop_back().drop_front();

4044

InsertionText = InsertionText.drop_front();

4047

InsertionText = InsertionText.drop_back().drop_front();

4054

SimplePointerKind PointerKind,

4057

assert(PointerLoc.

());

4059 if

(PointerKind == SimplePointerKind::Array) {

4060

(PointerLoc, diag::warn_nullability_missing_array);

4062

(PointerLoc, diag::warn_nullability_missing)

4063

static_cast<unsigned>

(PointerKind);

4066 auto

FixItLoc = PointerEndLoc.

() ? PointerEndLoc : PointerLoc;

4067 if

(FixItLoc.isMacroID())

4071 auto Diag

= S.

(FixItLoc, diag::note_nullability_fix_it);

4072

Diag << static_cast<unsigned>(Nullability);

4073

Diag << static_cast<unsigned>(PointerKind);

4102 if

(pointerKind == SimplePointerKind::Array)

4103

diagKind = diag::warn_nullability_missing_array;

4105

diagKind = diag::warn_nullability_missing;

4111

fileNullability.

PointerKind

static_cast<unsigned>

(pointerKind);

4143 auto

kind =

static_cast<

SimplePointerKind

>

(fileNullability.

PointerKind

);

4158 unsigned

i = endIndex;

4163 switch

(DC.

) {

4186template

typename

AttrT>

4189

return ::new (Ctx) AttrT(Ctx, AL);

4196 return

createSimpleAttr<TypeNonNullAttr>(Ctx,

);

4199 return

createSimpleAttr<TypeNullableAttr>(Ctx,

);

4202 return

createSimpleAttr<TypeNullableResultAttr>(Ctx,

);

4205 return

createSimpleAttr<TypeNullUnspecifiedAttr>(Ctx,

);

4207

llvm_unreachable(

"unknown NullabilityKind"

);

4218 if

(ASOld != ASNew) {

4219

(AttrLoc, diag::err_attribute_address_multiple_qualifiers);

4224

diag::warn_attribute_address_multiple_identical_qualifiers);

4238

!isa<RecordType, TemplateSpecializationType>(

4249 Sema

&S = state.getSema();

4255 if

(

.getIdentifier())

4256

Name =

.getIdentifier();

4259 bool

IsTypedefName =

4275 bool

IsClassTemplateDeduction = isa<DeducedTemplateSpecializationType>(DT);

4276 if

((AT && AT->

isDecltypeAuto

()) || IsClassTemplateDeduction) {

4277 for

(

unsigned

I = 0,

.getNumTypeObjects(); I !=

; ++I) {

4278 unsigned

Index =

- I - 1;

4280 unsigned

DiagId = IsClassTemplateDeduction

4281

? diag::err_deduced_class_template_compound_type

4282

: diag::err_decltype_auto_compound_type;

4283 unsigned

DiagKind = 0;

4284 switch

(DeclChunk.

) {

4287 if

(IsClassTemplateDeduction) {

4293 if

(IsClassTemplateDeduction) {

4298 if

(

.isFunctionDeclarationContext() &&

4299 D

.isFunctionDeclarator(FnIndex) && FnIndex == Index)

4301

DiagId = diag::err_decltype_auto_function_declarator_not_declaration;

4319

(DeclChunk.

, DiagId) << DiagKind;

4320 D

.setInvalidType(

true

);

4327

std::optional<NullabilityKind> inferNullability;

4328 bool

inferNullabilityCS =

false

;

4329 bool

inferNullabilityInnerOnly =

false

;

4330 bool

inferNullabilityInnerOnlyComplete =

false

;

4333 bool

inAssumeNonNullRegion =

false

;

4335 if

(assumeNonNullLoc.

()) {

4336

inAssumeNonNullRegion =

true

;

4350

} complainAboutMissingNullability = CAMN_No;

4351 unsigned

NumPointersRemaining = 0;

4352 auto

complainAboutInferringWithinChunk = PointerWrappingDeclaratorKind::None;

4354 if

(IsTypedefName) {

4358

complainAboutMissingNullability = CAMN_InnerPointers;

4362

++NumPointersRemaining;

4365 for

(

unsigned

i = 0, n =

.getNumTypeObjects(); i != n; ++i) {

4367 switch

(chunk.

) {

4375

++NumPointersRemaining;

4383

++NumPointersRemaining;

4388 bool

isFunctionOrMethod =

false

;

4389 switch

(

auto

context = state.getDeclarator().getContext()) {

4395

isFunctionOrMethod =

true

;

4399 if

(state.getDeclarator().isObjCIvar() && !isFunctionOrMethod) {

4400

complainAboutMissingNullability = CAMN_No;

4405 if

(state.getDeclarator().isObjCWeakProperty()) {

4408

complainAboutMissingNullability = CAMN_No;

4409 if

(inAssumeNonNullRegion) {

4419

complainAboutMissingNullability = CAMN_Yes;

4422 auto

wrappingKind = PointerWrappingDeclaratorKind::None;

4424 case

PointerDeclaratorKind::NonPointer:

4425 case

PointerDeclaratorKind::MultiLevelPointer:

4429 case

PointerDeclaratorKind::SingleLevelPointer:

4431 if

(inAssumeNonNullRegion) {

4432

complainAboutInferringWithinChunk = wrappingKind;

4439 case

PointerDeclaratorKind::CFErrorRefPointer:

4440 case

PointerDeclaratorKind::NSErrorPointerPointer:

4443 if

(isFunctionOrMethod && inAssumeNonNullRegion)

4447 case

PointerDeclaratorKind::MaybePointerToCFRef:

4448 if

(isFunctionOrMethod) {

4452 auto

hasCFReturnsAttr =

4454 return

AttrList.hasAttribute(ParsedAttr::AT_CFReturnsRetained) ||

4455

AttrList.hasAttribute(ParsedAttr::AT_CFReturnsNotRetained);

4457 if

(

const auto

*InnermostChunk =

.getInnermostNonParenChunk()) {

4458 if

(hasCFReturnsAttr(

.getDeclarationAttributes()) ||

4459

hasCFReturnsAttr(

.getAttributes()) ||

4460

hasCFReturnsAttr(InnermostChunk->getAttrs()) ||

4461

hasCFReturnsAttr(

.getDeclSpec().getAttributes())) {

4463

inferNullabilityInnerOnly =

true

;

4473

complainAboutMissingNullability = CAMN_Yes;

4501 auto

isVaList = [&S](

QualType T

) ->

bool

{

4507 if

(typedefTy->getDecl() == vaListTypedef)

4509 if

(

auto

*name = typedefTy->getDecl()->getIdentifier())

4510 if

(name->isStr(

"va_list"

))

4512

typedefTy = typedefTy->desugar()->getAs<

TypedefType

>();

4513

}

while

(typedefTy);

4519 auto

inferPointerNullability =

4524 if

(NumPointersRemaining > 0)

4525

--NumPointersRemaining;

4532 if

(inferNullability && !inferNullabilityInnerOnlyComplete) {

4535

? ParsedAttr::Form::ContextSensitiveKeyword()

4536

: ParsedAttr::Form::Keyword(

false

4542

attrs.addAtEnd(nullabilityAttr);

4544 if

(inferNullabilityCS) {

4545

state.getDeclarator().getMutableDeclSpec().getObjCQualifiers()

4549 if

(pointerLoc.isValid() &&

4550

complainAboutInferringWithinChunk !=

4551

PointerWrappingDeclaratorKind::None) {

4553

(pointerLoc, diag::warn_nullability_inferred_on_nested_type);

4554

Diag << static_cast<int>(complainAboutInferringWithinChunk);

4558 if

(inferNullabilityInnerOnly)

4559

inferNullabilityInnerOnlyComplete =

true

;

4560 return

nullabilityAttr;

4565 switch

(complainAboutMissingNullability) {

4569 case

CAMN_InnerPointers:

4570 if

(NumPointersRemaining == 0)

4584 if

(isVaList(

)) {

4586 if

(NumPointersRemaining > 0)

4587

--NumPointersRemaining;

4589

SimplePointerKind pointerKind = SimplePointerKind::Pointer;

4591

pointerKind = SimplePointerKind::BlockPointer;

4593

pointerKind = SimplePointerKind::MemberPointer;

4595 if

(

auto

= inferPointerNullability(

4596

pointerKind,

.getDeclSpec().getTypeSpecTypeLoc(),

4598 D

.getMutableDeclSpec().getAttributes(),

4599 D

.getMutableDeclSpec().getAttributePool())) {

4600 T

= state.getAttributedType(

4606 if

(complainAboutMissingNullability == CAMN_Yes &&

isArrayType

() &&

4610 D

.getDeclSpec().getTypeSpecTypeLoc());

4614 bool

ExpectNoDerefChunk =

4615

state.getCurrentAttributes().hasAttribute(ParsedAttr::AT_NoDeref);

4625 bool

AreDeclaratorChunksValid =

true

;

4626 for

(

unsigned

i = 0, e =

.getNumTypeObjects(); i != e; ++i) {

4627 unsigned

chunkIndex = e - i - 1;

4628

state.setCurrentChunkIndex(chunkIndex);

4631 switch

(DeclType.

) {

4639 if

(!LangOpts.Blocks)

4640

(DeclType.

, diag::err_blocks_disable) << LangOpts.OpenCL;

4643

inferPointerNullability(SimplePointerKind::BlockPointer, DeclType.

4645

state.getDeclarator().getAttributePool());

4651 if

(LangOpts.OpenCL)

4660

(

.getIdentifierLoc(), diag::err_distant_exception_spec);

4661 D

.setInvalidType(

true

);

4666

inferPointerNullability(SimplePointerKind::Pointer, DeclType.

4668

state.getDeclarator().getAttributePool());

4680 if

(LangOpts.OpenCL) {

4683

(

.getIdentifierLoc(), diag::err_opencl_pointer_to_type) <<

;

4684 D

.setInvalidType(

true

);

4696

(

.getIdentifierLoc(), diag::err_distant_exception_spec);

4697 D

.setInvalidType(

true

);

4710

(

.getIdentifierLoc(), diag::err_distant_exception_spec);

4711 D

.setInvalidType(

true

);

4721 if

(chunkIndex != 0 && !ArraySize &&

4722 D

.getDeclSpec().getAttributes().hasMSPropertyAttr()) {

4740

(DeclType.

, diag::err_array_star_outside_prototype);

4742 D

.setInvalidType(

true

);

4749 if

(!(

.isPrototypeContext() ||

4751

(DeclType.

, diag::err_array_static_outside_prototype)

4753

"type qualifier"

);

4758 D

.setInvalidType(

true

);

4764

(DeclType.

, diag::err_array_static_not_outermost)

4766

"type qualifier"

);

4770 D

.setInvalidType(

true

);

4776 if

(complainAboutMissingNullability == CAMN_Yes &&

4792

IsQualifiedFunction =

4797 if

.isInvalidType()) {

4801 return

SS.isInvalid() ||

4823

? dyn_cast_if_present<ParmVarDecl>(FTI.

Params

[0].

Param

)

4826 bool

IsFunctionDecl =

.getInnermostNonParenChunk() == &DeclType;

4827 if

(

First

->isExplicitObjectParameter() &&

4838

!IsClassType(

.getCXXScopeSpec())) {

4841

diag::err_explicit_object_parameter_nonmember)

4843

First

->getSourceRange();

4846

diag::err_explicit_object_parameter_invalid)

4847

First

->getSourceRange();

4849 D

.setInvalidType();

4850

AreDeclaratorChunksValid =

false

;

4855 if

(

.getDeclSpec().hasAutoTypeSpec() &&

4858

(

.getDeclSpec().getTypeSpecTypeLoc(),

4860

? diag::err_auto_missing_trailing_return

4861

: diag::err_deduced_return_type);

4863 D

.setInvalidType(

true

);

4864

AreDeclaratorChunksValid =

false

;

4866

(

.getDeclSpec().getTypeSpecTypeLoc(),

4867

diag::warn_cxx11_compat_deduced_return_type);

4871 if

(isa<ParenType>(

)) {

4874 D

.setInvalidType(

true

);

4876

AreDeclaratorChunksValid =

false

;

4877

}

else if

(

.getName().

() ==

4881

diag::err_deduction_guide_with_complex_decl)

4883 D

.setInvalidType(

true

);

4885

AreDeclaratorChunksValid =

false

;

4888

(

.hasQualifiers() || !isa<AutoType>(

) ||

4889

cast<AutoType>(

)->getKeyword() !=

4891

cast<AutoType>(

)->isConstrained())) {

4902

(

, diag::err_trailing_return_without_auto) <<

<< SR;

4903 D

.setInvalidType(

true

);

4905

AreDeclaratorChunksValid =

false

;

4911 D

.setInvalidType(

true

);

4921 if

(InventedParamInfo) {

4923

state,

, TInfo,

, *InventedParamInfo);

4937 unsigned

diagID = diag::err_func_returning_array_function;

4940 if

(chunkIndex == 0 &&

4942

diagID = diag::err_block_returning_array_function;

4945 D

.setInvalidType(

true

);

4946

AreDeclaratorChunksValid =

false

;

4955

(

.getIdentifierLoc(), diag::err_opencl_invalid_return)

4957 D

.setInvalidType(

true

);

4959

}

else if

(!S.

().NativeHalfArgsAndReturns &&

4961

(

.getIdentifierLoc(),

4962

diag::err_parameters_retval_cannot_have_fp16_type) << 1;

4963 D

.setInvalidType(

true

);

4967 if

(LangOpts.OpenCL) {

4972

(

.getIdentifierLoc(), diag::err_opencl_invalid_return)

4974 D

.setInvalidType(

true

);

4981 "__cl_clang_variadic_functions"

, S.

()) &&

4982

.getIdentifier() &&

4983

((

.getIdentifier()->getName() ==

"printf"

4985 D

.getIdentifier()->getName().starts_with(

"__"

)))) {

4986

(

.getIdentifierLoc(), diag::err_opencl_variadic_function);

4987 D

.setInvalidType(

true

);

4999

DiagLoc =

.getDeclSpec().getTypeSpecTypeLoc();

5002

(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value)

5014

AreDeclaratorChunksValid =

false

;

5017 D

.setInvalidType(

true

);

5026 D

.getFunctionDefinitionKind() ==

5031

(DeclType.

, diag::err_func_returning_qualified_void) <<

;

5037 if

(

.isVolatileQualified() && S.

().CPlusPlus20)

5038

(DeclType.

, diag::warn_deprecated_volatile_return) <<

;

5044 if

(

.getQualifiers().hasObjCLifetime()) {

5046 if

(chunkIndex + 1 <

.getNumTypeObjects()) {

5049 if

(AL.getKind() == ParsedAttr::AT_ObjCOwnership) {

5050

AttrLoc = AL.getLoc();

5056 for

(

const ParsedAttr

&AL :

.getDeclSpec().getAttributes()) {

5057 if

(AL.getKind() == ParsedAttr::AT_ObjCOwnership) {

5058

AttrLoc = AL.getLoc();

5072

(AttrLoc, diag::warn_arc_lifetime_result_type)

5073

.getQualifiers().getObjCLifetime();

5077 if

(LangOpts.CPlusPlus &&

.getDeclSpec().hasTagDefinition()) {

5080 TagDecl

*Tag = cast<TagDecl>(

.getDeclSpec().getRepAsDecl());

5081

(Tag->getLocation(), diag::err_type_defined_in_result_type)

5089

diag::err_exception_spec_in_typedef)

5115

diag::warn_c17_compat_ellipsis_only_parameter);

5116 else if

.getDeclarationAttributes().hasAttribute(

5117

ParsedAttr::AT_Overloadable) &&

5118

.getAttributes().hasAttribute(

5119

ParsedAttr::AT_Overloadable) &&

5120

.getDeclSpec().getAttributes().hasAttribute(

5121

ParsedAttr::AT_Overloadable))

5129

diag::err_ident_list_in_fn_declaration);

5130 D

.setInvalidType(

true

);

5135

AreDeclaratorChunksValid =

false

;

5158 bool

HasAnyInterestingExtParameterInfos =

false

;

5160 for

(

unsigned

i = 0, e = FTI.

NumParams

; i != e; ++i) {

5163

assert(!ParamTy.

() &&

"Couldn't parse type?"

);

5174

ParamTy = Context.

;

5179

ParamTy = Context.

;

5184

(DeclType.

, diag::err_void_param_qualified);

5190

diag::err_void_explicit_object_param);

5205 D

.setInvalidType();

5208

}

else if

(!S.

().NativeHalfArgsAndReturns &&

5211

diag::err_parameters_retval_cannot_have_fp16_type) << 0;

5212 D

.setInvalidType();

5219 if

(BTy->getKind() == BuiltinType::Float) {

5228 D

.setInvalidType();

5231 if

(LangOpts.ObjCAutoRefCount && Param->

<NSConsumedAttr>()) {

5232

ExtParameterInfos[i] = ExtParameterInfos[i].withIsConsumed(

true

);

5233

HasAnyInterestingExtParameterInfos =

true

;

5237

ExtParameterInfos[i] =

5238

ExtParameterInfos[i].withABI(

->getABI());

5239

HasAnyInterestingExtParameterInfos =

true

;

5242 if

(Param->

<PassObjectSizeAttr>()) {

5243

ExtParameterInfos[i] = ExtParameterInfos[i].withHasPassObjectSize();

5244

HasAnyInterestingExtParameterInfos =

true

;

5247 if

(Param->

<NoEscapeAttr>()) {

5248

ExtParameterInfos[i] = ExtParameterInfos[i].withIsNoEscape(

true

);

5249

HasAnyInterestingExtParameterInfos =

true

;

5252

ParamTys.push_back(ParamTy);

5255 if

(HasAnyInterestingExtParameterInfos) {

5264 Expr

*NoexceptExpr =

nullptr

;

5270

DynamicExceptions.reserve(N);

5271

DynamicExceptionRanges.reserve(N);

5272 for

(

unsigned

I = 0; I != N; ++I) {

5283

DynamicExceptionRanges,

5290 auto

IsClassMember = [&]() {

5291 return

(!state.getDeclarator().getCXXScopeSpec().isEmpty() &&

5292

state.getDeclarator()

5296

state.getDeclarator().getContext() ==

5298

state.getDeclarator().getContext() ==

5302 if

(state.getSema().getLangOpts().OpenCLCPlusPlus && IsClassMember()) {

5311 D

.setInvalidType(

true

);

5332

inferPointerNullability(SimplePointerKind::MemberPointer, DeclType.

5334

state.getDeclarator().getAttributePool());

5338 D

.setInvalidType(

true

);

5353

llvm_unreachable(

"Nested-name-specifier must name a type"

);

5365 if

(isa<DependentTemplateSpecializationType>(NNSType)) {

5368

}

else if

(isa<TemplateSpecializationType, RecordType>(NNSType)) {

5372

NNSPrefix, ClsType);

5378

diag::err_illegal_decl_mempointer_in_nonclass)

5379

<< (

.getIdentifier() ?

.getIdentifier()->getName() :

"type name"

)

5381 D

.setInvalidType(

true

);

5386 D

.getIdentifier());

5388

AreDeclaratorChunksValid =

false

;

5392 D

.setInvalidType(

true

);

5393

AreDeclaratorChunksValid =

false

;

5403 D

.getMutableDeclSpec().getAttributes());

5409 D

.setInvalidType(

true

);

5411

AreDeclaratorChunksValid =

false

;

5420

(DeclType.

, diag::warn_noderef_on_non_pointer_or_array);

5422

ExpectNoDerefChunk = state.didParseNoDeref();

5426 if

(ExpectNoDerefChunk)

5427

(state.getDeclarator().getBeginLoc(),

5428

diag::warn_noderef_on_non_pointer_or_array);

5441 bool

IsBlock =

false

;

5443 switch

(DeclType.Kind) {

5455

(DeclType.Loc, diag::warn_strict_prototypes)

5467

assert(!

.isNull() &&

"T must not be null after this point"

);

5471

assert(FnTy &&

"Why oh why is there not a FunctionProtoType here?"

);

5484

ExplicitObjectMember,

5488

Kind = DeductionGuide;

5489 else if

.getCXXScopeSpec().isSet()) {

5492

.getDeclSpec().isFriendSpecified())

5502 if

(

.isFunctionDeclarator(I)) {

5505 auto

= dyn_cast_or_null<ParmVarDecl>(Chunk.

Fun

Params

Param

);

5506 if

(

->isExplicitObjectParameter())

5507

Kind = ExplicitObjectMember;

5533 if

(IsQualifiedFunction &&

5536

(Kind !=

Member

.isExplicitObjectMemberFunction() ||

5539 D

.isStaticMember())) &&

5545 if

(

.isFunctionDeclarator(I)) {

5558 if

(!RemovalLocs.empty()) {

5559

llvm::sort(RemovalLocs,

5561

RemovalRange =

SourceRange

(RemovalLocs.front(), RemovalLocs.back());

5562 Loc

= RemovalLocs.front();

5566

(

, diag::err_invalid_qualified_function_type)

5567

<< Kind <<

.isFunctionDeclarator() <<

T 5579 for

(

unsigned

i = 0, e =

.getNumTypeObjects(); i != e; ++i) {

5589 for

(

ParsedAttr

&AL :

.getDeclarationAttributes()) {

5590 if

(!AL.slidesFromDeclToDeclSpecLegacyBehavior()) {

5598

state.diagnoseIgnoredTypeAttrs(

);

5609 if

(

.isVolatileQualified() && S.

().CPlusPlus20 &&

5612

(

.getIdentifierLoc(), diag::warn_deprecated_volatile_param) <<

;

5616 if

(

.hasEllipsis()) {

5621 switch

(

.getContext()) {

5636

(

.getEllipsisLoc(),

5637

diag::err_function_parameter_pack_without_parameter_packs)

5657

(

.getEllipsisLoc(),

5658

LangOpts.CPlusPlus11

5659

? diag::warn_cxx98_compat_variadic_templates

5660

: diag::ext_variadic_templates);

5689

(

.getEllipsisLoc(),

5690

diag::err_ellipsis_in_declarator_not_parameter);

5696

assert(!

.isNull() &&

"T must not be null at the end of this function"

);

5697 if

(!AreDeclaratorChunksValid)

5709

TypeProcessingState state(*

this

);

5713 if

(

.isPrototypeContext() &&

().ObjCAutoRefCount)

5732 unsigned

chunkIndex) {

5733 Sema

&S = state.getSema();

5741 const char

*attrStr =

nullptr

;

5742 switch

(ownership) {

5761

&Args, 1, ParsedAttr::Form::GNU());

5770 Sema

&S = state.getSema();

5774 bool

hasIndirection =

false

;

5775 for

(

unsigned

i = 0, e =

.getNumTypeObjects(); i != e; ++i) {

5777 switch

(chunk.

) {

5786

hasIndirection =

true

;

5819

TypeProcessingState state(*

this

);

5834

TypeProcessingState &State) {

5839

TypeProcessingState &State) {

5841

State.getSema().HLSL().TakeLocForHLSLAttribute(TL.

());

5849 if

(AL.getKind() == ParsedAttr::AT_MatrixType) {

5858

llvm_unreachable(

"no matrix_type attribute found at the expected location!"

);

5863 switch

(Chunk.

) {

5868

llvm_unreachable(

"cannot be _Atomic qualified"

);

5886 class

TypeSpecLocFiller :

public TypeLocVisitor

<TypeSpecLocFiller> {

5889

TypeProcessingState &State;

5893

TypeSpecLocFiller(

Sema

&S,

ASTContext

&Context, TypeProcessingState &State,

5895

: SemaRef(S), Context(Context), State(State), DS(DS) {}

5911

State.getExpansionLocForMacroQualifiedType(TL.

()));

6034 void

VisitDependentTemplateSpecializationTypeLoc(

6063 if

(TemplateId->

NumArgs

> 0) {

6075

FoundDecl = cast<NamedDecl>(USD);

6077

FoundDecl = cast_if_present<NamedDecl>(TN.getAsTemplateDecl());

6123 void

VisitTypeLoc(

TypeLoc

TL) {

6129 class

DeclaratorLocFiller :

public TypeLocVisitor

<DeclaratorLocFiller> {

6131

TypeProcessingState &State;

6135

DeclaratorLocFiller(

ASTContext

&Context, TypeProcessingState &State,

6137

: Context(Context), State(State), Chunk(Chunk) {}

6140

llvm_unreachable(

"qualified type locs not expected here!"

);

6143

llvm_unreachable(

"decayed type locs not expected here!"

);

6146

llvm_unreachable(

"array parameter type locs not expected here!"

);

6185

assert(isa<DependentNameType>(ClsTy) &&

"Unexpected TypeLoc"

);

6196 if

(isa<ElaboratedType>(ClsTy)) {

6211

llvm_unreachable(

"Nested-name-specifier must name a type"

);

6243 for

(

unsigned

i = 0, e = TL.

getNumParams

(), tpi = 0; i != e; ++i) {

6282 void

VisitTypeLoc(

TypeLoc

TL) {

6283

llvm_unreachable(

"unsupported TypeLoc kind in declarator!"

);

6292 if

(AL.getKind() == ParsedAttr::AT_AddressSpace) {

6301 "no address_space attribute found at the expected location!"

);

6315 Sema

&S = State.getSema();

6322 if

(isa<PackExpansionType>(

)) {

6327 for

(

unsigned

i = 0, e =

.getNumTypeObjects(); i != e; ++i) {

6330 if

(CurrTL.

getTypeLocClass

() == TypeLoc::IncompleteArray && e != 1 &&

6331 D

.getDeclSpec().getAttributes().hasMSPropertyAttr())

6341 bool

HasDesugaredTypeLoc =

true

;

6342 while

(HasDesugaredTypeLoc) {

6344 case

TypeLoc::MacroQualified: {

6347

State.getExpansionLocForMacroQualifiedType(TL.

()));

6352 case

TypeLoc::Attributed: {

6359 case

TypeLoc::Adjusted:

6360 case

TypeLoc::BTFTagAttributed: {

6365 case

TypeLoc::DependentAddressSpace: {

6373

HasDesugaredTypeLoc =

false

;

6378

DeclaratorLocFiller(S.

, State,

.getTypeObject(i)).Visit(CurrTL);

6384 if

(ReturnTypeInfo) {

6389

TypeSpecLocFiller(S, S.

, State,

.getDeclSpec()).Visit(CurrTL);

6404 "LocInfoType's TypeClass conflicts with an existing Type class"

);

6410

llvm_unreachable(

"LocInfoType leaked into the type system; an opaque TypeTy*" 6411 " was used directly instead of getting the QualType through" 6412 " GetTypeFromParser"

);

6418

assert(

.getIdentifier() ==

nullptr

6419 "Type name should have no identifier!"

);

6423 if

(

.isInvalidType())

6456 const Expr

*AddrSpace,

6459

std::optional<llvm::APSInt> OptAddrSpace =

6461 if

(!OptAddrSpace) {

6462

(AttrLoc, diag::err_attribute_argument_type)

6467

llvm::APSInt &addrSpace = *OptAddrSpace;

6470 if

(addrSpace.isSigned()) {

6471 if

(addrSpace.isNegative()) {

6472

(AttrLoc, diag::err_attribute_address_space_negative)

6476

addrSpace.setIsSigned(

false

);

6479

llvm::APSInt

max

(addrSpace.getBitWidth());

6483 if

(addrSpace >

max

) {

6484

(AttrLoc, diag::err_attribute_address_space_too_high)

6515 Diag

(AttrLoc, diag::err_attribute_address_multiple_qualifiers);

6531

TypeProcessingState &State) {

6532 Sema

&S = State.getSema();

6538 if

.diagnoseLangOpts(S)) {

6544 if

(

.getNumArgs() != 1) {

6545

(

(), diag::err_attribute_wrong_number_arguments)

6552 auto

*StrLiteral = dyn_cast<StringLiteral>(

.getArgAsExpr(0));

6561

StringRef BTFTypeTag = StrLiteral->getString();

6562 Type

= State.getBTFTagAttributedType(

6563

::new (Ctx) BTFTypeTagAttr(Ctx,

, BTFTypeTag),

);

6571

TypeProcessingState &State) {

6572 Sema

&S = State.getSema();

6577

(

(), diag::err_attribute_address_function_type);

6583 if

(

() == ParsedAttr::AT_AddressSpace) {

6586 if

(

.getNumArgs() != 1) {

6593 Expr

*ASArgExpr =

static_cast<Expr

>

(

.getArgAsExpr(0));

6602

::new (Ctx) AddressSpaceAttr(Ctx,

static_cast<unsigned>

(ASIdx));

6614 if

(EquivType.

()) {

6618 T

= State.getAttributedType(ASAttr,

, EquivType);

6620 T

= State.getAttributedType(ASAttr,

);

6631

.asOpenCLLangAS();

6633

ASIdx =

.asHLSLLangAS();

6636

llvm_unreachable(

"Invalid address space"

);

6654 bool

NonObjCPointer =

false

;

6656 if

->isDependentType() && !

->isUndeducedType()) {

6664

NonObjCPointer =

true

;

6665

}

else if

->isObjCRetainableType()) {

6671 if

(state.isProcessingDeclSpec()) {

6679 Sema

&S = state.getSema();

6685 if

.isArgIdent(0)) {

6686

(AttrLoc, diag::err_attribute_argument_type) <<

attr 6694 if

(II->

(

"none"

))

6696 else if

(II->

(

"strong"

))

6698 else if

(II->

(

"weak"

))

6700 else if

(II->

(

"autoreleasing"

))

6703

(AttrLoc, diag::warn_attribute_type_not_supported) <<

<< II;

6720

.getQualifiers().getObjCLifetime()) {

6723

(AttrLoc, diag::err_attr_objc_ownership_redundant)

6730 if

(previousLifetime != lifetime) {

6733 const Type

*prevTy =

nullptr

;

6734 while

(!prevTy || prevTy != underlyingType.

) {

6735

prevTy = underlyingType.

;

6744 if

(NonObjCPointer) {

6745

StringRef name =

.getAttrName()->getName();

6754

(AttrLoc, diag::warn_type_attribute_wrong_type) << name

6771 type

= state.getAttributedType(

6772

createSimpleAttr<ObjCInertUnsafeUnretainedAttr>(S.

6778 if

(!NonObjCPointer)

6784 type

= state.getAttributedType(::new (S.

)

6795

diagnostic,

0));

6797

(loc, diagnostic);

6806 unsigned

diagnostic =

6807

(S.

().ObjCWeakRuntime ? diag::err_arc_weak_disabled

6808

: diag::err_arc_weak_no_runtime);

6811

diagnoseOrDelay(S, AttrLoc, diagnostic,

);

6823 if

(

->isArcWeakrefUnavailable()) {

6824

(AttrLoc, diag::err_arc_unsupported_weak_class);

6825

(ObjT->getInterfaceDecl()->getLocation(),

6826

diag::note_class_declared);

6841 Sema

&S = state.getSema();

6844 if

->isPointerType() &&

6845

->isObjCObjectPointerType() &&

6846

->isBlockPointerType())

6850

(

.getLoc(), diag::err_attribute_multiple_objc_gc);

6856 if

.isArgIdent(0)) {

6857

(

.getLoc(), diag::err_attribute_argument_type)

6863 if

(

.getNumArgs() > 1) {

6864

(

.getLoc(), diag::err_attribute_wrong_number_arguments) <<

attr 6871 if

(II->

(

"weak"

))

6873 else if

(II->

(

"strong"

))

6876

(

.getLoc(), diag::warn_attribute_type_not_supported)

6886 if

(

.getLoc().isValid())

6887 type

= state.getAttributedType(

6904 struct

FunctionTypeUnwrapper {

6923 const Type

*Ty =

.getTypePtr();

6924 if

(isa<FunctionType>(Ty)) {

6925 Fn

= cast<FunctionType>(Ty);

6927

}

else if

(isa<ParenType>(Ty)) {

6928 T

= cast<ParenType>(Ty)->getInnerType();

6929

Stack.push_back(

Parens

);

6930

}

else if

(isa<ConstantArrayType>(Ty) || isa<VariableArrayType>(Ty) ||

6931

isa<IncompleteArrayType>(Ty)) {

6932 T

= cast<ArrayType>(Ty)->getElementType();

6933

Stack.push_back(Array);

6934

}

else if

(isa<PointerType>(Ty)) {

6937

}

else if

(isa<BlockPointerType>(Ty)) {

6939

Stack.push_back(BlockPointer);

6940

}

else if

(isa<MemberPointerType>(Ty)) {

6942

Stack.push_back(MemberPointer);

6943

}

else if

(isa<ReferenceType>(Ty)) {

6946

}

else if

(isa<AttributedType>(Ty)) {

6947 T

= cast<AttributedType>(Ty)->getEquivalentType();

6948

Stack.push_back(Attributed);

6949

}

else if

(isa<MacroQualifiedType>(Ty)) {

6950 T

= cast<MacroQualifiedType>(Ty)->getUnderlyingType();

6951

Stack.push_back(MacroQualified);

6960

Stack.push_back(Desugar);

6965 bool

isFunctionType()

const

{

return

(Fn !=

nullptr

); }

6970 if

(New == get())

return

Original;

6973 return

wrap(S.

, Original, 0);

6978 if

(I == Stack.size())

6987 return

wrap(

, SplitOld.

, I);

6988 return C

.getQualifiedType(wrap(

, SplitOld.

, I), SplitOld.

Quals

);

6992 if

(I == Stack.size())

return QualType

(Fn, 0);

6994 switch

(

static_cast<

WrapKind

>

(Stack[I++])) {

7001 return

wrap(

, cast<AttributedType>(Old)->getEquivalentType(), I);

7004 QualType

New = wrap(

, cast<ParenType>(Old)->getInnerType(), I);

7005 return C

.getParenType(New);

7008 case

MacroQualified:

7012 if

(

const auto

*CAT = dyn_cast<ConstantArrayType>(Old)) {

7013 QualType

New = wrap(

, CAT->getElementType(), I);

7014 return C

.getConstantArrayType(New, CAT->getSize(), CAT->getSizeExpr(),

7015

CAT->getSizeModifier(),

7016

CAT->getIndexTypeCVRQualifiers());

7019 if

(

const auto

*VAT = dyn_cast<VariableArrayType>(Old)) {

7020 QualType

New = wrap(

, VAT->getElementType(), I);

7021 return C

.getVariableArrayType(

7022

New, VAT->getSizeExpr(), VAT->getSizeModifier(),

7023

VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange());

7026 const auto

*IAT = cast<IncompleteArrayType>(Old);

7027 QualType

New = wrap(

, IAT->getElementType(), I);

7028 return C

.getIncompleteArrayType(New, IAT->getSizeModifier(),

7029

IAT->getIndexTypeCVRQualifiers());

7034 return C

.getPointerType(New);

7037 case

BlockPointer: {

7039 return C

.getBlockPointerType(New);

7042 case

MemberPointer: {

7045 return C

.getMemberPointerType(New, OldMPT->

getClass

());

7051 if

(isa<LValueReferenceType>(OldRef))

7054 return C

.getRValueReferenceType(New);

7058

llvm_unreachable(

"unknown wrapping kind"

);

7065 Sema

&S = State.getSema();

7069 default

: llvm_unreachable(

"Unknown attribute kind"

);

7070 case

ParsedAttr::AT_Ptr32:

7071

A = createSimpleAttr<Ptr32Attr>(S.

, PAttr);

7073 case

ParsedAttr::AT_Ptr64:

7074

A = createSimpleAttr<Ptr64Attr>(S.

, PAttr);

7076 case

ParsedAttr::AT_SPtr:

7077

A = createSimpleAttr<SPtrAttr>(S.

, PAttr);

7079 case

ParsedAttr::AT_UPtr:

7080

A = createSimpleAttr<UPtrAttr>(S.

, PAttr);

7084

std::bitset<attr::LastAttr> Attrs;

7087 if

(

const TypedefType

*TT = dyn_cast<TypedefType>(Desugared)) {

7088

Desugared = TT->desugar();

7090

}

else if

(

const ElaboratedType

*ET = dyn_cast<ElaboratedType>(Desugared)) {

7091

Desugared = ET->desugar();

7104 if

(Attrs[NewAttrKind]) {

7105

(PAttr.

(), diag::warn_duplicate_attribute_exact) << PAttr;

7108

Attrs[NewAttrKind] =

true

;

7112 if

(Attrs[attr::Ptr32] && Attrs[attr::Ptr64]) {

7113

(PAttr.

(), diag::err_attributes_are_not_compatible)

7115

"'__ptr64'"

7117

}

else if

(Attrs[attr::SPtr] && Attrs[attr::UPtr]) {

7118

(PAttr.

(), diag::err_attributes_are_not_compatible)

7126 if

(!isa<PointerType>(Desugared)) {

7130

(PAttr.

(), diag::err_attribute_no_member_pointers) << PAttr;

7132

(PAttr.

(), diag::err_attribute_pointers_only) << PAttr << 0;

7140 if

(PtrWidth == 32) {

7141 if

(Attrs[attr::Ptr64])

7143 else if

(Attrs[attr::UPtr])

7145

}

else if

(PtrWidth == 64 && Attrs[attr::Ptr32]) {

7162

assert(PAttr.

() == ParsedAttr::AT_WebAssemblyFuncref);

7164 Sema

&S = State.getSema();

7165 Attr

*A = createSimpleAttr<WebAssemblyFuncrefAttr>(S.

, PAttr);

7167

std::bitset<attr::LastAttr> Attrs;

7169 const auto

*AT = dyn_cast<AttributedType>(QT);

7171

Attrs[AT->getAttrKind()] =

true

;

7172

AT = dyn_cast<AttributedType>(AT->getModifiedType());

7177 if

(Attrs[NewAttrKind]) {

7178

(PAttr.

(), diag::warn_duplicate_attribute_exact) << PAttr;

7196 Sema

&S = State.getSema();

7197 auto

= State.getDeclarator();

7203 if

(State.isProcessingDeclSpec()) {

7204 if

(!(

.isPrototypeContext() ||

7208 if

(

auto

*chunk =

.getInnermostNonParenChunk()) {

7231 auto

chunkIdx = State.getCurrentChunkIndex();

7232 if

(chunkIdx >= 1 &&

7235 D

.getTypeObject(chunkIdx - 1).

getAttrs

());

7240 auto

*A = ::new (S.

) SwiftAttrAttr(S.

, PAttr, Str);

7241

QT = State.getAttributedType(A, QT, QT);

7248 auto

Attributed = dyn_cast<AttributedType>(

.getTypePtr());

7253 if

(Attributed->getImmediateNullability())

7254 return

Attributed->getModifiedType();

7258

Ctx, Attributed->getModifiedType());

7259

assert(Modified.

() != Attributed->getModifiedType().getTypePtr());

7261

Attributed->getEquivalentType(),

7262

Attributed->getAttr());

7268 case

ParsedAttr::AT_TypeNonNull:

7271 case

ParsedAttr::AT_TypeNullable:

7274 case

ParsedAttr::AT_TypeNullableResult:

7277 case

ParsedAttr::AT_TypeNullUnspecified:

7281

llvm_unreachable(

"not a nullability attribute kind"

);

7288 bool

IsContextSensitive,

bool

AllowOnArrayType,

bool

OverrideExisting) {

7289 bool Implicit

= (State ==

nullptr

);

7295 while

(

auto

*Attributed = dyn_cast<AttributedType>(Desugared.

())) {

7297 if

(

auto

ExistingNullability = Attributed->getImmediateNullability()) {

7299 if

(Nullability == *ExistingNullability) {

7303

(NullabilityLoc, diag::warn_nullability_duplicate)

7310 if

(!OverrideExisting) {

7312

(NullabilityLoc, diag::err_nullability_conflicting)

7322

Desugared = Attributed->getModifiedType();

7330 if

(Nullability != *ExistingNullability && !

Implicit

) {

7331

(NullabilityLoc, diag::err_nullability_conflicting)

7339 if

(

auto

typedefNullability =

7341 if

(*typedefNullability == *ExistingNullability) {

7354

!(AllowOnArrayType && Desugared->

isArrayType

())) {

7356

(NullabilityLoc, diag::err_nullability_nonpointer)

7364 if

(IsContextSensitive) {

7366 const Type

*pointeeType =

nullptr

;

7375

(NullabilityLoc, diag::err_nullability_cs_multilevel)

7377

(NullabilityLoc, diag::note_nullability_type_specifier)

7389

QT = State->getAttributedType(A, QT, QT);

7398 bool

AllowOnArrayType) {

7404

Nullability, NullabilityLoc,

7405

IsContextSensitive, AllowOnArrayType,

7412 bool

AllowArrayTypes,

7413 bool

OverrideExisting) {

7415

this

nullptr

, Nullability, DiagLoc,

7416 false

, AllowArrayTypes, OverrideExisting);

7423 Sema

&S = state.getSema();

7425 if

(isa<ObjCTypeParamType>(

)) {

7427 type

= state.getAttributedType(

7440

(

.getLoc(), diag::err_objc_kindof_nonobject)

7449

objType->getBaseType(), objType->getTypeArgsAsWritten(),

7450

objType->getProtocols(),

7451

objType->isObjCUnqualifiedId() ?

false

true

);

7456 if

(

auto

nullability =

->getNullability()) {

7459

assert(

.getAttributeSpellingListIndex() == 0 &&

7460 "multiple spellings for __kindof?"

);

7463

equivType = state.getAttributedType(A, equivType, equivType);

7468 type

= state.getAttributedType(

7469

createSimpleAttr<ObjCKindOfAttr>(S.

, equivType);

7481 Declarator

&declarator = state.getDeclarator();

7484 auto

moveToChunk = [&](

DeclaratorChunk

&chunk,

bool

inFunction) ->

bool

{

7497

PK_MemberFunctionPointer,

7502

: inFunction? PK_MemberFunctionPointer : PK_MemberPointer;

7504 auto

diag = state.getSema().Diag(

.getLoc(),

7505

diag::warn_nullability_declspec)

7507 attr

.isContextSensitiveKeywordAttribute())

7509

static_cast<unsigned>

(pointerKind);

7515

state.getSema().getPreprocessor().getLocForEndOfToken(

7517 " "

.getAttrName()->getName().str() +

" "

);

7527 for

(

unsigned

i = state.getCurrentChunkIndex(); i != 0; --i) {

7529 switch

(chunk.

) {

7533 return

moveToChunk(chunk,

false

);

7545 return

moveToChunk(*dest,

true

);

7561

assert(!

.isInvalid());

7564

llvm_unreachable(

"not a calling convention attribute"

);

7565 case

ParsedAttr::AT_CDecl:

7566 return

createSimpleAttr<CDeclAttr>(Ctx,

);

7567 case

ParsedAttr::AT_FastCall:

7568 return

createSimpleAttr<FastCallAttr>(Ctx,

);

7569 case

ParsedAttr::AT_StdCall:

7570 return

createSimpleAttr<StdCallAttr>(Ctx,

);

7571 case

ParsedAttr::AT_ThisCall:

7572 return

createSimpleAttr<ThisCallAttr>(Ctx,

);

7573 case

ParsedAttr::AT_RegCall:

7574 return

createSimpleAttr<RegCallAttr>(Ctx,

);

7575 case

ParsedAttr::AT_Pascal:

7576 return

createSimpleAttr<PascalAttr>(Ctx,

);

7577 case

ParsedAttr::AT_SwiftCall:

7578 return

createSimpleAttr<SwiftCallAttr>(Ctx,

);

7579 case

ParsedAttr::AT_SwiftAsyncCall:

7580 return

createSimpleAttr<SwiftAsyncCallAttr>(Ctx,

);

7581 case

ParsedAttr::AT_VectorCall:

7582 return

createSimpleAttr<VectorCallAttr>(Ctx,

);

7583 case

ParsedAttr::AT_AArch64VectorPcs:

7584 return

createSimpleAttr<AArch64VectorPcsAttr>(Ctx,

);

7585 case

ParsedAttr::AT_AArch64SVEPcs:

7586 return

createSimpleAttr<AArch64SVEPcsAttr>(Ctx,

);

7587 case

ParsedAttr::AT_ArmStreaming:

7588 return

createSimpleAttr<ArmStreamingAttr>(Ctx,

);

7589 case

ParsedAttr::AT_AMDGPUKernelCall:

7590 return

createSimpleAttr<AMDGPUKernelCallAttr>(Ctx,

);

7591 case

ParsedAttr::AT_Pcs: {

7596 if

(

.isArgExpr(0))

7597

Str = cast<StringLiteral>(

.getArgAsExpr(0))->getString();

7599

Str =

.getArgAsIdent(0)->Ident->getName();

7600

PcsAttr::PCSType

;

7601 if

(!PcsAttr::ConvertStrToPCSType(Str,

))

7602

llvm_unreachable(

"already validated the attribute"

);

7603

return ::new (Ctx) PcsAttr(Ctx,

);

7605 case

ParsedAttr::AT_IntelOclBicc:

7606 return

createSimpleAttr<IntelOclBiccAttr>(Ctx,

);

7607 case

ParsedAttr::AT_MSABI:

7608 return

createSimpleAttr<MSABIAttr>(Ctx,

);

7609 case

ParsedAttr::AT_SysVABI:

7610 return

createSimpleAttr<SysVABIAttr>(Ctx,

);

7611 case

ParsedAttr::AT_PreserveMost:

7612 return

createSimpleAttr<PreserveMostAttr>(Ctx,

);

7613 case

ParsedAttr::AT_PreserveAll:

7614 return

createSimpleAttr<PreserveAllAttr>(Ctx,

);

7615 case

ParsedAttr::AT_M68kRTD:

7616 return

createSimpleAttr<M68kRTDAttr>(Ctx,

);

7617 case

ParsedAttr::AT_PreserveNone:

7618 return

createSimpleAttr<PreserveNoneAttr>(Ctx,

);

7619 case

ParsedAttr::AT_RISCVVectorCC:

7620 return

createSimpleAttr<RISCVVectorCCAttr>(Ctx,

);

7622

llvm_unreachable(

"unexpected attribute kind!"

);

7625

std::optional<FunctionEffectMode>

7630

std::optional<llvm::APSInt> ConditionValue =

7632 if

(!ConditionValue) {

7635 Diag

(CondExpr->

getExprLoc

(), diag::err_attribute_argument_type)

7638 return

std::nullopt;

7647

FunctionTypeUnwrapper &Unwrapped) {

7649 if

(!Unwrapped.isFunctionType())

7652 Sema

&S = TPState.getSema();

7656 if

(FPT ==

nullptr

) {

7657

(PAttr.

(), diag::err_func_with_effects_no_prototype)

7664 bool

IsNonBlocking = PAttr.

() == ParsedAttr::AT_NonBlocking ||

7665

PAttr.

() == ParsedAttr::AT_Blocking;

7668 Expr

*CondExpr =

nullptr

;

7670 if

(PAttr.

() == ParsedAttr::AT_NonBlocking ||

7671

PAttr.

() == ParsedAttr::AT_NonAllocating) {

7680

std::optional<FunctionEffectMode> MaybeMode =

7686

NewMode = *MaybeMode;

7688

CondExpr =

nullptr

;

7721

assert(

Success

"effect conflicts should have been diagnosed above"

);

7725

FPT->getParamTypes(), EPI);

7734 auto

OtherAttr = std::find_if(

7735

state.getCurrentAttributes().begin(), state.getCurrentAttributes().end(),

7736

[OtherKind](

const ParsedAttr

&A) { return A.getKind() == OtherKind; });

7737 if

(OtherAttr == state.getCurrentAttributes().end() || OtherAttr->isInvalid())

7740 Sema

&S = state.getSema();

7741

(

(), diag::err_attributes_are_not_compatible)

7742

<< *OtherAttr <<

Attr 7743

<< (OtherAttr->isRegularKeywordAttribute() ||

7745

(OtherAttr->getLoc(), diag::note_conflicting_attribute);

7753 if

.getNumArgs()) {

7759 for

(

unsigned

I = 0; I <

.getNumArgs(); ++I) {

7760

StringRef StateName;

7765 if

(StateName !=

"sme_za_state"

) {

7766

(LiteralLoc, diag::err_unknown_arm_state) << StateName;

7773

(

(), diag::err_conflicting_attributes_arm_agnostic);

7788 if

.getNumArgs()) {

7794 for

(

unsigned

I = 0; I <

.getNumArgs(); ++I) {

7795

StringRef StateName;

7802 if

(StateName ==

"za"

) {

7805

}

else if

(StateName ==

"zt0"

) {

7809

(LiteralLoc, diag::err_unknown_arm_state) << StateName;

7815

(LiteralLoc, diag::err_conflicting_attributes_arm_agnostic);

7824

(LiteralLoc, diag::err_conflicting_attributes_arm_state)

7840 Sema

&S = state.getSema();

7842

FunctionTypeUnwrapper unwrapped(S,

);

7844 if

(

.getKind() == ParsedAttr::AT_NoReturn) {

7849 if

(!unwrapped.isFunctionType())

7858 if

(

.getKind() == ParsedAttr::AT_CmseNSCall) {

7860 if

(!unwrapped.isFunctionType())

7865

(

.getLoc(), diag::warn_attribute_ignored) <<

;

7879 if

(

.getKind() == ParsedAttr::AT_NSReturnsRetained) {

7880 if

(

.getNumArgs())

return true

;

7883 if

(!unwrapped.isFunctionType())

7888 attr

.getLoc(), unwrapped.get()->getReturnType()))

7893 if

(state.getSema().getLangOpts().ObjCAutoRefCount) {

7898 type

= state.getAttributedType(

7899

createSimpleAttr<NSReturnsRetainedAttr>(S.

7904 if

(

.getKind() == ParsedAttr::AT_AnyX86NoCallerSavedRegisters) {

7909 if

(!unwrapped.isFunctionType())

7918 if

(

.getKind() == ParsedAttr::AT_AnyX86NoCfCheck) {

7920

(

.getLoc(), diag::warn_nocf_check_attribute_ignored);

7930 if

(!unwrapped.isFunctionType())

7939 if

(

.getKind() == ParsedAttr::AT_Regparm) {

7945 if

(!unwrapped.isFunctionType())

7952

(

.getLoc(), diag::err_attributes_are_not_compatible)

7954

.isRegularKeywordAttribute();

7960

unwrapped.get()->getExtInfo().

withRegParm

(value);

7965 if

(

.getKind() == ParsedAttr::AT_ArmStreaming ||

7966 attr

.getKind() == ParsedAttr::AT_ArmStreamingCompatible ||

7967 attr

.getKind() == ParsedAttr::AT_ArmPreserves ||

7968 attr

.getKind() == ParsedAttr::AT_ArmIn ||

7969 attr

.getKind() == ParsedAttr::AT_ArmOut ||

7970 attr

.getKind() == ParsedAttr::AT_ArmInOut ||

7971 attr

.getKind() == ParsedAttr::AT_ArmAgnostic) {

7975 if

(

.getKind() == ParsedAttr::AT_ArmStreaming ||

7976 attr

.getKind() == ParsedAttr::AT_ArmStreamingCompatible)

7980 if

(!unwrapped.isFunctionType())

7987

(

.getLoc(), diag::warn_attribute_wrong_decl_type)

7988

.isRegularKeywordAttribute()

7995 switch

(

.getKind()) {

7996 case

ParsedAttr::AT_ArmStreaming:

7998

ParsedAttr::AT_ArmStreamingCompatible))

8002 case

ParsedAttr::AT_ArmStreamingCompatible:

8007 case

ParsedAttr::AT_ArmPreserves:

8011 case

ParsedAttr::AT_ArmIn:

8015 case

ParsedAttr::AT_ArmOut:

8019 case

ParsedAttr::AT_ArmInOut:

8023 case

ParsedAttr::AT_ArmAgnostic:

8028

llvm_unreachable(

"Unsupported attribute"

);

8032

FnTy->getParamTypes(), EPI);

8037 if

(

.getKind() == ParsedAttr::AT_NoThrow) {

8039 if

(!unwrapped.isFunctionType())

8052 if

(Proto->hasExceptionSpec()) {

8053 switch

(Proto->getExceptionSpecType()) {

8055

llvm_unreachable(

"This doesn't have an exception spec!"

);

8073

(

.getLoc(), diag::warn_nothrow_attribute_ignored);

8079 type

= unwrapped.wrap(

8088 if

(

.getKind() == ParsedAttr::AT_NonBlocking ||

8089 attr

.getKind() == ParsedAttr::AT_NonAllocating ||

8090 attr

.getKind() == ParsedAttr::AT_Blocking ||

8091 attr

.getKind() == ParsedAttr::AT_Allocating) {

8096 if

(!unwrapped.isFunctionType())

return false

;

8111

(

.getLoc(), diag::err_attributes_are_not_compatible)

8114

.isRegularKeywordAttribute();

8133 return

(

.getLoc(), diag::warn_cconv_unsupported)

8138 return

(

.getLoc(), diag::err_cconv_varargs)

8145

(

.getLoc(), diag::err_attributes_are_not_compatible)

8147

.isRegularKeywordAttribute();

8159 auto

EI = unwrapped.get()->getExtInfo().withCallingConv(CC);

8183

FunctionTypeUnwrapper Unwrapped(*

this

);

8185 bool

IsVariadic = (isa<FunctionProtoType>(FT) &&

8186

cast<FunctionProtoType>(FT)->isVariadic());

8200 Diag

(

, diag::warn_cconv_unsupported)

8211 if

(CurCC != DefaultCC)

8219 QualType

Wrapped = Unwrapped.wrap(*

this

, FT);

8233 if

(

.getNumArgs() != 1) {

8240 Expr

*SizeExpr =

.getArgAsExpr(0);

8253 if

(

.getNumArgs() != 1) {

8259 Expr

*SizeExpr =

.getArgAsExpr(0);

8274 bool

IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 ||

8275

Triple.getArch() == llvm::Triple::aarch64_32 ||

8276

Triple.getArch() == llvm::Triple::aarch64_be;

8278 if

(IsPolyUnsigned) {

8280 return

BTy->

() == BuiltinType::UChar ||

8281

BTy->

() == BuiltinType::UShort ||

8282

BTy->

() == BuiltinType::ULong ||

8283

BTy->

() == BuiltinType::ULongLong;

8286 return

BTy->

() == BuiltinType::SChar ||

8287

BTy->

() == BuiltinType::Short ||

8288

BTy->

() == BuiltinType::LongLong;

8294 if

((Triple.isArch64Bit() || Triple.getArch() == llvm::Triple::aarch64_32) &&

8295

BTy->

() == BuiltinType::Double)

8298 return

BTy->

() == BuiltinType::SChar ||

8299

BTy->

() == BuiltinType::UChar ||

8300

BTy->

() == BuiltinType::Short ||

8301

BTy->

() == BuiltinType::UShort ||

8302

BTy->

() == BuiltinType::Int ||

8303

BTy->

() == BuiltinType::UInt ||

8304

BTy->

() == BuiltinType::Long ||

8305

BTy->

() == BuiltinType::ULong ||

8306

BTy->

() == BuiltinType::LongLong ||

8307

BTy->

() == BuiltinType::ULongLong ||

8308

BTy->

() == BuiltinType::Float ||

8309

BTy->

() == BuiltinType::Half ||

8310

BTy->

() == BuiltinType::BFloat16 ||

8311

BTy->

() == BuiltinType::MFloat8;

8315

llvm::APSInt &

) {

8316 const auto

*AttrExpr =

.getArgAsExpr(0);

8317 if

(!AttrExpr->isTypeDependent()) {

8318 if

(std::optional<llvm::APSInt> Res =

8319

AttrExpr->getIntegerConstantExpr(S.

)) {

8339 bool

IsTargetCUDAAndHostARM =

false

;

8342

IsTargetCUDAAndHostARM =

8351

(

(), diag::err_attribute_unsupported_m_profile)

8352

"'mve'"

;

8359

(

(), diag::err_attribute_unsupported_m_profile)

8360

"'mve'"

;

8366 if

(

.getNumArgs() != 1) {

8367

(

(), diag::err_attribute_wrong_number_arguments)

8373

llvm::APSInt numEltsInt(32);

8379

!IsTargetCUDAAndHostARM) {

8380

(

(), diag::err_attribute_invalid_vector_type) << CurType;

8387 unsigned

numElts =

static_cast<unsigned>

(numEltsInt.getZExtValue());

8388 unsigned

vecSize = typeSize * numElts;

8389 if

(vecSize != 64 && vecSize != 128) {

8390

(

(), diag::err_attribute_bad_neon_vector_size) << CurType;

8414

(

(), diag::err_attribute_arm_feature_sve_bits_unsupported)

8421 if

(

.getNumArgs() != 1) {

8422

(

(), diag::err_attribute_wrong_number_arguments)

8429

llvm::APSInt SveVectorSizeInBits(32);

8433 unsigned

VecSize =

static_cast<unsigned>

(SveVectorSizeInBits.getZExtValue());

8436 if

(VecSize != S.

().VScaleMin * 128) {

8437

(

(), diag::err_attribute_bad_sve_vector_size)

8445

(

(), diag::err_attribute_invalid_sve_type)

8456 if

(BT->getKind() == BuiltinType::SveBool) {

8461

VecSize /= TypeSize;

8468 const VectorType

*VT = dyn_cast<VectorType>(CurType);

8471

diag::err_attribute_arm_mve_polymorphism);

8477

State.getAttributedType(createSimpleAttr<ArmMveStrictPolymorphismAttr>(

8478

State.getSema().Context,

8490

"'zve32x'"

;

8497 if

(!VScale || !VScale->first || VScale->first != VScale->second) {

8498

(

(), diag::err_attribute_riscv_rvv_bits_unsupported)

8505 if

(

.getNumArgs() != 1) {

8506

(

(), diag::err_attribute_wrong_number_arguments)

8513

llvm::APSInt RVVVectorSizeInBits(32);

8519

(

(), diag::err_attribute_invalid_rvv_type)

8525 unsigned

VecSize =

static_cast<unsigned>

(RVVVectorSizeInBits.getZExtValue());

8529 unsigned

MinElts = Info.

.getKnownMinValue();

8532 unsigned

ExpectedSize = VScale->first * MinElts;

8554

ExpectedSize *= EltSize;

8555

NumElts = VecSize / EltSize;

8559 if

(VecSize != ExpectedSize) {

8560

(

(), diag::err_attribute_bad_rvv_vector_size)

8561

<< VecSize << ExpectedSize;

8574

(

(), diag::err_opencl_invalid_access_qualifier);

8580 QualType

BaseTy = TypedefTy->desugar();

8582

std::string PrevAccessQual;

8584 if

(TypedefTy->getDecl()->hasAttr<OpenCLAccessAttr>()) {

8585

OpenCLAccessAttr *

8586

TypedefTy->getDecl()->getAttr<OpenCLAccessAttr>();

8589

PrevAccessQual =

"read_only"

;

8593 switch

(ImgType->getKind()) {

8594 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 8595 case BuiltinType::Id: \ 8596 PrevAccessQual = #Access; \ 8598 #include "clang/Basic/OpenCLImageTypes.def" 8600

llvm_unreachable(

"Unable to find corresponding image type."

);

8603

llvm_unreachable(

"unexpected type"

);

8606 if

(PrevAccessQual == AttrName.ltrim(

"_"

)) {

8612

(

(), diag::err_opencl_multiple_access_qualifiers);

8615

(TypedefTy->getDecl()->getBeginLoc(),

8616

diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;

8618 if

(

.getSemanticSpelling() == OpenCLAccessAttr::Keyword_write_only) {

8633 if

(

.getNumArgs() != 2) {

8634

(

(), diag::err_attribute_wrong_number_arguments)

8639 Expr

*RowsExpr =

.getArgAsExpr(0);

8640 Expr

*ColsExpr =

.getArgAsExpr(1);

8648 Sema

&S = State.getSema();

8651

(PA.

(), diag::err_attribute_too_few_arguments) << PA << 1;

8663 for

(

unsigned

Idx = 1; Idx < PA.

getNumArgs

(); Idx++) {

8669 auto

*AnnotateTypeAttr =

8670

AnnotateTypeAttr::Create(S.

, Str, Args.data(), Args.size(), PA);

8671

CurType = State.getAttributedType(AnnotateTypeAttr, CurType, CurType);

8677 if

(State.getDeclarator().isDeclarationOfFunction()) {

8678

CurType = State.getAttributedType(

8679

createSimpleAttr<LifetimeBoundAttr>(State.getSema().Context,

8683

State.getSema().Diag(

(), diag::err_attribute_wrong_decl_type)

8690 if

(State.getDeclarator().isDeclarationOfFunction()) {

8691 auto

= State.getSema().ParseLifetimeCaptureByAttr(PA,

"this"

);

8693

CurType = State.getAttributedType(

, CurType, CurType);

8705 if

(

.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_inout ||

8706 Attr

.getSemanticSpelling() == HLSLParamModifierAttr::Keyword_out) {

8707

State.setParsedHLSLParamMod(

true

);

8716

state.setParsedNoDeref(

false

);

8717 if

(attrs.

empty

())

8732 if

(

.isInvalid())

8735 if

(

.isStandardAttributeSyntax() ||

.isRegularKeywordAttribute()) {

8740 if

(

.isGNUScope()) {

8741

assert(

.isStandardAttributeSyntax());

8742 bool

IsTypeAttr =

.isTypeAttr();

8744

state.getSema().Diag(

.getLoc(),

8746

? diag::warn_gcc_ignores_type_attr

8747

: diag::warn_cxx11_gnu_attribute_on_type)

8753

.isTypeAttr()) {

8766 switch

(

.getKind()) {

8769 if

((

.isStandardAttributeSyntax() ||

8770 attr

.isRegularKeywordAttribute()) &&

8772

state.getSema().Diag(

.getLoc(), diag::err_attribute_not_type_attr)

8773

.isRegularKeywordAttribute();

8774 attr

.setUsedAsTypeAttr();

8779 if

(

.isStandardAttributeSyntax()) {

8780

state.getSema().Diag(

.getLoc(),

8781

diag::warn_unknown_attribute_ignored)

8792 case

ParsedAttr::AT_BTFTypeTag:

8794 attr

.setUsedAsTypeAttr();

8797 case

ParsedAttr::AT_MayAlias:

8800 attr

.setUsedAsTypeAttr();

8802 case

ParsedAttr::AT_OpenCLPrivateAddressSpace:

8803 case

ParsedAttr::AT_OpenCLGlobalAddressSpace:

8804 case

ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace:

8805 case

ParsedAttr::AT_OpenCLGlobalHostAddressSpace:

8806 case

ParsedAttr::AT_OpenCLLocalAddressSpace:

8807 case

ParsedAttr::AT_OpenCLConstantAddressSpace:

8808 case

ParsedAttr::AT_OpenCLGenericAddressSpace:

8809 case

ParsedAttr::AT_HLSLGroupSharedAddressSpace:

8810 case

ParsedAttr::AT_AddressSpace:

8812 attr

.setUsedAsTypeAttr();

8817 attr

.setUsedAsTypeAttr();

8819 case

ParsedAttr::AT_VectorSize:

8821 attr

.setUsedAsTypeAttr();

8823 case

ParsedAttr::AT_ExtVectorType:

8825 attr

.setUsedAsTypeAttr();

8827 case

ParsedAttr::AT_NeonVectorType:

8829 attr

.setUsedAsTypeAttr();

8831 case

ParsedAttr::AT_NeonPolyVectorType:

8834 attr

.setUsedAsTypeAttr();

8836 case

ParsedAttr::AT_ArmSveVectorBits:

8838 attr

.setUsedAsTypeAttr();

8840 case

ParsedAttr::AT_ArmMveStrictPolymorphism: {

8842 attr

.setUsedAsTypeAttr();

8845 case

ParsedAttr::AT_RISCVRVVVectorBits:

8847 attr

.setUsedAsTypeAttr();

8849 case

ParsedAttr::AT_OpenCLAccess:

8851 attr

.setUsedAsTypeAttr();

8853 case

ParsedAttr::AT_LifetimeBound:

8857 case

ParsedAttr::AT_LifetimeCaptureBy:

8862 case

ParsedAttr::AT_NoDeref: {

8867 if

(

.isStandardAttributeSyntax()) {

8868

state.getSema().Diag(

.getLoc(), diag::warn_attribute_ignored)

8873 type

= state.getAttributedType(createSimpleAttr<NoDerefAttr>(Ctx,

8875 attr

.setUsedAsTypeAttr();

8876

state.setParsedNoDeref(

true

);

8880 case

ParsedAttr::AT_MatrixType:

8882 attr

.setUsedAsTypeAttr();

8885 case

ParsedAttr::AT_WebAssemblyFuncref: {

8887 attr

.setUsedAsTypeAttr();

8891 case

ParsedAttr::AT_HLSLParamModifier: {

8893 attr

.setUsedAsTypeAttr();

8897 case

ParsedAttr::AT_SwiftAttr: {

8904 attr

.setUsedAsTypeAttr();

8912 if

(

->canHaveNullability() ||

->isDependentType() ||

8913 type

->isArrayType() ||

8917

endIndex = state.getCurrentChunkIndex();

8919

endIndex = state.getDeclarator().getNumTypeObjects();

8920 bool

allowOnArrayType =

8921

state.getDeclarator().isPrototypeContext() &&

8924

allowOnArrayType)) {

8928 attr

.setUsedAsTypeAttr();

8932 case

ParsedAttr::AT_ObjCKindOf:

8940

state.getSema().Diag(

.getLoc(),

8941

diag::err_objc_kindof_wrong_position)

8944

state.getDeclarator().getDeclSpec().getBeginLoc(),

8954 case

ParsedAttr::AT_NoThrow:

8957 if

(!state.getSema().getLangOpts().CPlusPlus)

8961 attr

.setUsedAsTypeAttr();

8965 if

(

.isStandardAttributeSyntax() ||

8966 attr

.isRegularKeywordAttribute()) {

8983 case

ParsedAttr::AT_AcquireHandle: {

8984 if

->isFunctionType())

8987 if

(

.getNumArgs() != 1) {

8988

state.getSema().Diag(

.getLoc(),

8989

diag::err_attribute_wrong_number_arguments)

8995

StringRef HandleType;

8996 if

(!state.getSema().checkStringLiteralArgumentAttr(

, 0, HandleType))

8998 type

= state.getAttributedType(

8999

AcquireHandleAttr::Create(state.getSema().Context, HandleType,

9001 attr

.setUsedAsTypeAttr();

9004 case

ParsedAttr::AT_AnnotateType: {

9006 attr

.setUsedAsTypeAttr();

9009 case

ParsedAttr::AT_HLSLResourceClass:

9010 case

ParsedAttr::AT_HLSLROV:

9011 case

ParsedAttr::AT_HLSLRawBuffer:

9012 case

ParsedAttr::AT_HLSLContainedType: {

9017

state.getSema().HLSL().handleResourceTypeAttr(

))

9018 attr

.setUsedAsTypeAttr();

9025 if

(isa<AttributedType>(

) &&

.hasMacroIdentifier() &&

9026

.getQualifiers().hasObjCLifetime() &&

9027

.getQualifiers().hasObjCGCAttr() &&

9028 attr

.getKind() != ParsedAttr::AT_ObjCGC &&

9029 attr

.getKind() != ParsedAttr::AT_ObjCOwnership) {

9031 type

= state.getSema().Context.getMacroQualifiedType(

, MacroII);

9032

state.setExpansionLocForMacroQualifiedType(

9033

cast<MacroQualifiedType>(

.getTypePtr()),

9034 attr

.getMacroExpansionLoc());

9041 if

(

VarDecl

*Var = dyn_cast<VarDecl>(DRE->getDecl())) {

9043 auto

*Def = Var->getDefinition();

9049

Def = Var->getDefinition();

9056 if

(Var->getPointOfInstantiation().isInvalid() && Def) {

9057

assert(Var->getTemplateSpecializationKind() ==

9059 "explicit instantiation with no point of instantiation"

);

9060

Var->setTemplateSpecializationKind(

9061

Var->getTemplateSpecializationKind(), PointOfInstantiation);

9081 if

(

const auto

CastE = dyn_cast<ExplicitCastExpr>(

)) {

9082 QualType

DestType = CastE->getTypeAsWritten();

9088

IAT->getElementType(),

9125 if

(RequireCompleteTypeImpl(

, Kind, &Diagnoser))

9128 if

(!Tag->getDecl()->isCompleteDefinitionRequired()) {

9129

Tag->getDecl()->setCompleteDefinitionRequired();

9148 return

Ctx.IsEquivalent(

, Suggested);

9159 if

(isa<TagDecl>(

) && cast<TagDecl>(

)->isBeingDefined()) {

9163

}

else if

(

auto

*RD = dyn_cast<CXXRecordDecl>(

)) {

9164 if

(

auto

*Pattern = RD->getTemplateInstantiationPattern())

9166 D

= RD->getDefinition();

9167

}

else if

(

auto

*ED = dyn_cast<EnumDecl>(

)) {

9168 if

(

auto

*Pattern = ED->getTemplateInstantiationPattern())

9170 if

(OnlyNeedComplete && (ED->isFixed() ||

().MSVCCompat)) {

9176

*Suggested =

nullptr

;

9177 for

(

auto

*Redecl : ED->redecls()) {

9180 if

(Redecl->isThisDeclarationADefinition() ||

9181

(Redecl->isCanonicalDecl() && !*Suggested))

9182

*Suggested = Redecl;

9187 D

= ED->getDefinition();

9188

}

else if

(

auto

*FD = dyn_cast<FunctionDecl>(

)) {

9189 if

(

auto

*Pattern = FD->getTemplateInstantiationPattern())

9191 D

= FD->getDefinition();

9192

}

else if

(

auto

*VD = dyn_cast<VarDecl>(

)) {

9193 if

(

auto

*Pattern = VD->getTemplateInstantiationPattern())

9195 D

= VD->getDefinition();

9198

assert(

"missing definition for pattern of instantiated definition"

);

9202 auto

DefinitionIsAcceptable = [&] {

9222 if

(DefinitionIsAcceptable())

9228

Source->CompleteRedeclChain(

);

9229 return

DefinitionIsAcceptable();

9245 bool

OnlyNeedComplete) {

9262 bool

OnlyNeedComplete) {

9270 if

(!RD->

<MSInheritanceAttr>()) {

9272 bool

BestCase =

false

;

9292

RD->

addAttr

(MSInheritanceAttr::CreateImplicit(

9299

CompleteTypeKind Kind,

9300

TypeDiagnoser *Diagnoser) {

9310 if

(!MPTy->getClass()->isDependentType()) {

9312

!MPTy->getClass()->getAsCXXRecordDecl()->isBeingDefined() &&

9314

diag::err_memptr_incomplete))

9333 if

(Def && !isa<EnumDecl>(Def))

9344 if

(Diagnoser && Suggested)

9347 return

!TreatAsComplete;

9349

CodeSynthesisContext TempInst;

9351

TempInst.Template = Def;

9352

TempInst.Entity = Def;

9353

TempInst.PointOfInstantiation =

;

9361 TagDecl

= dyn_cast_or_null<TagDecl>(Def);

9375 if

(Tag &&

->hasExternalLexicalStorage())

9376

Source->CompleteType(Tag);

9378

Source->CompleteType(IFace);

9382 return

RequireCompleteTypeImpl(

, Kind, Diagnoser);

9389 if

(

auto

*RD = dyn_cast_or_null<CXXRecordDecl>(Tag)) {

9390 bool

Instantiated =

false

;

9391 bool

Diagnosed =

false

;

9392 if

(RD->isDependentContext()) {

9396

}

else if

(

auto

*ClassTemplateSpec =

9397

dyn_cast<ClassTemplateSpecializationDecl>(RD)) {

9398 if

(ClassTemplateSpec->getSpecializationKind() ==

TSK_Undeclared

) {

9404

Instantiated =

true

;

9408 if

(!RD->isBeingDefined() && Pattern) {

9410

assert(MSI &&

"Missing member specialization information?"

);

9420

Instantiated =

true

;

9428 if

(Diagnoser && Diagnosed)

9434 return

RequireCompleteTypeImpl(

, Kind, Diagnoser);

9444

Diagnoser->diagnose(*

this

);

9448 if

(Tag && !

->isInvalidDecl() && !

->getLocation().isInvalid())

9450 Tag

->isBeingDefined() ? diag::note_type_being_defined

9451

: diag::note_forward_declaration)

9485 default

: llvm_unreachable(

"Invalid tag kind for literal type diagnostic!"

);

9529 for

(

const auto

&I : RD->

vbases

())

9530 Diag

(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)

9531

<< I.getSourceRange();

9534 Diag

(RD->

getLocation

(), diag::note_non_literal_no_constexpr_ctors) << RD;

9536 for

(

const auto

&I : RD->

bases

()) {

9537 if

(!I.getType()->isLiteralType(

)) {

9538 Diag

(I.getBeginLoc(), diag::note_non_literal_base_class)

9539

<< RD << I.getType() << I.getSourceRange();

9543 for

(

const auto

*I : RD->

fields

()) {

9544 if

(!I->getType()->isLiteralType(

) ||

9545

I->getType().isVolatileQualified()) {

9546 Diag

(I->getLocation(), diag::note_non_literal_field)

9547

<< RD << I << I->getType()

9548

<< I->getType().isVolatileQualified();

9558

assert(Dtor &&

"class has literal fields and bases but no dtor?"

);

9563 Diag

(Dtor->

getLocation

(), diag::note_non_literal_non_constexpr_dtor)

9567

? diag::note_non_literal_user_provided_dtor

9568

: diag::note_non_literal_nontrivial_dtor)

9613 auto

*CountDecl = cast<DeclRefExpr>(

)->getDecl();

9637 if

(

auto

*ImplCastExpr = dyn_cast<ImplicitCastExpr>(

))

9638

IDExpr = ImplCastExpr->getSubExpr();

9640 if

(

auto

*PackExpr = dyn_cast<PackIndexingExpr>(

)) {

9642

IDExpr = PackExpr->getPackIdExpression();

9644

IDExpr = PackExpr->getSelectedExpr();

9660 if

(

const auto

*SNTTPE = dyn_cast<SubstNonTypeTemplateParmExpr>(IDExpr))

9661 return

SNTTPE->getParameterType(

);

9669 if

(

const auto

*DRE = dyn_cast<DeclRefExpr>(IDExpr)) {

9672 return

isa<TemplateParamObjectDecl>(VD) ?

.getUnqualifiedType() :

;

9674 if

(

const auto

*ME = dyn_cast<MemberExpr>(IDExpr)) {

9675 if

(

const auto

*VD = ME->getMemberDecl())

9676 if

(isa<FieldDecl>(VD) || isa<VarDecl>(VD))

9677 return

VD->getType();

9678

}

else if

(

const auto

*IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {

9679 return

IR->getDecl()->getType();

9680

}

else if

(

const auto

*PR = dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {

9681 if

(PR->isExplicitProperty())

9682 return

PR->getExplicitProperty()->getType();

9683

}

else if

(

const auto

*PE = dyn_cast<PredefinedExpr>(IDExpr)) {

9684 return

PE->getType();

9695 if

(

auto

*DRE = dyn_cast<DeclRefExpr>(IDExpr->

IgnoreParens

())) {

9696 if

(

auto

*Var = dyn_cast<VarDecl>(DRE->getDecl())) {

9716 Diag

(

getExprLoc

(), diag::warn_side_effects_unevaluated_context);

9729 Diag

(

, diag::err_expected_name_of_pack) << Pattern;

9733 if

.isNull())

9735

: diag::ext_pack_indexing);

9742 bool

FullySubstituted,

9745

std::optional<int64_t> Index;

9753

Index =

Value

.getExtValue();

9754

IndexExpr = Res.

get

();

9757 if

(FullySubstituted && Index) {

9758 if

(*Index < 0 || *Index >= int64_t(Expansions.size())) {

9760

<< *Index << Pattern << Expansions.size();

9766

Expansions, Index.value_or(-1));

9773

assert(ED &&

"EnumType has no EnumDecl"

);

9778

assert(!Underlying.

());

9786 Diag

(

, diag::err_only_enums_have_underlying_types);

9794 Diag

(

, diag::err_underlying_type_of_incomplete_enum) << BaseType;

9795 Diag

(FwdDecl->

getLocation

(), diag::note_forward_declaration) << FwdDecl;

9830

Split.Quals.removeCVRQualifiers();

9840

UKind == UnaryTransformType::AddLvalueReference,

9848 if

(UKind == UnaryTransformType::RemoveAllExtents)

9852 return

AT->getElementType();

9861 if

(UKind == UTTKind::RemoveCVRef &&

9862

(

.isConstQualified() ||

.isVolatileQualified())) {

9874 if

((BaseType->

isReferenceType

() && UKind != UTTKind::RemoveRestrict) ||

9881 if

(UKind == UTTKind::RemoveConst || UKind == UTTKind::RemoveCV)

9883 if

(UKind == UTTKind::RemoveVolatile || UKind == UTTKind::RemoveCV)

9885 if

(UKind == UTTKind::RemoveRestrict)

9896 if

(

auto

BitInt

= dyn_cast<BitIntType>(Underlying)) {

9897 unsigned int

Bits =

BitInt

->getNumBits();

9901

(

, diag::err_make_signed_integral_only)

9902

<< IsMakeSigned <<

true

<< BaseType << 1 << Underlying;

9906

(

, diag::err_make_signed_integral_only)

9907

<< IsMakeSigned <<

false

<< BaseType << 1

9914

std::array<CanQualType *, 6> AllSignedIntegers = {

9918

AllSignedIntegers.data(), AllSignedIntegers.size() - Int128Unsupported);

9919

std::array<CanQualType *, 6> AllUnsignedIntegers = {

9924

AllUnsignedIntegers.size() -

9927

IsMakeSigned ? &AvailableSignedIntegers : &AvailableUnsignedIntegers;

9931

llvm::find_if(*Consider, [&S, BaseSize](

const CanQual<Type>

) {

9935

assert(

!= Consider->end());

9936 return QualType

((*Result)->getTypePtr(), 0);

9941 bool

IsMakeSigned = UKind == UnaryTransformType::MakeSigned;

9946 Diag

(

, diag::err_make_signed_integral_only)

9947

<< IsMakeSigned << BaseType->

isBitIntType

() << BaseType << 0;

9951 bool

IsNonIntIntegral =

9960 if

(Underlying.

())

9971 case

UnaryTransformType::EnumUnderlyingType: {

9975 case

UnaryTransformType::AddPointer: {

9979 case

UnaryTransformType::RemovePointer: {

9983 case

UnaryTransformType::Decay: {

9987 case

UnaryTransformType::AddLvalueReference:

9988 case

UnaryTransformType::AddRvalueReference: {

9992 case

UnaryTransformType::RemoveAllExtents:

9993 case

UnaryTransformType::RemoveExtent: {

9997 case

UnaryTransformType::RemoveCVRef:

9998 case

UnaryTransformType::RemoveReference: {

10002 case

UnaryTransformType::RemoveConst:

10003 case

UnaryTransformType::RemoveCV:

10004 case

UnaryTransformType::RemoveRestrict:

10005 case

UnaryTransformType::RemoveVolatile: {

10009 case

UnaryTransformType::MakeSigned:

10010 case

UnaryTransformType::MakeUnsigned: {

10016 return

.isNull()

10028 int

DisallowedKind = -1;

10030

DisallowedKind = 1;

10032

DisallowedKind = 2;

10034

DisallowedKind = 3;

10036

DisallowedKind = 4;

10037 else if

(

.hasQualifiers())

10038

DisallowedKind = 5;

10040

DisallowedKind = 6;

10043

DisallowedKind = 7;

10045

DisallowedKind = 8;

10048

DisallowedKind = 9;

10050 if

(DisallowedKind != -1) {

10051 Diag

(