34 #include "llvm/ADT/SmallPtrSet.h" 35 #include "llvm/ADT/SmallString.h" 36 #include "llvm/ADT/StringSwitch.h" 37 #include "llvm/Support/ErrorHandling.h" 39 using namespace clang;
69 bool useExpansionLoc =
true;
71 case ParsedAttr::AT_ObjCGC:
74 case ParsedAttr::AT_ObjCOwnership:
80 useExpansionLoc =
false;
90 if (useExpansionLoc && loc.
isMacroID() && II) {
91 if (II->
isStr(
"strong")) {
93 }
else if (II->
isStr(
"weak")) {
98 S.
Diag(loc, diag::warn_type_attribute_wrong_type) << name << WhichType
104 #define OBJC_POINTER_TYPE_ATTRS_CASELIST \ 105 case ParsedAttr::AT_ObjCGC: \ 106 case ParsedAttr::AT_ObjCOwnership 109 #define CALLING_CONV_ATTRS_CASELIST \ 110 case ParsedAttr::AT_CDecl: \ 111 case ParsedAttr::AT_FastCall: \ 112 case ParsedAttr::AT_StdCall: \ 113 case ParsedAttr::AT_ThisCall: \ 114 case ParsedAttr::AT_RegCall: \ 115 case ParsedAttr::AT_Pascal: \ 116 case ParsedAttr::AT_SwiftCall: \ 117 case ParsedAttr::AT_VectorCall: \ 118 case ParsedAttr::AT_AArch64VectorPcs: \ 119 case ParsedAttr::AT_MSABI: \ 120 case ParsedAttr::AT_SysVABI: \ 121 case ParsedAttr::AT_Pcs: \ 122 case ParsedAttr::AT_IntelOclBicc: \ 123 case ParsedAttr::AT_PreserveMost: \ 124 case ParsedAttr::AT_PreserveAll 127 #define FUNCTION_TYPE_ATTRS_CASELIST \ 128 case ParsedAttr::AT_NSReturnsRetained: \ 129 case ParsedAttr::AT_NoReturn: \ 130 case ParsedAttr::AT_Regparm: \ 131 case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: \ 132 case ParsedAttr::AT_AnyX86NoCfCheck: \ 133 CALLING_CONV_ATTRS_CASELIST 136 #define MS_TYPE_ATTRS_CASELIST \ 137 case ParsedAttr::AT_Ptr32: \ 138 case ParsedAttr::AT_Ptr64: \ 139 case ParsedAttr::AT_SPtr: \ 140 case ParsedAttr::AT_UPtr 143 #define NULLABILITY_TYPE_ATTRS_CASELIST \ 144 case ParsedAttr::AT_TypeNonNull: \ 145 case ParsedAttr::AT_TypeNullable: \ 146 case ParsedAttr::AT_TypeNullUnspecified 151 class TypeProcessingState {
181 using TypeAttrPair = std::pair<const AttributedType*, const Attr*>;
183 bool AttrsForTypesSorted =
true;
187 llvm::DenseMap<const MacroQualifiedType *, SourceLocation> LocsForMacros;
195 : sema(sema), declarator(declarator),
197 hasSavedAttrs(
false), parsedNoDeref(
false) {}
199 Sema &getSema()
const {
207 bool isProcessingDeclSpec()
const {
211 unsigned getCurrentChunkIndex()
const {
215 void setCurrentChunkIndex(
unsigned idx) {
221 if (isProcessingDeclSpec())
222 return getMutableDeclSpec().getAttributes();
227 void saveDeclSpecAttrs() {
229 if (hasSavedAttrs)
return;
231 DeclSpec &spec = getMutableDeclSpec();
233 savedAttrs.push_back(&AL);
234 trivial &= savedAttrs.empty();
235 hasSavedAttrs =
true;
241 ignoredTypeAttrs.push_back(&attr);
247 for (
auto *
Attr : ignoredTypeAttrs)
257 AttrsForTypes.push_back({cast<AttributedType>(T.
getTypePtr()), A});
258 AttrsForTypesSorted =
false;
269 auto *NewAttrTy = cast<AttributedType>(T.
getTypePtr());
270 for (TypeAttrPair &A : AttrsForTypes) {
271 if (A.first == AttrTy)
274 AttrsForTypesSorted =
false;
281 if (!AttrsForTypesSorted) {
282 llvm::stable_sort(AttrsForTypes, llvm::less_first());
283 AttrsForTypesSorted =
true;
288 for (
auto It = std::partition_point(
289 AttrsForTypes.begin(), AttrsForTypes.end(),
290 [=](
const TypeAttrPair &A) {
return A.first < AT; });
291 It != AttrsForTypes.end() && It->first == AT; ++It) {
294 It->second =
nullptr;
299 llvm_unreachable(
"no Attr* for AttributedType*");
304 auto FoundLoc = LocsForMacros.find(MQT);
305 assert(FoundLoc != LocsForMacros.end() &&
306 "Unable to find macro expansion location for MacroQualifedType");
307 return FoundLoc->second;
312 LocsForMacros[MQT] = Loc;
315 void setParsedNoDeref(
bool parsed) { parsedNoDeref = parsed; }
317 bool didParseNoDeref()
const {
return parsedNoDeref; }
319 ~TypeProcessingState() {
322 restoreDeclSpecAttrs();
326 DeclSpec &getMutableDeclSpec()
const {
330 void restoreDeclSpecAttrs() {
331 assert(hasSavedAttrs);
333 getMutableDeclSpec().getAttributes().clearListOnly();
335 getMutableDeclSpec().getAttributes().addAtEnd(AL);
374 if (attr.
getKind() == ParsedAttr::AT_ObjCGC)
376 assert(attr.
getKind() == ParsedAttr::AT_ObjCOwnership);
391 bool onlyBlockPointers) {
397 for (; i != 0; --
i) {
399 switch (fnChunk.
Kind) {
415 for (--i; i != 0; --
i) {
417 switch (ptrChunk.
Kind) {
427 if (onlyBlockPointers)
436 llvm_unreachable(
"bad declarator chunk kind");
442 llvm_unreachable(
"bad declarator chunk kind");
459 Declarator &declarator = state.getDeclarator();
462 for (
unsigned i = state.getCurrentChunkIndex();
i != 0; --
i) {
464 switch (chunk.
Kind) {
470 if (state.isProcessingDeclSpec() &&
471 attr.
getKind() == ParsedAttr::AT_ObjCOwnership)
474 if (!destChunk) destChunk = &chunk;
487 if (state.isProcessingDeclSpec() &&
488 attr.
getKind() == ParsedAttr::AT_ObjCOwnership) {
515 Declarator &declarator = state.getDeclarator();
519 unsigned innermost = -1U;
520 bool considerDeclSpec =
true;
523 switch (chunk.
Kind) {
537 considerDeclSpec =
false;
545 if (considerDeclSpec) {
550 state.saveDeclSpecAttrs();
559 if (innermost != -1U) {
567 state.addIgnoredTypeAttr(attr);
576 Declarator &declarator = state.getDeclarator();
580 for (
unsigned i = state.getCurrentChunkIndex();
i != 0; --
i) {
582 switch (chunk.
Kind) {
608 Declarator &declarator = state.getDeclarator();
627 state.saveDeclSpecAttrs();
634 state.getDeclarator().getAttributes());
640 state, attr, state.getCurrentAttributes(), declSpecType))
645 state.addIgnoredTypeAttr(attr);
653 Declarator &declarator = state.getDeclarator();
663 state.addIgnoredTypeAttr(attr);
678 assert(!state.getDeclarator().getAttributes().empty() &&
679 "declarator has no attrs!");
687 if (attr.isCXX11Attribute())
690 switch (attr.getKind()) {
707 case ParsedAttr::AT_ObjCKindOf:
720 Declarator &declarator = state.getDeclarator();
766 None, loc, loc, declarator));
781 typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc;
786 if (!(RemoveTQs & Qual.first))
790 if (TypeQuals & Qual.first)
791 S.
Diag(Qual.second, DiagID)
796 TypeQuals &= ~Qual.first;
810 if (AL.isInvalid() || !AL.isTypeAttr())
813 diag::warn_block_literal_attributes_on_omitted_return_type)
815 ToBeRemoved.push_back(&AL);
825 diag::warn_block_literal_qualifiers_on_omitted_return_type);
835 bool failOnError =
false) {
838 if (!objcObjectType || !objcObjectType->getInterface()) {
839 S.
Diag(loc, diag::err_objc_type_args_non_class)
852 S.
Diag(loc, diag::err_objc_type_args_non_parameterized_class)
863 if (objcObjectType->isSpecialized()) {
864 S.
Diag(loc, diag::err_objc_type_args_specialized_class)
876 unsigned numTypeParams = typeParams->
size();
877 bool anyPackExpansions =
false;
878 for (
unsigned i = 0, n = typeArgs.size();
i != n; ++
i) {
886 bool diagnosed =
false;
889 rangeToRemove = attr.getLocalSourceRange();
890 if (attr.getTypePtr()->getImmediateNullability()) {
891 typeArg = attr.
getTypePtr()->getModifiedType();
892 S.
Diag(attr.getBeginLoc(),
893 diag::err_objc_type_arg_explicit_nullability)
900 S.
Diag(qual.getBeginLoc(), diag::err_objc_type_arg_qualified)
909 finalTypeArgs.push_back(typeArg);
912 anyPackExpansions =
true;
916 if (!anyPackExpansions) {
917 if (
i < numTypeParams) {
918 typeParam = typeParams->
begin()[
i];
921 S.
Diag(loc, diag::err_objc_type_args_wrong_arity)
924 << (unsigned)typeArgs.size()
942 assert(anyPackExpansions &&
"Too many arguments?");
951 if (typeArgObjC->isObjCIdType()) {
954 if (boundObjC->isObjCIdType())
963 diag::err_objc_type_arg_does_not_match_bound)
980 assert(anyPackExpansions &&
"Too many arguments?");
991 diag::err_objc_type_arg_does_not_match_bound)
1009 diag::err_objc_type_arg_not_id_compatible)
1019 if (!anyPackExpansions && finalTypeArgs.size() != numTypeParams) {
1020 S.
Diag(loc, diag::err_objc_type_args_wrong_arity)
1021 << (typeArgs.size() < typeParams->
size())
1023 << (unsigned)finalTypeArgs.size()
1024 << (unsigned)numTypeParams;
1045 if (!Protocols.empty()) {
1051 <<
SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
1052 if (FailOnError) Result =
QualType();
1054 if (FailOnError && Result.
isNull())
1072 if (!TypeArgs.empty()) {
1077 if (FailOnError && Result.
isNull())
1081 if (!Protocols.empty()) {
1086 Diag(Loc, diag::err_invalid_protocol_qualifiers)
1087 <<
SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
1088 if (FailOnError) Result =
QualType();
1090 if (FailOnError && Result.
isNull())
1117 auto ObjCObjectTL = ObjCObjectPointerTL.getPointeeLoc()
1127 ObjCObjectTL.setProtocolLAngleLoc(lAngleLoc);
1128 ObjCObjectTL.setProtocolRAngleLoc(rAngleLoc);
1129 for (
unsigned i = 0, n = protocols.size();
i != n; ++
i)
1130 ObjCObjectTL.setProtocolLoc(
i, protocolLocs[
i]);
1133 return CreateParsedType(Result, ResultTInfo);
1148 QualType T = GetTypeFromParser(BaseType, &BaseTypeInfo);
1158 for (
unsigned i = 0, n = TypeArgs.size();
i != n; ++
i) {
1160 QualType TypeArg = GetTypeFromParser(TypeArgs[
i], &TypeArgInfo);
1162 ActualTypeArgInfos.clear();
1166 assert(TypeArgInfo &&
"No type source info?");
1167 ActualTypeArgInfos.push_back(TypeArgInfo);
1173 TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc,
1177 ProtocolLocs, ProtocolRAngleLoc,
1192 ResultTL = ObjCObjectPointerTL.getPointeeLoc();
1197 if (OTPTL.getNumProtocols() > 0) {
1198 assert(OTPTL.getNumProtocols() == Protocols.size());
1199 OTPTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1200 OTPTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1201 for (
unsigned i = 0, n = Protocols.size();
i != n; ++
i)
1202 OTPTL.setProtocolLoc(
i, ProtocolLocs[
i]);
1206 return CreateParsedType(Result, ResultTInfo);
1212 if (ObjCObjectTL.getNumTypeArgs() > 0) {
1213 assert(ObjCObjectTL.getNumTypeArgs() == ActualTypeArgInfos.size());
1215 ObjCObjectTL.setTypeArgsRAngleLoc(TypeArgsRAngleLoc);
1216 for (
unsigned i = 0, n = ActualTypeArgInfos.size();
i != n; ++
i)
1217 ObjCObjectTL.setTypeArgTInfo(
i, ActualTypeArgInfos[
i]);
1224 if (ObjCObjectTL.getNumProtocols() > 0) {
1225 assert(ObjCObjectTL.getNumProtocols() == Protocols.size());
1226 ObjCObjectTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1227 ObjCObjectTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1228 for (
unsigned i = 0, n = Protocols.size();
i != n; ++
i)
1229 ObjCObjectTL.setProtocolLoc(
i, ProtocolLocs[
i]);
1236 ObjCObjectTL.setHasBaseTypeAsWritten(
true);
1237 if (ObjCObjectTL.getType() == T)
1238 ObjCObjectTL.getBaseLoc().initializeFullCopy(BaseTypeInfo->
getTypeLoc());
1240 ObjCObjectTL.getBaseLoc().initialize(Context, Loc);
1243 return CreateParsedType(Result, ResultTInfo);
1246 static OpenCLAccessAttr::Spelling
1249 if (AL.getKind() == ParsedAttr::AT_OpenCLAccess)
1250 return static_cast<OpenCLAccessAttr::Spelling>(AL.getSemanticSpelling());
1251 return OpenCLAccessAttr::Keyword_read_only;
1264 Sema &S = state.getSema();
1265 Declarator &declarator = state.getDeclarator();
1285 "Unknown TSS value");
1299 "Unknown TSS value");
1308 "Unknown TSS value");
1313 "Unknown TSS value");
1318 "Unknown TSS value");
1350 S.
Diag(DeclLoc, diag::ext_missing_declspec)
1360 S.
Diag(DeclLoc, diag::err_missing_type_specifier)
1367 }
else if ((S.
getLangOpts().OpenCLVersion >= 200 ||
1370 S.
Diag(DeclLoc, diag::err_missing_actual_pipe_type)
1374 S.
Diag(DeclLoc, diag::ext_missing_type_specifier)
1394 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1413 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1434 llvm_unreachable(
"Unable to specify long long as _Accum width");
1457 llvm_unreachable(
"Unable to specify long long as _Fract width");
1509 Result = Context.
IntTy;
1520 Result = Context.
IntTy;
1544 "Can't handle qualifiers on typedef names yet!");
1546 if (Result.isNull()) {
1556 assert(!Result.isNull() &&
"Didn't get a type for typeof?");
1557 if (!Result->isDependentType())
1565 assert(E &&
"Didn't get an expression for typeof?");
1568 if (Result.isNull()) {
1569 Result = Context.
IntTy;
1576 assert(E &&
"Didn't get an expression for decltype?");
1579 if (Result.isNull()) {
1580 Result = Context.
IntTy;
1587 assert(!Result.isNull() &&
"Didn't get a type for __underlying_type?");
1591 if (Result.isNull()) {
1592 Result = Context.
IntTy;
1616 assert(!Result.isNull() &&
"Didn't get a type for _Atomic?");
1618 if (Result.isNull()) {
1619 Result = Context.
IntTy;
1624 #define GENERIC_IMAGE_TYPE(ImgType, Id) \ 1625 case DeclSpec::TST_##ImgType##_t: \ 1626 switch (getImageAccess(DS.getAttributes())) { \ 1627 case OpenCLAccessAttr::Keyword_write_only: \ 1628 Result = Context.Id##WOTy; \ 1630 case OpenCLAccessAttr::Keyword_read_write: \ 1631 Result = Context.Id##RWTy; \ 1633 case OpenCLAccessAttr::Keyword_read_only: \ 1634 Result = Context.Id##ROTy; \ 1638 #include "clang/Basic/OpenCLImageTypes.def" 1641 Result = Context.
IntTy;
1648 declarator.setInvalidType(
true);
1654 if (DS.isTypeSpecSat() && !IsFixedPointType)
1655 S.
Diag(DS.getTypeSpecSatLoc(), diag::err_invalid_saturation_spec)
1656 << DS.getSpecifierName(DS.getTypeSpecType(),
1662 S.
Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex);
1664 }
else if (DS.isTypeAltiVecVector()) {
1666 assert(typeSize > 0 &&
"type size for vector must be greater than 0 bits");
1668 if (DS.isTypeAltiVecPixel())
1670 else if (DS.isTypeAltiVecBool())
1677 S.
Diag(DS.getTypeSpecComplexLoc(), diag::err_imaginary_not_supported);
1688 if (!DS.isTypeSpecPipe())
1692 if (
unsigned TypeQuals = DS.getTypeQualifiers()) {
1701 if (TypeQuals &&
Result->isFunctionType()) {
1705 ? diag::warn_typecheck_function_qualifiers_ignored
1706 : diag::warn_typecheck_function_qualifiers_unspecified);
1719 if (TypeQuals &&
Result->isReferenceType()) {
1721 S, DS, TypeQuals,
Result,
1723 diag::warn_typecheck_reference_qualifiers);
1730 && TypeQuals &
Result.getCVRQualifiers()) {
1732 S.
Diag(DS.getConstSpecLoc(), diag::ext_duplicate_declspec)
1737 S.
Diag(DS.getVolatileSpecLoc(), diag::ext_duplicate_declspec)
1749 declarator.setInvalidType(
true);
1754 assert(!
Result.isNull() &&
"This function should not return a null type");
1779 unsigned DiagID = 0;
1795 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
1799 DiagID = diag::err_typecheck_invalid_restrict_not_pointer;
1813 unsigned CVRAU,
const DeclSpec *DS) {
1848 return BuildQualifiedType(T, Loc, Split.
Quals);
1853 return BuildQualifiedType(T, Loc, Q, DS);
1900 diag::err_arc_indirect_no_ownership, type, isReference));
1902 S.
Diag(loc, diag::err_arc_indirect_no_ownership) << type << isReference;
1906 assert(implicitLifetime &&
"didn't infer any lifetime!");
1959 S.
Diag(Loc, diag::err_compound_qualified_function_type)
1982 Diag(Loc, diag::err_illegal_decl_pointer_to_reference)
1988 Diag(Loc, diag::err_opencl_function_pointer);
1998 if (getLangOpts().ObjCAutoRefCount)
2022 "Unresolved overloaded function type");
2050 Diag(Loc, diag::err_reference_to_void);
2058 if (getLangOpts().ObjCAutoRefCount)
2104 S.
Diag(Loc, diag::ext_vla_folded_to_constant) << SR;
2129 Expr *ArraySize,
unsigned Quals,
2146 Diag(Loc, diag::err_illegal_decl_array_of_references)
2152 Diag(Loc, diag::err_illegal_decl_array_incomplete_type) << T;
2156 if (RequireNonAbstractType(Brackets.
getBegin(), T,
2157 diag::err_array_of_abstract_type))
2164 if (!MPTy->getClass()->isDependentType())
2165 (
void)isCompleteType(Loc, T);
2170 if (RequireCompleteType(Loc, T,
2171 diag::err_illegal_decl_array_incomplete_type))
2176 Diag(Loc, diag::err_illegal_decl_array_of_functions)
2184 if (EltTy->getDecl()->hasFlexibleArrayMember())
2185 Diag(Loc, diag::ext_flexible_array_in_array) << T;
2187 Diag(Loc, diag::err_objc_array_of_interfaces) << T;
2195 ArraySize = Result.
get();
2199 if (ArraySize && !ArraySize->
isRValue()) {
2204 ArraySize = Result.
get();
2230 if (getLangOpts().CPlusPlus11 &&
2244 if (ConstVal.isSigned() && ConstVal.isNegative()) {
2249 Diag(ArraySize->
getBeginLoc(), diag::err_typecheck_negative_array_size)
2253 if (ConstVal == 0) {
2257 ? diag::err_typecheck_zero_array_size
2258 : diag::ext_typecheck_zero_array_size)
2263 diag::warn_typecheck_zero_static_array_size)
2270 unsigned ActiveSizeBits
2284 Diag(Loc, diag::err_opencl_vla);
2290 targetDiag(Loc, (getLangOpts().CUDA && getLangOpts().CUDAIsDevice)
2291 ? diag::err_cuda_vla
2292 : diag::err_vla_unsupported)
2293 << ((getLangOpts().CUDA && getLangOpts().CUDAIsDevice)
2294 ? CurrentCUDATarget()
2295 : CFT_InvalidTarget);
2299 if (!getLangOpts().C99) {
2302 if (isSFINAEContext()) {
2303 Diag(Loc, diag::err_vla_in_sfinae);
2308 Diag(Loc, diag::ext_vla);
2311 getLangOpts().
CPlusPlus? diag::err_c99_array_usage_cxx
2312 : diag::ext_c99_array_usage) << ASM;
2317 Diag(Loc, diag::warn_vla_used);
2323 if (getLangOpts().
OpenCL) {
2327 Diag(Loc, diag::err_opencl_invalid_type_array) << ArrType;
2342 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << CurType;
2350 llvm::APSInt VecSize(32);
2352 Diag(AttrLoc, diag::err_attribute_argument_type)
2362 unsigned VectorSize =
static_cast<unsigned>(VecSize.getZExtValue() * 8);
2363 unsigned TypeSize =
static_cast<unsigned>(Context.
getTypeSize(CurType));
2365 if (VectorSize == 0) {
2371 if (VectorSize % TypeSize) {
2372 Diag(AttrLoc, diag::err_attribute_invalid_size)
2378 Diag(AttrLoc, diag::err_attribute_size_too_large)
2383 return Context.
getVectorType(CurType, VectorSize / TypeSize,
2402 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << T;
2407 llvm::APSInt vecSize(32);
2409 Diag(AttrLoc, diag::err_attribute_argument_type)
2417 unsigned vectorSize =
static_cast<unsigned>(vecSize.getZExtValue());
2419 if (vectorSize == 0) {
2420 Diag(AttrLoc, diag::err_attribute_zero_size)
2426 Diag(AttrLoc, diag::err_attribute_size_too_large)
2439 Diag(Loc, diag::err_func_returning_array_function)
2445 if (T->
isHalfType() && !getLangOpts().HalfArgsAndReturns) {
2446 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 <<
2454 Diag(Loc, diag::err_object_cannot_be_passed_returned_by_value)
2461 checkNonTrivialCUnion(T, Loc, NTCUC_FunctionReturn,
2462 NTCUK_Destruct|NTCUK_Copy);
2475 bool hasCheckedSwiftCall =
false;
2476 auto checkForSwiftCC = [&](
unsigned paramIndex) {
2478 if (hasCheckedSwiftCall)
return;
2479 hasCheckedSwiftCall =
true;
2481 S.
Diag(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall)
2485 for (
size_t paramIndex = 0, numParams = paramTypes.size();
2486 paramIndex != numParams; ++paramIndex) {
2495 checkForSwiftCC(paramIndex);
2496 if (paramIndex != 0 &&
2499 S.
Diag(getParamLoc(paramIndex),
2500 diag::err_swift_indirect_result_not_first);
2505 checkForSwiftCC(paramIndex);
2510 checkForSwiftCC(paramIndex);
2511 if (paramIndex == 0 ||
2514 S.
Diag(getParamLoc(paramIndex),
2515 diag::err_swift_error_result_not_after_swift_context);
2519 llvm_unreachable(
"bad ABI kind");
2527 bool Invalid =
false;
2529 Invalid |= CheckFunctionReturnType(T, Loc);
2531 for (
unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) {
2535 Diag(Loc, diag::err_param_with_void_type);
2537 }
else if (ParamType->
isHalfType() && !getLangOpts().HalfArgsAndReturns) {
2539 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<
2544 ParamTypes[Idx] = ParamType;
2549 [=](
unsigned i) {
return Loc; });
2554 checkNSReturnsRetainedReturnType(Loc, T);
2577 if (CheckDistantExceptionSpec(T)) {
2578 Diag(Loc, diag::err_distant_exception_spec);
2585 Diag(Loc, diag::err_illegal_decl_mempointer_to_reference)
2591 Diag(Loc, diag::err_illegal_decl_mempointer_to_void)
2597 Diag(Loc, diag::err_mempointer_in_nonclass_type) << Class;
2607 adjustMemberFunctionCC(T,
false, IsCtorOrDtor, Loc);
2627 Diag(Loc, diag::err_nonfunction_block_type);
2640 if (TInfo) *TInfo =
nullptr;
2645 if (
const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
2646 QT = LIT->getType();
2647 DI = LIT->getTypeSourceInfo();
2650 if (TInfo) *TInfo = DI;
2656 unsigned chunkIndex);
2663 Sema &S = state.getSema();
2664 Declarator &declarator = state.getDeclarator();
2670 unsigned outermostPointerIndex = 0;
2672 unsigned numPointers = 0;
2674 unsigned chunkIndex =
i;
2676 switch (chunk.
Kind) {
2686 outermostPointerIndex = chunkIndex;
2694 if (numPointers != 1)
return;
2696 outermostPointerIndex = chunkIndex;
2697 isBlockPointer =
true;
2714 if (numPointers == 1) {
2732 }
else if (numPointers == 2) {
2745 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership)
2749 outermostPointerIndex);
2771 }
const QualKinds[5] = {
2780 unsigned NumQuals = 0;
2785 for (
auto &E : QualKinds) {
2786 if (Quals & E.Mask) {
2787 if (!QualStr.empty()) QualStr +=
' ';
2795 getSourceManager().isBeforeInTranslationUnit(QualLoc, Loc))
2804 << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];
2810 unsigned FunctionChunkIndex) {
2820 for (
unsigned OuterChunkIndex = FunctionChunkIndex + 1,
2822 OuterChunkIndex !=
End; ++OuterChunkIndex) {
2824 switch (OuterChunk.
Kind) {
2831 diag::warn_qual_return_type,
2857 llvm_unreachable(
"unknown declarator chunk kind");
2880 Sema &SemaRef = state.getSema();
2883 ReturnTypeInfo =
nullptr;
2886 TagDecl *OwnedTagDecl =
nullptr;
2937 bool IsCXXAutoType =
2939 bool IsDeducedReturnType =
false;
2960 assert(LSI &&
"No LambdaScopeInfo on the stack!");
2962 const unsigned AutoParameterPosition = LSI->
TemplateParams.size();
2972 TemplateParameterDepth, AutoParameterPosition,
2973 nullptr,
false, IsParameterPack);
2980 T = state.ReplaceAutoType(
2989 switch (cast<TagDecl>(SemaRef.
CurContext)->getTagKind()) {
2990 case TTK_Enum: llvm_unreachable(
"unhandled tag kind");
2992 case TTK_Union: Error = Cxx ? 3 : 4;
break;
3005 if (isa<DeducedTemplateSpecializationType>(Deduced))
3016 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
3030 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3032 IsDeducedReturnType =
true;
3035 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
3037 IsDeducedReturnType =
true;
3040 if (isa<DeducedTemplateSpecializationType>(Deduced))
3058 if (!IsCXXAutoType && !isa<DeducedTemplateSpecializationType>(Deduced))
3072 (!SemaRef.
getLangOpts().CPlusPlus11 || !IsCXXAutoType))
3075 bool HaveTrailing =
false;
3083 if (SemaRef.
getLangOpts().CPlusPlus11 && IsCXXAutoType &&
3085 HaveTrailing =
true;
3102 assert(isa<DeducedTemplateSpecializationType>(Deduced) &&
3103 "unknown auto type");
3110 SemaRef.
Diag(AutoRange.
getBegin(), diag::err_auto_not_allowed)
3112 <<
QualType(Deduced, 0) << AutoRange;
3113 if (
auto *TD = TN.getAsTemplateDecl())
3114 SemaRef.
Diag(TD->getLocation(), diag::note_template_decl_here);
3118 }
else if (!HaveTrailing &&
3125 ? diag::warn_cxx11_compat_generic_lambda
3126 : IsDeducedReturnType
3127 ? diag::warn_cxx11_compat_deduced_return_type
3128 : diag::warn_cxx98_compat_auto_type_specifier)
3137 unsigned DiagID = 0;
3143 llvm_unreachable(
"parser should not have allowed this");
3159 DiagID = diag::err_type_defined_in_alias_template;
3170 DiagID = diag::err_type_defined_in_type_specifier;
3179 DiagID = diag::err_type_defined_in_param_type;
3185 DiagID = diag::err_type_defined_in_condition;
3196 assert(!T.
isNull() &&
"This function should not return a null type");
3205 assert(FTI.
isAmbiguous &&
"no direct-initializer / function ambiguity");
3236 FTI.
NumParams ? diag::warn_parens_disambiguated_as_function_declaration
3237 : diag::warn_empty_parens_are_function_decl)
3248 if (
Comma.getFileID() != Name.getFileID() ||
3249 Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) {
3256 Result.suppressDiagnostics();
3269 S.
Diag(B, diag::note_additional_parens_for_variable_declaration)
3284 S.
Diag(DeclType.
Loc, diag::note_empty_parens_default_ctor)
3289 if (Init.empty() && S.
LangOpts.CPlusPlus11)
3292 S.
Diag(DeclType.
Loc, diag::note_empty_parens_zero_initialize)
3303 "do not have redundant top-level parentheses");
3312 bool CouldBeTemporaryObject =
3319 bool StartsWithDeclaratorId =
true;
3327 StartsWithDeclaratorId =
false;
3332 CouldBeTemporaryObject =
false;
3340 CouldBeTemporaryObject =
false;
3341 StartsWithDeclaratorId =
false;
3351 CouldBeTemporaryObject =
false;
3358 CouldBeTemporaryObject =
false;
3359 StartsWithDeclaratorId =
false;
3369 if (CouldBeTemporaryObject) {
3373 CouldBeTemporaryObject =
false;
3374 Result.suppressDiagnostics();
3379 if (!CouldBeTemporaryObject) {
3392 S.
Diag(Paren.
Loc, diag::warn_redundant_parens_around_declarator)
3398 S.
Diag(Paren.
Loc, diag::warn_parens_disambiguated_as_variable_declaration)
3401 if (!RD || !RD->hasDefinition() || RD->hasNonTrivialDestructor())
3402 S.
Diag(Paren.
Loc, diag::note_raii_guard_add_name)
3407 S.
Diag(D.
getBeginLoc(), diag::note_function_style_cast_add_parentheses)
3410 S.
Diag(Paren.
Loc, diag::note_remove_parens_for_variable_declaration)
3426 switch (AL.getKind()) {
3444 bool IsCXXInstanceMethod =
false;
3450 unsigned I = ChunkIndex;
3451 bool FoundNonParen =
false;
3452 while (I && !FoundNonParen) {
3455 FoundNonParen =
true;
3458 if (FoundNonParen) {
3461 IsCXXInstanceMethod =
3466 IsCXXInstanceMethod =
true;
3473 IsCXXInstanceMethod =
3481 IsCXXInstanceMethod);
3489 if (AL.getKind() == ParsedAttr::AT_OpenCLKernel) {
3511 switch (nullability) {
3513 if (!Ident__Nonnull)
3514 Ident__Nonnull = PP.getIdentifierInfo(
"_Nonnull");
3515 return Ident__Nonnull;
3518 if (!Ident__Nullable)
3519 Ident__Nullable = PP.getIdentifierInfo(
"_Nullable");
3520 return Ident__Nullable;
3523 if (!Ident__Null_unspecified)
3524 Ident__Null_unspecified = PP.getIdentifierInfo(
"_Null_unspecified");
3525 return Ident__Null_unspecified;
3527 llvm_unreachable(
"Unknown nullability kind.");
3533 Ident_NSError = PP.getIdentifierInfo(
"NSError");
3535 return Ident_NSError;
3542 if (AL.getKind() == ParsedAttr::AT_TypeNonNull ||
3543 AL.getKind() == ParsedAttr::AT_TypeNullable ||
3544 AL.getKind() == ParsedAttr::AT_TypeNullUnspecified)
3561 MaybePointerToCFRef,
3565 NSErrorPointerPointer,
3588 unsigned numNormalPointers = 0;
3592 return PointerDeclaratorKind::NonPointer;
3597 switch (chunk.
Kind) {
3599 if (numNormalPointers == 0)
3600 wrappingKind = PointerWrappingDeclaratorKind::Array;
3609 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3610 : PointerDeclaratorKind::SingleLevelPointer;
3616 if (numNormalPointers == 0)
3617 wrappingKind = PointerWrappingDeclaratorKind::Reference;
3621 ++numNormalPointers;
3622 if (numNormalPointers > 2)
3623 return PointerDeclaratorKind::MultiLevelPointer;
3629 unsigned numTypeSpecifierPointers = 0;
3633 ++numNormalPointers;
3635 if (numNormalPointers > 2)
3636 return PointerDeclaratorKind::MultiLevelPointer;
3639 ++numTypeSpecifierPointers;
3645 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3646 : PointerDeclaratorKind::SingleLevelPointer;
3651 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3652 : PointerDeclaratorKind::SingleLevelPointer;
3657 ++numNormalPointers;
3658 ++numTypeSpecifierPointers;
3661 if (
auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) {
3663 numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3664 return PointerDeclaratorKind::NSErrorPointerPointer;
3673 if (objcClass->getInterface()->getIdentifier() == S.
getNSErrorIdent()) {
3674 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2)
3675 return PointerDeclaratorKind::NSErrorPointerPointer;
3682 if (numNormalPointers == 0)
3683 return PointerDeclaratorKind::NonPointer;
3688 bool isCFError =
false;
3699 if (
auto bridgeAttr = recordDecl->
getAttr<ObjCBridgeAttr>())
3700 bridgedType = bridgeAttr->getBridgedType();
3701 else if (
auto bridgeAttr =
3702 recordDecl->
getAttr<ObjCBridgeMutableAttr>())
3703 bridgedType = bridgeAttr->getBridgedType();
3713 if (isCFError && numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3714 return PointerDeclaratorKind::CFErrorRefPointer;
3722 switch (numNormalPointers) {
3724 return PointerDeclaratorKind::NonPointer;
3727 return PointerDeclaratorKind::SingleLevelPointer;
3730 return PointerDeclaratorKind::MaybePointerToCFRef;
3733 return PointerDeclaratorKind::MultiLevelPointer;
3742 if (ctx->isFunctionOrMethod())
3745 if (ctx->isFileContext())
3756 bool invalid =
false;
3758 if (invalid || !sloc.
isFile())
3784 if (!FixItLoc.
isValid() || FixItLoc == PointerLoc)
3793 InsertionTextBuf +=
" ";
3794 StringRef InsertionText = InsertionTextBuf.str();
3797 InsertionText = InsertionText.drop_back();
3798 }
else if (NextChar[-1] ==
'[') {
3799 if (NextChar[0] ==
']')
3800 InsertionText = InsertionText.drop_back().drop_front();
3802 InsertionText = InsertionText.drop_front();
3805 InsertionText = InsertionText.drop_back().drop_front();
3817 if (PointerKind == SimplePointerKind::Array) {
3818 S.
Diag(PointerLoc, diag::warn_nullability_missing_array);
3820 S.
Diag(PointerLoc, diag::warn_nullability_missing)
3821 <<
static_cast<unsigned>(PointerKind);
3824 auto FixItLoc = PointerEndLoc.
isValid() ? PointerEndLoc : PointerLoc;
3825 if (FixItLoc.isMacroID())
3829 auto Diag = S.
Diag(FixItLoc, diag::note_nullability_fix_it);
3831 Diag << static_cast<unsigned>(PointerKind);
3860 if (pointerKind == SimplePointerKind::Array)
3861 diagKind = diag::warn_nullability_missing_array;
3863 diagKind = diag::warn_nullability_missing;
3869 fileNullability.
PointerKind =
static_cast<unsigned>(pointerKind);
3916 unsigned i = endIndex;
3944 template<
typename AttrT>
3955 return createSimpleAttr<TypeNonNullAttr>(Ctx, Attr);
3958 return createSimpleAttr<TypeNullableAttr>(Ctx, Attr);
3961 return createSimpleAttr<TypeNullUnspecifiedAttr>(Ctx, Attr);
3963 llvm_unreachable(
"unknown NullabilityKind");
3974 if (ASOld != ASNew) {
3975 S.
Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
3980 diag::warn_attribute_address_multiple_identical_qualifiers);
3996 Sema &S = state.getSema();
4006 bool IsTypedefName =
4022 bool IsClassTemplateDeduction = isa<DeducedTemplateSpecializationType>(DT);
4025 unsigned Index = E - I - 1;
4027 unsigned DiagId = IsClassTemplateDeduction
4028 ? diag::err_deduced_class_template_compound_type
4029 : diag::err_decltype_auto_compound_type;
4030 unsigned DiagKind = 0;
4031 switch (DeclChunk.
Kind) {
4034 if (IsClassTemplateDeduction) {
4040 if (IsClassTemplateDeduction) {
4048 DiagId = diag::err_decltype_auto_function_declarator_not_declaration;
4066 S.
Diag(DeclChunk.
Loc, DiagId) << DiagKind;
4075 bool inferNullabilityCS =
false;
4076 bool inferNullabilityInnerOnly =
false;
4077 bool inferNullabilityInnerOnlyComplete =
false;
4080 bool inAssumeNonNullRegion =
false;
4082 if (assumeNonNullLoc.
isValid()) {
4083 inAssumeNonNullRegion =
true;
4097 } complainAboutMissingNullability = CAMN_No;
4098 unsigned NumPointersRemaining = 0;
4101 if (IsTypedefName) {
4105 complainAboutMissingNullability = CAMN_InnerPointers;
4110 ++NumPointersRemaining;
4115 switch (chunk.
Kind) {
4123 ++NumPointersRemaining;
4131 ++NumPointersRemaining;
4137 switch (
auto context = state.getDeclarator().getContext()) {
4143 isFunctionOrMethod =
true;
4148 complainAboutMissingNullability = CAMN_No;
4153 if (state.getDeclarator().isObjCWeakProperty() && inAssumeNonNullRegion) {
4162 complainAboutMissingNullability = CAMN_Yes;
4167 case PointerDeclaratorKind::NonPointer:
4168 case PointerDeclaratorKind::MultiLevelPointer:
4172 case PointerDeclaratorKind::SingleLevelPointer:
4174 if (inAssumeNonNullRegion) {
4175 complainAboutInferringWithinChunk = wrappingKind;
4177 inferNullabilityCS =
4183 case PointerDeclaratorKind::CFErrorRefPointer:
4184 case PointerDeclaratorKind::NSErrorPointerPointer:
4187 if (isFunctionOrMethod && inAssumeNonNullRegion)
4191 case PointerDeclaratorKind::MaybePointerToCFRef:
4192 if (isFunctionOrMethod) {
4196 auto hasCFReturnsAttr =
4198 return AttrList.hasAttribute(ParsedAttr::AT_CFReturnsRetained) ||
4199 AttrList.hasAttribute(ParsedAttr::AT_CFReturnsNotRetained);
4203 hasCFReturnsAttr(InnermostChunk->getAttrs()) ||
4206 inferNullabilityInnerOnly =
true;
4216 complainAboutMissingNullability = CAMN_Yes;
4242 auto isVaList = [&S](
QualType T) ->
bool {
4248 if (typedefTy->getDecl() == vaListTypedef)
4250 if (
auto *
name = typedefTy->getDecl()->getIdentifier())
4251 if (
name->isStr(
"va_list"))
4253 typedefTy = typedefTy->desugar()->getAs<
TypedefType>();
4254 }
while (typedefTy);
4260 auto inferPointerNullability =
4265 if (NumPointersRemaining > 0)
4266 --NumPointersRemaining;
4273 if (inferNullability && !inferNullabilityInnerOnlyComplete) {
4281 attrs.addAtEnd(nullabilityAttr);
4283 if (inferNullabilityCS) {
4284 state.getDeclarator().getMutableDeclSpec().getObjCQualifiers()
4288 if (pointerLoc.isValid() &&
4289 complainAboutInferringWithinChunk !=
4292 S.
Diag(pointerLoc, diag::warn_nullability_inferred_on_nested_type);
4293 Diag << static_cast<int>(complainAboutInferringWithinChunk);
4297 if (inferNullabilityInnerOnly)
4298 inferNullabilityInnerOnlyComplete =
true;
4299 return nullabilityAttr;
4304 switch (complainAboutMissingNullability) {
4308 case CAMN_InnerPointers:
4309 if (NumPointersRemaining == 0)
4326 if (NumPointersRemaining > 0)
4327 --NumPointersRemaining;
4331 pointerKind = SimplePointerKind::BlockPointer;
4333 pointerKind = SimplePointerKind::MemberPointer;
4335 if (
auto *attr = inferPointerNullability(
4340 T = state.getAttributedType(
4346 if (complainAboutMissingNullability == CAMN_Yes &&
4355 bool ExpectNoDerefChunk =
4356 state.getCurrentAttributes().hasAttribute(ParsedAttr::AT_NoDeref);
4362 unsigned chunkIndex = e -
i - 1;
4363 state.setCurrentChunkIndex(chunkIndex);
4366 switch (DeclType.
Kind) {
4374 if (!LangOpts.Blocks)
4375 S.
Diag(DeclType.
Loc, diag::err_blocks_disable) << LangOpts.OpenCL;
4378 inferPointerNullability(SimplePointerKind::BlockPointer, DeclType.
Loc,
4380 state.getDeclarator().getAttributePool());
4386 if (LangOpts.OpenCL)
4401 inferPointerNullability(SimplePointerKind::Pointer, DeclType.
Loc,
4403 state.getDeclarator().getAttributePool());
4415 if (LangOpts.OpenCL) {
4416 if (T->isImageType() || T->isSamplerT() || T->isPipeType() ||
4417 T->isBlockPointerType()) {
4462 S.
Diag(DeclType.
Loc, diag::err_array_star_outside_prototype);
4473 S.
Diag(DeclType.
Loc, diag::err_array_static_outside_prototype) <<
4485 S.
Diag(DeclType.
Loc, diag::err_array_static_not_outermost) <<
4500 S.
Diag(DeclType.
Loc, diag::err_illegal_decl_array_of_auto)
4508 if (complainAboutMissingNullability == CAMN_Yes &&
4525 IsQualifiedFunction =
4538 ? diag::err_auto_missing_trailing_return
4539 : diag::err_deduced_return_type);
4544 diag::warn_cxx11_compat_deduced_return_type);
4548 if (isa<ParenType>(T)) {
4556 diag::err_deduction_guide_with_complex_decl)
4561 (T.hasQualifiers() || !isa<AutoType>(T) ||
4562 cast<AutoType>(T)->getKeyword() !=
4565 diag::err_trailing_return_without_auto)
4583 if (!D.
isInvalidType() && (T->isArrayType() || T->isFunctionType()) &&
4586 unsigned diagID = diag::err_func_returning_array_function;
4589 if (chunkIndex == 0 &&
4591 diagID = diag::err_block_returning_array_function;
4592 S.
Diag(DeclType.
Loc, diagID) << T->isFunctionType() << T;
4599 if (T->isHalfType()) {
4608 diag::err_parameters_retval_cannot_have_fp16_type) << 1;
4613 if (LangOpts.OpenCL) {
4616 if (T->isBlockPointerType() || T->isImageType() || T->isSamplerT() ||
4628 (LangOpts.OpenCLCPlusPlus || LangOpts.OpenCLVersion >= 120)) ||
4637 if (T->isObjCObjectType()) {
4646 S.
Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value)
4664 if ((T.getCVRQualifiers() || T->isAtomicType()) &&
4666 (T->isDependentType() || T->isRecordType()))) {
4667 if (T->isVoidType() && !S.
getLangOpts().CPlusPlus &&
4672 S.
Diag(DeclType.
Loc, diag::err_func_returning_qualified_void) << T;
4680 if (T.getQualifiers().hasObjCLifetime()) {
4685 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
4686 AttrLoc = AL.getLoc();
4693 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
4694 AttrLoc = AL.getLoc();
4708 S.
Diag(AttrLoc, diag::warn_arc_lifetime_result_type)
4709 << T.getQualifiers().getObjCLifetime();
4725 diag::err_exception_spec_in_typedef)
4738 && !LangOpts.OpenCL) {
4753 diag::err_ident_list_in_fn_declaration);
4778 bool HasAnyInterestingExtParameterInfos =
false;
4780 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
4783 assert(!ParamTy.isNull() &&
"Couldn't parse type?");
4788 if (ParamTy->isVoidType()) {
4793 S.
Diag(DeclType.
Loc, diag::err_void_only_param);
4794 ParamTy = Context.
IntTy;
4799 ParamTy = Context.
IntTy;
4803 if (ParamTy.hasQualifiers())
4804 S.
Diag(DeclType.
Loc, diag::err_void_param_qualified);
4809 }
else if (ParamTy->isHalfType()) {
4815 diag::err_opencl_half_param) << ParamTy;
4821 diag::err_parameters_retval_cannot_have_fp16_type) << 0;
4825 if (ParamTy->isPromotableIntegerType()) {
4829 if (BTy->getKind() == BuiltinType::Float) {
4836 if (LangOpts.ObjCAutoRefCount && Param->
hasAttr<NSConsumedAttr>()) {
4837 ExtParameterInfos[
i] = ExtParameterInfos[
i].withIsConsumed(
true);
4838 HasAnyInterestingExtParameterInfos =
true;
4842 ExtParameterInfos[
i] =
4843 ExtParameterInfos[
i].withABI(attr->getABI());
4844 HasAnyInterestingExtParameterInfos =
true;
4847 if (Param->
hasAttr<PassObjectSizeAttr>()) {
4848 ExtParameterInfos[
i] = ExtParameterInfos[
i].withHasPassObjectSize();
4849 HasAnyInterestingExtParameterInfos =
true;
4852 if (Param->
hasAttr<NoEscapeAttr>()) {
4853 ExtParameterInfos[
i] = ExtParameterInfos[
i].withIsNoEscape(
true);
4854 HasAnyInterestingExtParameterInfos =
true;
4857 ParamTys.push_back(ParamTy);
4860 if (HasAnyInterestingExtParameterInfos) {
4869 Expr *NoexceptExpr =
nullptr;
4875 DynamicExceptions.reserve(N);
4876 DynamicExceptionRanges.reserve(N);
4877 for (
unsigned I = 0; I != N; ++I) {
4888 DynamicExceptionRanges,
4895 auto IsClassMember = [&]() {
4896 return (!state.getDeclarator().getCXXScopeSpec().isEmpty() &&
4897 state.getDeclarator()
4901 state.getDeclarator().getContext() ==
4905 if (state.getSema().getLangOpts().OpenCLCPlusPlus && IsClassMember()) {
4911 LangAS ASIdxNew = attr.asOpenCLLangAS();
4934 inferPointerNullability(SimplePointerKind::MemberPointer, DeclType.
Loc,
4936 state.getDeclarator().getAttributePool());
4955 llvm_unreachable(
"Nested-name-specifier must name a type");
4965 if (NNSPrefix && isa<TemplateSpecializationType>(NNS->
getAsType()))
4971 diag::err_illegal_decl_mempointer_in_nonclass)
5007 S.
Diag(DeclType.
Loc, diag::warn_noderef_on_non_pointer_or_array);
5009 ExpectNoDerefChunk = state.didParseNoDeref();
5013 if (ExpectNoDerefChunk)
5014 S.
Diag(state.getDeclarator().getBeginLoc(),
5015 diag::warn_noderef_on_non_pointer_or_array);
5026 bool IsBlock =
false;
5028 switch (DeclType.Kind) {
5038 S.
Diag(DeclType.Loc, diag::warn_strict_prototypes)
5050 assert(!T.
isNull() &&
"T must not be null after this point");
5054 assert(FnTy &&
"Why oh why is there not a FunctionProtoType here?");
5064 enum { NonMember, Member, DeductionGuide }
Kind = NonMember;
5066 Kind = DeductionGuide;
5094 if (IsQualifiedFunction &&
5116 if (!RemovalLocs.empty()) {
5117 llvm::sort(RemovalLocs,
5119 RemovalRange =
SourceRange(RemovalLocs.front(), RemovalLocs.back());
5120 Loc = RemovalLocs.front();
5124 S.
Diag(Loc, diag::err_invalid_qualified_function_type)
5149 state.diagnoseIgnoredTypeAttrs(T);
5179 diag::err_function_parameter_pack_without_parameter_packs)
5199 LangOpts.CPlusPlus11
5200 ? diag::warn_cxx98_compat_variadic_templates
5201 : diag::ext_variadic_templates);
5232 diag::err_ellipsis_in_declarator_not_parameter);
5238 assert(!T.
isNull() &&
"T must not be null at the end of this function");
5254 TypeProcessingState
state(*
this, D);
5277 unsigned chunkIndex) {
5278 Sema &S = state.getSema();
5286 const char *attrStr =
nullptr;
5287 switch (ownership) {
5315 Sema &S = state.getSema();
5319 bool hasIndirection =
false;
5322 switch (chunk.
Kind) {
5331 hasIndirection =
true;
5364 TypeProcessingState
state(*
this, D);
5369 if (getLangOpts().ObjC) {
5379 TypeProcessingState &State) {
5384 class TypeSpecLocFiller :
public TypeLocVisitor<TypeSpecLocFiller> {
5386 TypeProcessingState &
State;
5390 TypeSpecLocFiller(
ASTContext &Context, TypeProcessingState &State,
5392 : Context(Context),
State(State), DS(DS) {}
5401 State.getExpansionLocForMacroQualifiedType(TL.
getTypePtr()));
5511 void VisitDependentTemplateSpecializationTypeLoc(
5550 void VisitTypeLoc(
TypeLoc TL) {
5556 class DeclaratorLocFiller :
public TypeLocVisitor<DeclaratorLocFiller> {
5558 TypeProcessingState &
State;
5562 DeclaratorLocFiller(
ASTContext &Context, TypeProcessingState &State,
5564 : Context(Context),
State(State), Chunk(Chunk) {}
5567 llvm_unreachable(
"qualified type locs not expected here!");
5570 llvm_unreachable(
"decayed type locs not expected here!");
5603 assert(isa<DependentNameType>(ClsTy) &&
"Unexpected TypeLoc");
5614 if (isa<ElaboratedType>(ClsTy)) {
5629 llvm_unreachable(
"Nested-name-specifier must name a type");
5680 void VisitTypeLoc(
TypeLoc TL) {
5681 llvm_unreachable(
"unsupported TypeLoc kind in declarator!");
5688 switch (Chunk.
Kind) {
5693 llvm_unreachable(
"cannot be _Atomic qualified");
5714 if (AL.getKind() == ParsedAttr::AT_AddressSpace) {
5723 "no address_space attribute found at the expected location!");
5737 Sema &S = State.getSema();
5744 if (isa<PackExpansionType>(T)) {
5759 State.getExpansionLocForMacroQualifiedType(TL.getTypePtr()));
5784 if (ReturnTypeInfo) {
5804 "LocInfoType's TypeClass conflicts with an existing Type class");
5810 llvm_unreachable(
"LocInfoType leaked into the type system; an opaque TypeTy*" 5811 " was used directly instead of getting the QualType through" 5812 " GetTypeFromParser");
5819 "Type name should have no identifier!");
5834 checkUnusedDeclAttributes(D);
5836 if (getLangOpts().CPlusPlus) {
5838 CheckExtraCXXDefaultArguments(D);
5841 return CreateParsedType(T, TInfo);
5847 return CreateParsedType(T, TInfo);
5858 const Expr *AddrSpace,
5861 llvm::APSInt addrSpace(32);
5863 S.
Diag(AttrLoc, diag::err_attribute_argument_type)
5870 if (addrSpace.isSigned()) {
5871 if (addrSpace.isNegative()) {
5872 S.
Diag(AttrLoc, diag::err_attribute_address_space_negative)
5876 addrSpace.setIsSigned(
false);
5879 llvm::APSInt
max(addrSpace.getBitWidth());
5882 if (addrSpace > max) {
5883 S.
Diag(AttrLoc, diag::err_attribute_address_space_too_high)
5918 Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
5930 return BuildAddressSpaceAttr(T, ASIdx, AddrSpace, AttrLoc);
5938 TypeProcessingState &State) {
5939 Sema &S = State.getSema();
5944 S.
Diag(Attr.
getLoc(), diag::err_attribute_address_function_type);
5950 if (Attr.
getKind() == ParsedAttr::AT_AddressSpace) {
5954 S.
Diag(Attr.
getLoc(), diag::err_attribute_wrong_number_arguments) << Attr
5974 ASArgExpr =
static_cast<Expr *
>(AddrSpace.
get());
5986 auto *ASAttr = ::new (Ctx) AddressSpaceAttr(
5988 static_cast<unsigned>(ASIdx));
6000 if (EquivType.
isNull()) {
6004 T = State.getAttributedType(ASAttr, Type, EquivType);
6006 T = State.getAttributedType(ASAttr, Type, Type);
6018 llvm_unreachable(
"Invalid address space");
6039 if (
const AttributedType *attr = dyn_cast<AttributedType>(type)) {
6040 if (attr->getAttrKind() == attr::ObjCOwnership)
6043 type = attr->getModifiedType();
6046 }
else if (
const ParenType *paren = dyn_cast<ParenType>(type)) {
6047 type = paren->getInnerType();
6066 bool NonObjCPointer =
false;
6076 NonObjCPointer =
true;
6083 if (state.isProcessingDeclSpec()) {
6091 Sema &S = state.getSema();
6098 S.
Diag(AttrLoc, diag::err_attribute_argument_type) << attr
6106 if (II->
isStr(
"none"))
6108 else if (II->
isStr(
"strong"))
6110 else if (II->
isStr(
"weak"))
6112 else if (II->
isStr(
"autoreleasing"))
6115 S.
Diag(AttrLoc, diag::warn_attribute_type_not_supported)
6136 S.
Diag(AttrLoc, diag::err_attr_objc_ownership_redundant)
6143 if (previousLifetime != lifetime) {
6146 const Type *prevTy =
nullptr;
6147 while (!prevTy || prevTy != underlyingType.
Ty) {
6148 prevTy = underlyingType.
Ty;
6157 if (NonObjCPointer) {
6167 S.
Diag(AttrLoc, diag::warn_type_attribute_wrong_type) << name
6184 type = state.getAttributedType(
6185 createSimpleAttr<ObjCInertUnsafeUnretainedAttr>(S.
Context, attr),
6191 if (!NonObjCPointer)
6197 type = state.getAttributedType(::
new (S.
Context) ObjCOwnershipAttr(
6209 diagnostic,
type, 0));
6211 S.
Diag(loc, diagnostic);
6220 unsigned diagnostic =
6221 (S.
getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled
6222 : diag::err_arc_weak_no_runtime);
6225 diagnoseOrDelay(S, AttrLoc, diagnostic, type);
6237 if (Class->isArcWeakrefUnavailable()) {
6238 S.
Diag(AttrLoc, diag::err_arc_unsupported_weak_class);
6239 S.
Diag(ObjT->getInterfaceDecl()->getLocation(),
6240 diag::note_class_declared);
6255 Sema &S = state.getSema();
6264 S.
Diag(attr.
getLoc(), diag::err_attribute_multiple_objc_gc);
6271 S.
Diag(attr.
getLoc(), diag::err_attribute_argument_type)
6278 S.
Diag(attr.
getLoc(), diag::err_attribute_wrong_number_arguments) << attr
6285 if (II->
isStr(
"weak"))
6287 else if (II->
isStr(
"strong"))
6290 S.
Diag(attr.
getLoc(), diag::warn_attribute_type_not_supported)
6301 type = state.getAttributedType(
6320 struct FunctionTypeUnwrapper {
6335 FunctionTypeUnwrapper(
Sema &S,
QualType T) : Original(T) {
6338 if (isa<FunctionType>(Ty)) {
6339 Fn = cast<FunctionType>(Ty);
6341 }
else if (isa<ParenType>(Ty)) {
6342 T = cast<ParenType>(Ty)->getInnerType();
6343 Stack.push_back(Parens);
6344 }
else if (isa<PointerType>(Ty)) {
6345 T = cast<PointerType>(Ty)->getPointeeType();
6347 }
else if (isa<BlockPointerType>(Ty)) {
6348 T = cast<BlockPointerType>(Ty)->getPointeeType();
6349 Stack.push_back(BlockPointer);
6350 }
else if (isa<MemberPointerType>(Ty)) {
6351 T = cast<MemberPointerType>(Ty)->getPointeeType();
6352 Stack.push_back(MemberPointer);
6353 }
else if (isa<ReferenceType>(Ty)) {
6354 T = cast<ReferenceType>(Ty)->getPointeeType();
6355 Stack.push_back(Reference);
6356 }
else if (isa<AttributedType>(Ty)) {
6357 T = cast<AttributedType>(Ty)->getEquivalentType();
6358 Stack.push_back(Attributed);
6372 bool isFunctionType()
const {
return (Fn !=
nullptr); }
6377 if (New ==
get())
return Original;
6380 return wrap(S.
Context, Original, 0);
6385 if (I == Stack.size())
6394 return wrap(C, SplitOld.
Ty, I);
6399 if (I == Stack.size())
return QualType(Fn, 0);
6401 switch (static_cast<WrapKind>(Stack[I++])) {
6408 return wrap(C, cast<AttributedType>(Old)->getEquivalentType(), I);
6411 QualType New = wrap(C, cast<ParenType>(Old)->getInnerType(), I);
6416 QualType New = wrap(C, cast<PointerType>(Old)->getPointeeType(), I);
6420 case BlockPointer: {
6421 QualType New = wrap(C, cast<BlockPointerType>(Old)->getPointeeType(),I);
6425 case MemberPointer: {
6434 if (isa<LValueReferenceType>(OldRef))
6441 llvm_unreachable(
"unknown wrapping kind");
6448 Sema &S = State.getSema();
6452 default: llvm_unreachable(
"Unknown attribute kind");
6453 case ParsedAttr::AT_Ptr32:
6454 A = createSimpleAttr<Ptr32Attr>(S.
Context, PAttr);
6456 case ParsedAttr::AT_Ptr64:
6457 A = createSimpleAttr<Ptr64Attr>(S.
Context, PAttr);
6459 case ParsedAttr::AT_SPtr:
6460 A = createSimpleAttr<SPtrAttr>(S.
Context, PAttr);
6462 case ParsedAttr::AT_UPtr:
6463 A = createSimpleAttr<UPtrAttr>(S.
Context, PAttr);
6475 if (NewAttrKind == CurAttrKind) {
6476 S.
Diag(PAttr.
getLoc(), diag::warn_duplicate_attribute_exact)
6483 if ((CurAttrKind == attr::Ptr32 && NewAttrKind == attr::Ptr64) ||
6484 (CurAttrKind == attr::Ptr64 && NewAttrKind == attr::Ptr32)) {
6485 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
6486 <<
"'__ptr32'" <<
"'__ptr64'";
6488 }
else if ((CurAttrKind == attr::SPtr && NewAttrKind == attr::UPtr) ||
6489 (CurAttrKind == attr::UPtr && NewAttrKind == attr::SPtr)) {
6490 S.
Diag(PAttr.
getLoc(), diag::err_attributes_are_not_compatible)
6491 <<
"'__sptr'" <<
"'__uptr'";
6506 if (!isa<PointerType>(Desugared)) {
6508 S.
Diag(PAttr.
getLoc(), diag::err_attribute_no_member_pointers) << PAttr;
6510 S.
Diag(PAttr.
getLoc(), diag::err_attribute_pointers_only) << PAttr << 0;
6514 Type = State.getAttributedType(A, Type, Type);
6521 case ParsedAttr::AT_TypeNonNull:
6524 case ParsedAttr::AT_TypeNullable:
6527 case ParsedAttr::AT_TypeNullUnspecified:
6531 llvm_unreachable(
"not a nullability attribute kind");
6551 bool allowOnArrayType) {
6552 Sema &S = state.getSema();
6562 while (
auto attributed = dyn_cast<AttributedType>(desugared.
getTypePtr())) {
6564 if (
auto existingNullability = attributed->getImmediateNullability()) {
6566 if (nullability == *existingNullability) {
6567 S.
Diag(nullabilityLoc, diag::warn_nullability_duplicate)
6575 S.
Diag(nullabilityLoc, diag::err_nullability_conflicting)
6581 desugared = attributed->getModifiedType();
6589 if (nullability != *existingNullability) {
6590 S.
Diag(nullabilityLoc, diag::err_nullability_conflicting)
6598 if (
auto typedefNullability
6600 if (*typedefNullability == *existingNullability) {
6613 !(allowOnArrayType && desugared->
isArrayType())) {
6614 S.
Diag(nullabilityLoc, diag::err_nullability_nonpointer)
6621 if (isContextSensitive) {
6623 const Type *pointeeType;
6632 S.
Diag(nullabilityLoc, diag::err_nullability_cs_multilevel)
6635 S.
Diag(nullabilityLoc, diag::note_nullability_type_specifier)
6645 type = state.getAttributedType(
6654 Sema &S = state.getSema();
6656 if (isa<ObjCTypeParamType>(type)) {
6658 type = state.getAttributedType(
6659 createSimpleAttr<ObjCKindOfAttr>(S.
Context, attr), type, type);
6671 S.
Diag(attr.
getLoc(), diag::err_objc_kindof_nonobject)
6680 objType->getBaseType(), objType->getTypeArgsAsWritten(),
6681 objType->getProtocols(),
6682 objType->isObjCUnqualifiedId() ?
false :
true);
6691 "multiple spellings for __kindof?");
6693 A->setImplicit(
true);
6694 equivType = state.getAttributedType(A, equivType, equivType);
6699 type = state.getAttributedType(
6700 createSimpleAttr<ObjCKindOfAttr>(S.
Context, attr), type, equivType);
6712 Declarator &declarator = state.getDeclarator();
6715 auto moveToChunk = [&](
DeclaratorChunk &chunk,
bool inFunction) ->
bool {
6728 PK_MemberFunctionPointer,
6733 : inFunction? PK_MemberFunctionPointer : PK_MemberPointer;
6735 auto diag = state.getSema().Diag(attr.
getLoc(),
6736 diag::warn_nullability_declspec)
6740 << static_cast<unsigned>(pointerKind);
6746 state.getSema().getPreprocessor()
6747 .getLocForEndOfToken(chunk.
Loc),
6758 for (
unsigned i = state.getCurrentChunkIndex();
i != 0; --
i) {
6760 switch (chunk.
Kind) {
6764 return moveToChunk(chunk,
false);
6776 return moveToChunk(*dest,
true);
6795 llvm_unreachable(
"not a calling convention attribute");
6796 case ParsedAttr::AT_CDecl:
6797 return createSimpleAttr<CDeclAttr>(Ctx, Attr);
6798 case ParsedAttr::AT_FastCall:
6799 return createSimpleAttr<FastCallAttr>(Ctx, Attr);
6800 case ParsedAttr::AT_StdCall:
6801 return createSimpleAttr<StdCallAttr>(Ctx, Attr);
6802 case ParsedAttr::AT_ThisCall:
6803 return createSimpleAttr<ThisCallAttr>(Ctx, Attr);
6804 case ParsedAttr::AT_RegCall:
6805 return createSimpleAttr<RegCallAttr>(Ctx, Attr);
6806 case ParsedAttr::AT_Pascal:
6807 return createSimpleAttr<PascalAttr>(Ctx, Attr);
6808 case ParsedAttr::AT_SwiftCall:
6809 return createSimpleAttr<SwiftCallAttr>(Ctx, Attr);
6810 case ParsedAttr::AT_VectorCall:
6811 return createSimpleAttr<VectorCallAttr>(Ctx, Attr);
6812 case ParsedAttr::AT_AArch64VectorPcs:
6813 return createSimpleAttr<AArch64VectorPcsAttr>(Ctx, Attr);
6814 case ParsedAttr::AT_Pcs: {
6820 Str = cast<StringLiteral>(Attr.
getArgAsExpr(0))->getString();
6823 PcsAttr::PCSType
Type;
6824 if (!PcsAttr::ConvertStrToPCSType(Str, Type))
6825 llvm_unreachable(
"already validated the attribute");
6826 return ::new (Ctx) PcsAttr(Attr.
getRange(), Ctx, Type,
6829 case ParsedAttr::AT_IntelOclBicc:
6830 return createSimpleAttr<IntelOclBiccAttr>(Ctx, Attr);
6831 case ParsedAttr::AT_MSABI:
6832 return createSimpleAttr<MSABIAttr>(Ctx, Attr);
6833 case ParsedAttr::AT_SysVABI:
6834 return createSimpleAttr<SysVABIAttr>(Ctx, Attr);
6835 case ParsedAttr::AT_PreserveMost:
6836 return createSimpleAttr<PreserveMostAttr>(Ctx, Attr);
6837 case ParsedAttr::AT_PreserveAll:
6838 return createSimpleAttr<PreserveAllAttr>(Ctx, Attr);
6840 llvm_unreachable(
"unexpected attribute kind!");
6847 Sema &S = state.getSema();
6849 FunctionTypeUnwrapper unwrapped(S, type);
6851 if (attr.
getKind() == ParsedAttr::AT_NoReturn) {
6856 if (!unwrapped.isFunctionType())
6867 if (attr.
getKind() == ParsedAttr::AT_NSReturnsRetained) {
6871 if (!unwrapped.isFunctionType())
6876 unwrapped.get()->getReturnType()))
6881 if (state.getSema().getLangOpts().ObjCAutoRefCount) {
6883 = unwrapped.get()->getExtInfo().withProducesResult(
true);
6886 type = state.getAttributedType(
6887 createSimpleAttr<NSReturnsRetainedAttr>(S.
Context, attr),
6892 if (attr.
getKind() == ParsedAttr::AT_AnyX86NoCallerSavedRegisters) {
6897 if (!unwrapped.isFunctionType())
6901 unwrapped.get()->getExtInfo().withNoCallerSavedRegs(
true);
6906 if (attr.
getKind() == ParsedAttr::AT_AnyX86NoCfCheck) {
6908 S.
Diag(attr.
getLoc(), diag::warn_nocf_check_attribute_ignored);
6918 if (!unwrapped.isFunctionType())
6922 unwrapped.get()->getExtInfo().withNoCfCheck(
true);
6927 if (attr.
getKind() == ParsedAttr::AT_Regparm) {
6933 if (!unwrapped.isFunctionType())
6940 S.
Diag(attr.
getLoc(), diag::err_attributes_are_not_compatible)
6948 unwrapped.get()->getExtInfo().withRegParm(value);
6953 if (attr.
getKind() == ParsedAttr::AT_NoThrow) {
6955 if (!unwrapped.isFunctionType())
6968 if (Proto->hasExceptionSpec()) {
6969 switch (Proto->getExceptionSpecType()) {
6971 llvm_unreachable(
"This doesn't have an exception spec!");
6989 S.
Diag(attr.
getLoc(), diag::warn_nothrow_attribute_ignored);
6995 type = unwrapped.wrap(
7005 if (!unwrapped.isFunctionType())
return false;
7020 S.
Diag(attr.
getLoc(), diag::err_attributes_are_not_compatible)
7041 return S.
Diag(attr.
getLoc(), diag::warn_cconv_unsupported)
7046 return S.
Diag(attr.
getLoc(), diag::err_cconv_varargs)
7053 S.
Diag(attr.
getLoc(), diag::err_attributes_are_not_compatible)
7066 auto EI = unwrapped.get()->getExtInfo().withCallingConv(CC);
7070 type = state.getAttributedType(CCAttr, type, Equivalent);
7090 FunctionTypeUnwrapper Unwrapped(*
this, T);
7092 bool IsVariadic = (isa<FunctionProtoType>(FT) &&
7093 cast<FunctionProtoType>(FT)->isVariadic());
7106 Diag(Loc, diag::warn_cconv_unsupported)
7117 if (CurCC != DefaultCC || DefaultCC == ToCC)
7120 if (hasExplicitCallingConv(T))
7125 QualType Wrapped = Unwrapped.wrap(*
this, FT);
7140 S.
Diag(Attr.
getLoc(), diag::err_attribute_wrong_number_arguments) << Attr
7160 SizeExpr = Size.
get();
7178 S.
Diag(Attr.
getLoc(), diag::err_attribute_wrong_number_arguments) << Attr
7198 sizeExpr = Size.
get();
7219 bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 ||
7220 Triple.getArch() == llvm::Triple::aarch64_be;
7222 if (IsPolyUnsigned) {
7224 return BTy->
getKind() == BuiltinType::UChar ||
7225 BTy->
getKind() == BuiltinType::UShort ||
7226 BTy->
getKind() == BuiltinType::ULong ||
7227 BTy->
getKind() == BuiltinType::ULongLong;
7230 return BTy->
getKind() == BuiltinType::SChar ||
7231 BTy->
getKind() == BuiltinType::Short;
7237 bool Is64Bit = Triple.getArch() == llvm::Triple::aarch64 ||
7238 Triple.getArch() == llvm::Triple::aarch64_be;
7240 if (Is64Bit && BTy->
getKind() == BuiltinType::Double)
7243 return BTy->
getKind() == BuiltinType::SChar ||
7244 BTy->
getKind() == BuiltinType::UChar ||
7245 BTy->
getKind() == BuiltinType::Short ||
7246 BTy->
getKind() == BuiltinType::UShort ||
7247 BTy->
getKind() == BuiltinType::Int ||
7248 BTy->
getKind() == BuiltinType::UInt ||
7249 BTy->
getKind() == BuiltinType::Long ||
7250 BTy->
getKind() == BuiltinType::ULong ||
7251 BTy->
getKind() == BuiltinType::LongLong ||
7252 BTy->
getKind() == BuiltinType::ULongLong ||
7253 BTy->
getKind() == BuiltinType::Float ||
7254 BTy->
getKind() == BuiltinType::Half;
7268 S.
Diag(Attr.
getLoc(), diag::err_attribute_unsupported) << Attr;
7274 S.
Diag(Attr.
getLoc(), diag::err_attribute_wrong_number_arguments) << Attr
7281 llvm::APSInt numEltsInt(32);
7284 S.
Diag(Attr.
getLoc(), diag::err_attribute_argument_type)
7292 S.
Diag(Attr.
getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
7299 unsigned numElts =
static_cast<unsigned>(numEltsInt.getZExtValue());
7300 unsigned vecSize = typeSize * numElts;
7301 if (vecSize != 64 && vecSize != 128) {
7302 S.
Diag(Attr.
getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType;
7315 S.
Diag(Attr.
getLoc(), diag::err_opencl_invalid_access_qualifier);
7321 QualType BaseTy = TypedefTy->desugar();
7323 std::string PrevAccessQual;
7325 if (TypedefTy->getDecl()->hasAttr<OpenCLAccessAttr>()) {
7326 OpenCLAccessAttr *Attr =
7327 TypedefTy->getDecl()->getAttr<OpenCLAccessAttr>();
7328 PrevAccessQual = Attr->getSpelling();
7330 PrevAccessQual =
"read_only";
7334 switch (ImgType->getKind()) {
7335 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 7336 case BuiltinType::Id: \ 7337 PrevAccessQual = #Access; \ 7339 #include "clang/Basic/OpenCLImageTypes.def" 7341 llvm_unreachable(
"Unable to find corresponding image type.");
7344 llvm_unreachable(
"unexpected type");
7347 if (PrevAccessQual == AttrName.ltrim(
"_")) {
7349 S.
Diag(Attr.
getLoc(), diag::warn_duplicate_declspec)
7353 S.
Diag(Attr.
getLoc(), diag::err_opencl_multiple_access_qualifiers);
7356 S.
Diag(TypedefTy->getDecl()->getBeginLoc(),
7357 diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;
7389 auto ChunkIndex = State.getCurrentChunkIndex();
7397 if (!IsPointee && ChunkIndex > 1) {
7398 auto AdjustedCI = ChunkIndex - 1;
7402 while (AdjustedCI > 0 &&
7409 bool IsFuncReturnType =
7417 IsFuncReturnType || IsFuncType ||
7464 if (State.getSema().getLangOpts().OpenCLVersion <= 120 &&
7465 !State.getSema().getLangOpts().OpenCLCPlusPlus) {
7494 T = State.getSema().Context.getAddrSpaceQualType(T, ImpAddr);
7500 if (State.getDeclarator().isDeclarationOfFunction()) {
7501 CurType = State.getAttributedType(
7502 createSimpleAttr<LifetimeBoundAttr>(State.getSema().Context, Attr),
7523 state.setParsedNoDeref(
false);
7528 if (attr.isInvalid())
7531 if (attr.isCXX11Attribute()) {
7536 if (attr.isGNUScope()) {
7537 bool IsTypeAttr = attr.isTypeAttr();
7539 state.getSema().Diag(attr.getLoc(),
7541 ? diag::warn_gcc_ignores_type_attr
7542 : diag::warn_cxx11_gnu_attribute_on_type)
7548 attr.getKind() != ParsedAttr::AT_AddressSpace) {
7558 switch (attr.getKind()) {
7562 state.getSema().Diag(attr.getLoc(), diag::err_attribute_not_type_attr)
7564 attr.setUsedAsTypeAttr();
7570 state.getSema().Diag(attr.getLoc(),
7571 diag::warn_unknown_attribute_ignored)
7578 case ParsedAttr::AT_MayAlias:
7581 attr.setUsedAsTypeAttr();
7583 case ParsedAttr::AT_OpenCLPrivateAddressSpace:
7584 case ParsedAttr::AT_OpenCLGlobalAddressSpace:
7585 case ParsedAttr::AT_OpenCLLocalAddressSpace:
7586 case ParsedAttr::AT_OpenCLConstantAddressSpace:
7587 case ParsedAttr::AT_OpenCLGenericAddressSpace:
7588 case ParsedAttr::AT_AddressSpace:
7590 attr.setUsedAsTypeAttr();
7595 attr.setUsedAsTypeAttr();
7597 case ParsedAttr::AT_VectorSize:
7599 attr.setUsedAsTypeAttr();
7601 case ParsedAttr::AT_ExtVectorType:
7603 attr.setUsedAsTypeAttr();
7605 case ParsedAttr::AT_NeonVectorType:
7608 attr.setUsedAsTypeAttr();
7610 case ParsedAttr::AT_NeonPolyVectorType:
7613 attr.setUsedAsTypeAttr();
7615 case ParsedAttr::AT_OpenCLAccess:
7617 attr.setUsedAsTypeAttr();
7619 case ParsedAttr::AT_LifetimeBound:
7624 case ParsedAttr::AT_NoDeref: {
7626 type = state.getAttributedType(createSimpleAttr<NoDerefAttr>(Ctx, attr),
7628 attr.setUsedAsTypeAttr();
7629 state.setParsedNoDeref(
true);
7635 attr.setUsedAsTypeAttr();
7648 endIndex = state.getCurrentChunkIndex();
7650 endIndex = state.getDeclarator().getNumTypeObjects();
7651 bool allowOnArrayType =
7652 state.getDeclarator().isPrototypeContext() &&
7658 allowOnArrayType)) {
7662 attr.setUsedAsTypeAttr();
7666 case ParsedAttr::AT_ObjCKindOf:
7674 state.getSema().Diag(attr.getLoc(),
7675 diag::err_objc_kindof_wrong_position)
7678 state.getDeclarator().getDeclSpec().getBeginLoc(),
7688 case ParsedAttr::AT_NoThrow:
7691 if (!state.getSema().getLangOpts().CPlusPlus)
7695 attr.setUsedAsTypeAttr();
7710 if (isa<AttributedType>(type) && attr.hasMacroIdentifier() &&
7713 attr.getKind() != ParsedAttr::AT_ObjCGC &&
7714 attr.getKind() != ParsedAttr::AT_ObjCOwnership) {
7716 type = state.getSema().Context.getMacroQualifiedType(type, MacroII);
7717 state.setExpansionLocForMacroQualifiedType(
7719 attr.getMacroExpansionLoc());
7723 if (!state.getSema().getLangOpts().OpenCL ||
7732 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
7734 auto *Def = Var->getDefinition();
7737 InstantiateVariableDefinition(PointOfInstantiation, Var);
7738 Def = Var->getDefinition();
7745 if (Var->getPointOfInstantiation().isInvalid() && Def) {
7746 assert(Var->getTemplateSpecializationKind() ==
7748 "explicit instantiation with no point of instantiation");
7749 Var->setTemplateSpecializationKind(
7750 Var->getTemplateSpecializationKind(), PointOfInstantiation);
7794 completeExprArrayBound(E);
7801 return RequireCompleteType(E->
getExprLoc(), T, Diagnoser);
7806 return RequireCompleteExprType(E, Diagnoser);
7828 if (RequireCompleteTypeImpl(Loc, T, &Diagnoser))
7831 if (!Tag->getDecl()->isCompleteDefinitionRequired()) {
7832 Tag->getDecl()->setCompleteDefinitionRequired();
7833 Consumer.HandleTagDeclRequiredDefinition(Tag->getDecl());
7864 bool OnlyNeedComplete) {
7866 if (!getLangOpts().Modules && !getLangOpts().ModulesLocalVisibility)
7871 if (isa<TagDecl>(D) && cast<TagDecl>(D)->isBeingDefined()) {
7875 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
7876 if (
auto *Pattern = RD->getTemplateInstantiationPattern())
7878 D = RD->getDefinition();
7879 }
else if (
auto *ED = dyn_cast<EnumDecl>(D)) {
7880 if (
auto *Pattern = ED->getTemplateInstantiationPattern())
7882 if (OnlyNeedComplete && ED->isFixed()) {
7886 *Suggested =
nullptr;
7887 for (
auto *Redecl : ED->redecls()) {
7888 if (isVisible(Redecl))
7890 if (Redecl->isThisDeclarationADefinition() ||
7891 (Redecl->isCanonicalDecl() && !*Suggested))
7892 *Suggested = Redecl;
7896 D = ED->getDefinition();
7897 }
else if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
7898 if (
auto *Pattern = FD->getTemplateInstantiationPattern())
7900 D = FD->getDefinition();
7901 }
else if (
auto *VD = dyn_cast<VarDecl>(D)) {
7902 if (
auto *Pattern = VD->getTemplateInstantiationPattern())
7904 D = VD->getDefinition();
7906 assert(D &&
"missing definition for pattern of instantiated definition");
7910 auto DefinitionIsVisible = [&] {
7917 : hasVisibleMergedDefinition(D)) {
7918 if (CodeSynthesisContexts.empty() &&
7919 !getLangOpts().ModulesLocalVisibility) {
7930 if (DefinitionIsVisible())
7936 Source->CompleteRedeclChain(D);
7937 return DefinitionIsVisible();
7946 if (!RD->
hasAttr<MSInheritanceAttr>()) {
7947 MSInheritanceAttr::Spelling IM;
7954 IM = MSInheritanceAttr::Keyword_single_inheritance;
7957 IM = MSInheritanceAttr::Keyword_multiple_inheritance;
7960 IM = MSInheritanceAttr::Keyword_unspecified_inheritance;
7964 RD->
addAttr(MSInheritanceAttr::CreateImplicit(
7977 TypeDiagnoser *Diagnoser) {
7987 if (!MPTy->getClass()->isDependentType()) {
7988 if (getLangOpts().CompleteMemberPointers &&
7989 !MPTy->getClass()->getAsCXXRecordDecl()->isBeingDefined() &&
7990 RequireCompleteType(Loc,
QualType(MPTy->getClass(), 0),
7991 diag::err_memptr_incomplete))
7997 (void)isCompleteType(Loc,
QualType(MPTy->getClass(), 0));
8008 if (Def && !isa<EnumDecl>(Def))
8009 checkSpecializationVisibility(Loc, Def);
8016 !hasVisibleDefinition(Def, &SuggestedDef,
true)) {
8019 bool TreatAsComplete = Diagnoser && !isSFINAEContext();
8020 if (Diagnoser && SuggestedDef)
8021 diagnoseMissingImport(Loc, SuggestedDef, MissingImportKind::Definition,
8023 return !TreatAsComplete;
8024 }
else if (Def && !TemplateInstCallbacks.empty()) {
8025 CodeSynthesisContext TempInst;
8026 TempInst.Kind = CodeSynthesisContext::Memoization;
8027 TempInst.Template = Def;
8028 TempInst.Entity = Def;
8029 TempInst.PointOfInstantiation = Loc;
8037 TagDecl *Tag = dyn_cast_or_null<TagDecl>(Def);
8046 if (Def->isInvalidDecl())
8052 Source->CompleteType(Tag);
8053 if (IFace && IFace->hasExternalLexicalStorage())
8054 Source->CompleteType(IFace);
8058 return RequireCompleteTypeImpl(Loc, T, Diagnoser);
8065 if (
auto *RD = dyn_cast_or_null<CXXRecordDecl>(Tag)) {
8066 bool Instantiated =
false;
8067 bool Diagnosed =
false;
8068 if (RD->isDependentContext()) {
8072 }
else if (
auto *ClassTemplateSpec =
8073 dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
8074 if (ClassTemplateSpec->getSpecializationKind() ==
TSK_Undeclared) {
8075 Diagnosed = InstantiateClassTemplateSpecialization(
8078 Instantiated =
true;
8082 if (!RD->isBeingDefined() && Pattern) {
8084 assert(MSI &&
"Missing member specialization information?");
8088 Diagnosed = InstantiateClass(Loc, RD, Pattern,
8089 getTemplateInstantiationArgs(RD),
8092 Instantiated =
true;
8100 if (Diagnoser && Diagnosed)
8106 return RequireCompleteTypeImpl(Loc, T, Diagnoser);
8116 Diagnoser->diagnose(*
this, Loc, T);
8123 : diag::note_forward_declaration)
8127 if (IFace && !IFace->isInvalidDecl())
8128 Diag(IFace->getLocation(), diag::note_forward_class);
8133 ExternalSource->MaybeDiagnoseMissingCompleteType(Loc, T);
8141 return RequireCompleteType(Loc, T, Diagnoser);
8154 default: llvm_unreachable(
"Invalid tag kind for literal type diagnostic!");
8181 if ((isCompleteType(Loc, ElemType) || ElemType->isVoidType()) &&
8199 if (RequireCompleteType(Loc, ElemType, diag::note_non_literal_incomplete, T))
8204 if (RD->
isLambda() && !getLangOpts().CPlusPlus17) {
8216 for (
const auto &I : RD->
vbases())
8217 Diag(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)
8218 << I.getSourceRange();
8221 Diag(RD->
getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD;
8223 for (
const auto &I : RD->
bases()) {
8224 if (!I.getType()->isLiteralType(Context)) {
8225 Diag(I.getBeginLoc(), diag::note_non_literal_base_class)
8230 for (
const auto *I : RD->
fields()) {
8231 if (!I->getType()->isLiteralType(Context) ||
8232 I->getType().isVolatileQualified()) {
8233 Diag(I->getLocation(), diag::note_non_literal_field)
8234 << RD << I << I->getType()
8235 << I->getType().isVolatileQualified();
8243 assert(Dtor &&
"class has literal fields and bases but no dtor?");
8248 diag::note_non_literal_user_provided_dtor :
8249 diag::note_non_literal_nontrivial_dtor) << RD;
8251 SpecialMemberIsTrivial(Dtor, CXXDestructor, TAH_IgnoreTrivialABI,
8260 return RequireLiteralType(Loc, T, Diagnoser);
8286 Diag(E->
getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 2;
8291 DiagnoseUseOfDecl(TT->getDecl(), E->
getExprLoc());
8315 }
else if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
8316 if (
const ValueDecl *VD = ME->getMemberDecl())
8317 if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
8318 return VD->getType();
8319 }
else if (
const ObjCIvarRefExpr *IR = dyn_cast<ObjCIvarRefExpr>(E)) {
8320 return IR->getDecl()->getType();
8322 if (PR->isExplicitProperty())
8323 return PR->getExplicitProperty()->getType();
8324 }
else if (
auto *PE = dyn_cast<PredefinedExpr>(E)) {
8325 return PE->getType();
8335 using namespace sema;
8337 if (isa<ParenExpr>(E)) {
8339 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
8367 bool AsUnevaluated) {
8370 if (AsUnevaluated && CodeSynthesisContexts.empty() &&
8374 Diag(E->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
8386 Diag(Loc, diag::err_only_enums_have_underlying_types);
8395 Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
8396 Diag(FwdDecl->
getLocation(), diag::note_forward_declaration) << FwdDecl;
8401 assert(ED &&
"EnumType has no EnumDecl");
8403 DiagnoseUseOfDecl(ED, Loc);
8406 assert(!Underlying.
isNull());
8412 llvm_unreachable(
"unknown unary transform type");
8419 if (RequireCompleteType(Loc, T, diag::err_atomic_specifier_bad_type, 0))
8422 int DisallowedKind = -1;
8437 if (DisallowedKind != -1) {
8438 Diag(Loc, diag::err_atomic_specifier_bad_type) << DisallowedKind << T;
FileNullabilityMap NullabilityMap
A mapping that describes the nullability we've seen in each header file.
Abstract class used to diagnose incomplete types.
ParsedType getTrailingReturnType() const
Get the trailing-return-type for this function declarator.
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
static void checkNullabilityConsistency(Sema &S, SimplePointerKind pointerKind, SourceLocation pointerLoc, SourceLocation pointerEndLoc=SourceLocation())
Complains about missing nullability if the file containing pointerLoc has other uses of nullability (...
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const
C++11 decltype.
AttributePool & getAttributePool() const
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Defines the clang::ASTContext interface.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
TypeLoc getValueLoc() const
unsigned UnalignedQualLoc
The location of the __unaligned-qualifier, if any.
const Type * Ty
The locally-unqualified type.
bool diagnoseAppertainsTo(class Sema &S, const Decl *D) const
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
static unsigned getLiteralDiagFromTagKind(TagTypeKind Tag)
Get diagnostic select index for tag kind for literal type diagnostic message.
void setImplicit(bool I=true)
const internal::VariadicDynCastAllOfMatcher< Decl, TypedefDecl > typedefDecl
Matches typedef declarations.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl, SourceLocation ProtocolLAngleLoc, ArrayRef< ObjCProtocolDecl *> Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc, bool FailOnError=false)
Build an Objective-C type parameter type.
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
unsigned RefQualifierIsLValueRef
Whether the ref-qualifier (if any) is an lvalue reference.
static bool isOmittedBlockReturnType(const Declarator &D)
isOmittedBlockReturnType - Return true if this declarator is missing a return type because this is a ...
no exception specification
QualType BuildFunctionType(QualType T, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc, DeclarationName Entity, const FunctionProtoType::ExtProtoInfo &EPI)
Build a function type.
This is a discriminated union of FileInfo and ExpansionInfo.
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
PointerType - C99 6.7.5.1 - Pointer Declarators.
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
QualType BuildWritePipeType(QualType T, SourceLocation Loc)
Build a Write-only Pipe type.
A (possibly-)qualified type.
bool isBlockPointerType() const
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
bool isMemberPointerType() const
void setStarLoc(SourceLocation Loc)
Wrapper for source info for tag types.
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
static const TSS TSS_unsigned
static bool hasNullabilityAttr(const ParsedAttributesView &attrs)
Check whether there is a nullability attribute of any kind in the given attribute list...
const TypeClass * getTypePtr() const
QualType BuildUnaryTransformType(QualType BaseType, UnaryTransformType::UTTKind UKind, SourceLocation Loc)
static bool DiagnoseMultipleAddrSpaceAttributes(Sema &S, LangAS ASOld, LangAS ASNew, SourceLocation AttrLoc)
__auto_type (GNU extension)
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
void setNameEndLoc(SourceLocation Loc)
static const TST TST_wchar
void takeOneFrom(ParsedAttributes &Attrs, ParsedAttr *PA)
llvm::PointerUnion< Expr *, IdentifierLoc * > ArgsUnion
A union of the various pointer types that can be passed to an ParsedAttr as an argument.
#define CALLING_CONV_ATTRS_CASELIST
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false)
Perform unqualified name lookup starting from a given scope.
void setKWLoc(SourceLocation Loc)
The attribute is immediately after the declaration's name.
void setRParenLoc(SourceLocation Loc)
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
void setStarLoc(SourceLocation Loc)
const internal::VariadicDynCastAllOfMatcher< Decl, RecordDecl > recordDecl
Matches class, struct, and union declarations.
NullabilityKind
Describes the nullability of a particular type.
void setExceptionSpecRange(SourceRange R)
QualType BuildObjCObjectType(QualType BaseType, SourceLocation Loc, SourceLocation TypeArgsLAngleLoc, ArrayRef< TypeSourceInfo *> TypeArgs, SourceLocation TypeArgsRAngleLoc, SourceLocation ProtocolLAngleLoc, ArrayRef< ObjCProtocolDecl *> Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc, bool FailOnError=false)
Build an Objective-C object pointer type.
FunctionType - C99 6.7.5.3 - Function Declarators.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
TypeLoc getValueLoc() const
bool isRealFloatingType() const
Floating point categories.
void setEmbeddedInDeclarator(bool isInDeclarator)
True if this tag declaration is "embedded" (i.e., defined or declared for the very first time) in the...
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
void addConst()
Add the const type qualifier to this QualType.
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
bool isRecordType() const
bool isDecltypeAuto() const
static const TST TST_typeofExpr
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T, TagDecl *OwnedTagDecl=nullptr)
Retrieve a version of the type 'T' that is elaborated by Keyword, qualified by the nested-name-specif...
const Type * getTypeForDecl() const
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
static const TST TST_char16
Decl - This represents one declaration (or definition), e.g.
static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr, QualType type)
diagnoseBadTypeAttribute - Diagnoses a type attribute which doesn't apply to the given type...
bool isVariadic() const
Whether this function prototype is variadic.
WrittenBuiltinSpecs & getWrittenBuiltinSpecs()
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
Defines the C++ template declaration subclasses.
Represents a C++11 auto or C++14 decltype(auto) type.
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity)
Build an array type.
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer...
A constructor named via a template-id.
Expr * getArgAsExpr(unsigned Arg) const
QualType getDependentVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc, VectorType::VectorKind VecKind) const
Return the unique reference to the type for a dependently sized vector of the specified element type...
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
SourceLocation getLParenLoc() const
The base class of the type hierarchy.
bool hasTrailingReturnType() const
Determine whether a trailing return type was written (at any level) within this declarator.
DiagnosticsEngine & getDiagnostics() const
SourceLocation getBeginLoc() const LLVM_READONLY
One instance of this struct is used for each type in a declarator that is parsed. ...
QualType getCorrespondingUnsignedType(QualType T) const
SourceLocation EndLoc
EndLoc - If valid, the place where this chunck ends.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
Wrapper for source info for typedefs.
static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk)
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
SourceLocation getEndLoc() const LLVM_READONLY
bool isTypeSpecSat() const
const TargetInfo & getTargetInfo() const
The attribute is part of a DeclaratorChunk.
RefQualifierKind RefQualifier
A container of type source information.
bool getHasRegParm() const
bool hasConstexprNonCopyMoveConstructor() const
Determine whether this class has at least one constexpr constructor other than the copy or move const...
static void diagnoseAndRemoveTypeQualifiers(Sema &S, const DeclSpec &DS, unsigned &TypeQuals, QualType TypeSoFar, unsigned RemoveTQs, unsigned DiagID)
static void fillDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc DASTL, const ParsedAttributesView &Attrs)
static void transferARCOwnership(TypeProcessingState &state, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership)
Used for transferring ownership in casts resulting in l-values.
An overloaded operator name, e.g., operator+.
bool getSuppressSystemWarnings() const
Wrapper for source info for pointers decayed from arrays and functions.
Abstract base class used for diagnosing integer constant expression violations.
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
SourceLocation getEllipsisLoc() const
SourceLocation getLocalBeginLoc() const
Retrieve the location of the beginning of this component of the nested-name-specifier.
SourceLocation getEndLoc() const
Get the end source location.
#define NULLABILITY_TYPE_ATTRS_CASELIST
const ParsedAttributes & getAttributes() const
unsigned RestrictQualLoc
The location of the restrict-qualifier, if any.
bool hasAttribute(ParsedAttr::Kind K) const
const AttributedType * getCallingConvAttributedType(QualType T) const
Get the outermost AttributedType node that sets a calling convention.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
void setParensRange(SourceRange range)
An identifier, stored as an IdentifierInfo*.
bool isFunctionDeclarationContext() const
Return true if this declaration appears in a context where a function declarator would be a function ...
Represents a variable declaration or definition.
static bool handleObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
static OpenCLAccessAttr::Spelling getImageAccess(const ParsedAttributesView &Attrs)
unsigned isStar
True if this dimension was [*]. In this case, NumElts is null.
static DeclaratorChunk * maybeMovePastReturnType(Declarator &declarator, unsigned i, bool onlyBlockPointers)
Given the index of a declarator chunk, check whether that chunk directly specifies the return type of...
static const TST TST_underlyingType
Information about one declarator, including the parsed type information and the identifier.
void removeObjCLifetime()
LangAS getLangASFromTargetAS(unsigned TargetAS)
void initialize(ASTContext &Context, SourceLocation Loc) const
Initializes this to state that every location in this type is the given location. ...
DiagnosticsEngine & Diags
Wrapper for source info for member pointers.
bool isEnumeralType() const
Wrapper of type source information for a type with non-trivial direct qualifiers. ...
const T * getAs() const
Member-template getAs<specific type>'.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
unsigned getParsedSpecifiers() const
Return a bitmask of which flavors of specifiers this DeclSpec includes.
Extra information about a function prototype.
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Represents a C++17 deduced template specialization type.
The "__interface" keyword.
bool isCXX11Attribute() const
static const TST TST_interface
static const TST TST_char
A namespace, stored as a NamespaceDecl*.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
bool hasTrivialDefaultConstructor() const
Determine whether this class has a trivial default constructor (C++11 [class.ctor]p5).
TypeLoc getNamedTypeLoc() const
bool isInvalidDecl() const
void setAttrOperandParensRange(SourceRange range)
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
bool isCallingConv() const
Describes how types, statements, expressions, and declarations should be printed. ...
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
bool hasMethodTypeQualifiers() const
Determine whether this method has qualifiers.
bool hasDefinition() const
unsigned getNumExceptions() const
Get the number of dynamic exception specifications.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Represents a parameter to a function.
OpenCLOptions & getOpenCLOptions()
noexcept(expression), value-dependent
enum clang::DeclaratorChunk::@217 Kind
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
The collection of all-type qualifiers we support.
bool isVariableArrayType() const
bool needsExtraLocalData() const
SourceRange getTypeSpecWidthRange() const
void setParensRange(SourceRange Range)
static const TST TST_unknown_anytype
bool canHaveNullability(bool ResultIfUnknown=true) const
Determine whether the given type can have a nullability specifier applied to it, i.e., if it is any kind of pointer type.
Base wrapper for a particular "section" of type source info.
MSInheritanceAttr::Spelling calculateInheritanceModel() const
Calculate what the inheritance model would be for this class.
QualType BuildMemberPointerType(QualType T, QualType Class, SourceLocation Loc, DeclarationName Entity)
Build a member pointer type T Class::*.
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
Represents a struct/union/class.
static AttrT * createSimpleAttr(ASTContext &Ctx, ParsedAttr &Attr)
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
bool isDependentScopeSpecifier(const CXXScopeSpec &SS)
Expr * NoexceptExpr
Pointer to the expression in the noexcept-specifier of this function, if it has one.
TypeSpecifierSign getWrittenSignSpec() const
FunctionType::ExtInfo ExtInfo
One of these records is kept for each identifier that is lexed.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
void setLocalRangeEnd(SourceLocation L)
static bool checkQualifiedFunction(Sema &S, QualType T, SourceLocation Loc, QualifiedFunctionKind QFK)
Check whether the type T is a qualified function type, and if it is, diagnose that it cannot be conta...
static bool hasOuterPointerLikeChunk(const Declarator &D, unsigned endIndex)
Returns true if any of the declarator chunks before endIndex include a level of indirection: array...
unsigned getAttributeSpellingListIndex() const
Get an index into the attribute spelling list defined in Attr.td.
SourceLocation getExceptionSpecLocBeg() const
const WrittenBuiltinSpecs & getWrittenBuiltinSpecs() const
SourceLocation getBegin() const
static const TST TST_decimal32
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
QualType IgnoreParens() const
Returns the specified type after dropping any outer-level parentheses.
UnionParsedType ConversionFunctionId
When Kind == IK_ConversionFunctionId, the type that the conversion function names.
Represents a class type in Objective C.
static const TST TST_char8
QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace, SourceLocation AttrLoc)
BuildAddressSpaceAttr - Builds a DependentAddressSpaceType if an expression is uninstantiated.
static void deduceOpenCLImplicitAddrSpace(TypeProcessingState &State, QualType &T, TypeAttrLocation TAL)
bool hasExplicitCallingConv(QualType T)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
A C++ nested-name-specifier augmented with source location information.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
ArrayRef< QualType > getParamTypes() const
SourceLocation getTypeSpecTypeLoc() const
bool CheckAttrTarget(const ParsedAttr &CurrAttr)
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
QualType BuildParenType(QualType T)
Build a paren type including T.
void setBuiltinLoc(SourceLocation Loc)
QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc)
bool isSpelledAsLValue() const
field_range fields() const
void setRBracketLoc(SourceLocation Loc)
static SourceLocation getFromRawEncoding(unsigned Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
static void HandleVectorSizeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
HandleVectorSizeAttribute - this attribute is only applicable to integral and float scalars...
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
SourceLocation getBeginLoc() const LLVM_READONLY
static const TST TST_class
NameKind getNameKind() const
Determine what kind of name this is.
static void fillAttributedTypeLoc(AttributedTypeLoc TL, TypeProcessingState &State)
void checkExceptionSpecification(bool IsTopLevel, ExceptionSpecificationType EST, ArrayRef< ParsedType > DynamicExceptions, ArrayRef< SourceRange > DynamicExceptionRanges, Expr *NoexceptExpr, SmallVectorImpl< QualType > &Exceptions, FunctionProtoType::ExceptionSpecInfo &ESI)
Check the given exception-specification and update the exception specification information with the r...
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
static const TST TST_double
bool hasAutoTypeSpec() const
bool isReferenceType() const
void setElaboratedKeywordLoc(SourceLocation Loc)
static bool IsNoDerefableChunk(DeclaratorChunk Chunk)
static std::string getPrintableNameForEntity(DeclarationName Entity)
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
ParsedType ActOnObjCInstanceType(SourceLocation Loc)
The parser has parsed the context-sensitive type 'instancetype' in an Objective-C message declaration...
static const TST TST_error
bool hasStructuralCompatLayout(Decl *D, Decl *Suggested)
Determine if D and Suggested have a structurally compatible layout as described in C11 6...
static const TST TST_enum
static void maybeSynthesizeBlockSignature(TypeProcessingState &state, QualType declSpecType)
Add a synthetic '()' to a block-literal declarator if it is required, given the return type...
TypeLoc getNextTypeLoc() const
static const TSW TSW_unspecified
void copy(DependentTemplateSpecializationTypeLoc Loc)
__DEVICE__ int max(int __a, int __b)
bool hasTagDefinition() const
TSC getTypeSpecComplex() const
Wrapper of type source information for a type with no direct qualifiers.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
const AstTypeMatcher< TypedefType > typedefType
Matches typedef types.
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param Data Additional data for task generation like final * state
static const TST TST_accum
A user-defined literal name, e.g., operator "" _i.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this attribute.
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
bool isInvalidType() const
Values of this type can be null.
static void inferARCWriteback(TypeProcessingState &state, QualType &declSpecType)
Given that this is the declaration of a parameter under ARC, attempt to infer attributes and such for...
bool getProducesResult() const
static void HandleLifetimeBoundAttr(TypeProcessingState &State, QualType &CurType, ParsedAttr &Attr)
bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value)
void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, SourceLocation Loc)
Adjust the calling convention of a method to be the ABI default if it wasn't specified explicitly...
TypeSpecifierWidth getWrittenWidthSpec() const
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment...
Represents a C++ unqualified-id that has been parsed.
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
bool hasNonLiteralTypeFieldsOrBases() const
Determine whether this class has a non-literal or/ volatile type non-static data member or base class...
void setNameLoc(SourceLocation Loc)
void setAttr(const Attr *A)
static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, TypeSourceInfo *&ReturnTypeInfo)
Represents the results of name lookup.
An lvalue ref-qualifier was provided (&).
unsigned ConstQualLoc
The location of the const-qualifier, if any.
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
void setExpansionLoc(SourceLocation Loc)
static void fixItNullability(Sema &S, DiagnosticBuilder &Diag, SourceLocation PointerLoc, NullabilityKind Nullability)
Creates a fix-it to insert a C-style nullability keyword at pointerLoc, taking into account whitespac...
LLVM_READONLY bool isWhitespace(unsigned char c)
Return true if this character is horizontal or vertical ASCII whitespace: ' ', '\t', '\f', '\v', '\n', '\r'.
void setCaretLoc(SourceLocation Loc)
TagKind getTagKind() const
static PointerDeclaratorKind classifyPointerDeclarator(Sema &S, QualType type, Declarator &declarator, PointerWrappingDeclaratorKind &wrappingKind)
Classify the given declarator, whose type-specified is type, based on what kind of pointer it refers ...
Microsoft throw(...) extension.
const FileInfo & getFile() const
bool checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType T)
Check if type T corresponding to declaration specifier DS is disabled due to required OpenCL extensio...
bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC, const FunctionDecl *FD=nullptr)
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
bool isTypeSpecPipe() const
const Type * getClass() const
Wrapper for source info for functions.
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
static bool hasDirectOwnershipQualifier(QualType type)
Does this type have a "direct" ownership qualifier? That is, is it written like "__strong id"...
Whether values of this type can be null is (explicitly) unspecified.
An x-value expression is a reference to an object with independent storage but which can be "moved"...
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state, QualType &declSpecType)
Given that there are attributes written on the declarator itself, try to distribute any type attribut...
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation...
const clang::PrintingPolicy & getPrintingPolicy() const
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
void addCVRQualifiers(unsigned mask)
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack)
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
void AddInnermostTypeInfo(const DeclaratorChunk &TI)
Add a new innermost chunk to this declarator.
const Type * getClass() const
void expandBuiltinRange(SourceRange Range)
TSS getTypeSpecSign() const
void setUsedAsTypeAttr(bool Used=true)
bool isLambda() const
Determine whether this class describes a lambda function object.
Values of this type can never be null.
QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc)
Given a variable, determine the type that a reference to that variable will have in the given scope...
Scope - A scope is a transient data structure that is used while parsing the program.
Wrapper for source info for ObjC interfaces.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
QualType BuildExtVectorType(QualType T, Expr *ArraySize, SourceLocation AttrLoc)
Build an ext-vector type.
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, CorrectionCandidateCallback *CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements)
Determine the number of bits required to address a member of.
Represents a C++ nested-name-specifier or a global scope specifier.
Represents an Objective-C protocol declaration.
#define MS_TYPE_ATTRS_CASELIST
void setUnaligned(bool flag)
static void distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType)
A function type attribute was written on the declarator.
bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const
static FileID getNullabilityCompletenessCheckFileID(Sema &S, SourceLocation loc)
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
const LangOptions & getLangOpts() const
SourceLocation getConstSpecLoc() const
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
void addCVRUQualifiers(unsigned mask)
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
void setLocalRangeBegin(SourceLocation L)
void addAtEnd(ParsedAttr *newAttr)
static void transferARCOwnershipToDeclSpec(Sema &S, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership)
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Represents an ObjC class declaration.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs, typeofs, etc., as well as any qualifiers.
void copy(ElaboratedTypeLoc Loc)
SourceLocation getIncludeLoc() const
SourceRange getSourceRange() const LLVM_READONLY
static bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
handleObjCGCTypeAttr - Process the attribute((objc_gc)) type attribute on the specified type...
is ARM Neon polynomial vector
static NullabilityKind mapNullabilityAttrKind(ParsedAttr::Kind kind)
Map a nullability attribute kind to a nullability kind.
static bool BuildAddressSpaceIndex(Sema &S, LangAS &ASIdx, const Expr *AddrSpace, SourceLocation AttrLoc)
Build an AddressSpace index from a constant expression and diagnose any errors related to invalid add...
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
IdentifierInfo * getIdentifier() const
CanQualType UnsignedCharTy
void setAttrNameLoc(SourceLocation loc)
const LangOptions & LangOpts
static std::string getFunctionQualifiersAsString(const FunctionProtoType *FnTy)
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
uint8_t PointerKind
Which kind of pointer declarator we saw.
This object can be modified without requiring retains or releases.
static const TST TST_float
CXXRecordDecl * getMostRecentNonInjectedDecl()
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
void setInvalid(bool b=true) const
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
bool isExpressionContext() const
Determine whether this declaration appears in a context where an expression could appear...
ExtInfo withCallingConv(CallingConv cc) const
void * getOpaqueData() const
Get the pointer where source information is stored.
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
QualType BuildBlockPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a block pointer type.
TypeResult actOnObjCTypeArgsAndProtocolQualifiers(Scope *S, SourceLocation Loc, ParsedType BaseType, SourceLocation TypeArgsLAngleLoc, ArrayRef< ParsedType > TypeArgs, SourceLocation TypeArgsRAngleLoc, SourceLocation ProtocolLAngleLoc, ArrayRef< Decl *> Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc)
Build a specialized and/or protocol-qualified Objective-C type.
llvm::StringRef getParameterABISpelling(ParameterABI kind)
bool hasUserProvidedDefaultConstructor() const
Whether this class has a user-provided default constructor per C++11.
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind UKind) const
Unary type transforms.
QualType getCorrespondingSaturatedType(QualType Ty) const
Sema - This implements semantic analysis and AST building for C.
static const TSW TSW_long
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl *> DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), DeclSpec *MethodQualifiers=nullptr)
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
A little helper class used to produce diagnostics.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
SourceLocation getUnalignedSpecLoc() const
Represents a prototype with parameter type info, e.g.
bool hasConstexprSpecifier() const
Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing.
QualType getDependentAddressSpaceType(QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttrLoc) const
QualType applyObjCProtocolQualifiers(QualType type, ArrayRef< ObjCProtocolDecl *> protocols, bool &hasError, bool allowOnPointerType=false) const
Apply Objective-C protocol qualifiers to the given type.
static void checkExtParameterInfos(Sema &S, ArrayRef< QualType > paramTypes, const FunctionProtoType::ExtProtoInfo &EPI, llvm::function_ref< SourceLocation(unsigned)> getParamLoc)
Check the extended parameter information.
DeclSpec * MethodQualifiers
DeclSpec for the function with the qualifier related info.
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
ArraySizeModifier
Capture whether this is a normal array (e.g.
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/unaligned/atomic.
void addObjCLifetime(ObjCLifetime type)
static QualType ConvertDeclSpecToType(TypeProcessingState &state)
Convert the specified declspec to the appropriate type object.
bool isEnabled(llvm::StringRef Ext) const
void setSizeExpr(Expr *Size)
A conversion function name, e.g., operator int.
SourceRange getRange() const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
TST getTypeSpecType() const
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
Scope * getCurScope() const
Retrieve the parser's current scope.
CharacteristicKind getFileCharacteristic() const
Return whether this is a system header or not.
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
unsigned hasStatic
True if this dimension included the 'static' keyword.
SourceLocation getBeginLoc() const
Get the begin source location.
Type source information for an attributed type.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorType::VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
This represents one expression.
QualType getPointeeType() const
Declaration of a template type parameter.
bool isObjCARCImplicitlyUnretainedType() const
Determines if this type, which must satisfy isObjCLifetimeType(), is implicitly __unsafe_unretained r...
unsigned VolatileQualLoc
The location of the volatile-qualifier, if any.
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
This file defines the classes used to store parsed information about declaration-specifiers and decla...
const T * castAs() const
Member-template castAs<specific type>.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
TypeResult ActOnTypeName(Scope *S, Declarator &D)
bool isObjCRetainableType() const
QualType getTypeOfExprType(Expr *e) const
GCC extension.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Represents a C++ destructor within a class.
Qualifiers::GC getObjCGCAttr() const
Returns gc attribute of this type.
QualType getParenType(QualType NamedType) const
static void HandleExtVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
Process the OpenCL-like ext_vector_type attribute when it occurs on a type.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
std::string getAsString() const
Retrieve the human-readable string for this name.
TypeResult actOnObjCProtocolQualifierType(SourceLocation lAngleLoc, ArrayRef< Decl *> protocols, ArrayRef< SourceLocation > protocolLocs, SourceLocation rAngleLoc)
Build a an Objective-C protocol-qualified 'id' type where no base type was specified.
SourceLocation getVolatileSpecLoc() const
QualType BuildAtomicType(QualType T, SourceLocation Loc)
void ClearTypeQualifiers()
Clear out all of the type qualifiers.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
Defines the clang::Preprocessor interface.
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, bool AllowFold=true)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
void completeExprArrayBound(Expr *E)
ObjCLifetime getObjCLifetime() const
bool supportsVariadicCall(CallingConv CC)
Checks whether the given calling convention supports variadic calls.
SourceLocation getBeginLoc() const
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
internal::Matcher< T > id(StringRef ID, const internal::BindableMatcher< T > &InnerMatcher)
If the provided matcher matches a node, binds the node to ID.
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Represents a C++ template name within the type system.
static const TST TST_decimal64
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Defines the clang::TypeLoc interface and its subclasses.
static void warnAboutRedundantParens(Sema &S, Declarator &D, QualType T)
Produce an appropriate diagnostic for a declarator with top-level parentheses.
A namespace alias, stored as a NamespaceAliasDecl*.
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type...
static QualType getDecltypeForExpr(Sema &S, Expr *E)
getDecltypeForExpr - Given an expr, will return the decltype for that expression, according to the ru...
CanQualType UnsignedInt128Ty
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
void setNameLoc(SourceLocation Loc)
bool isFunctionOrMethod() const
static Optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
CharSourceRange getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
bool LValueRef
True if this is an lvalue reference, false if it's an rvalue reference.
SourceLocation Loc
Loc - The place where this type was defined.
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
Qualifiers Quals
The local qualifiers.
void setAttrExprOperand(Expr *e)
DeclContext * getParent()
getParent - Returns the containing DeclContext.
ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for protocol qualifiers are stored aft...
void setHasBaseTypeAsWritten(bool HasBaseType)
void setEllipsisLoc(SourceLocation EL)
static QualType inferARCLifetimeForPointee(Sema &S, QualType type, SourceLocation loc, bool isReference)
Given that we're building a pointer or reference to the given.
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI)
Get a function type and produce the equivalent function type with the specified exception specificati...
SourceLocation getEnd() const
Compare two source locations.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
bool RequireLiteralType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a literal type.
static const TST TST_half
An lvalue reference type, per C++11 [dcl.ref].
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type...
bool isFriendSpecified() const
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
TypeLoc getInnerLoc() const
Wraps an identifier and optional source location for the identifier.
static void moveAttrFromListToList(ParsedAttr &attr, ParsedAttributesView &fromList, ParsedAttributesView &toList)
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
static QualType Desugar(ASTContext &Context, QualType QT, bool &ShouldAKA)
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
SourceLocation getCommaLoc() const
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
bool RequireCompleteExprType(Expr *E, TypeDiagnoser &Diagnoser)
Ensure that the type of the given expression is complete.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
A type, stored as a Type*.
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
static const TSW TSW_short
void removeCVRQualifiers(unsigned mask)
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
SourceLocation PointerLoc
The first pointer declarator (of any pointer kind) in the file that does not have a corresponding nul...
bool isFirstDeclarator() const
TypeSourceInfo * GetTypeForDeclaratorCast(Declarator &D, QualType FromTy)
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const
Return the uniqued reference to the type for an Objective-C gc-qualified type.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType)
TypeAndRange * Exceptions
Pointer to a new[]'d array of TypeAndRange objects that contain the types in the function's dynamic e...
SourceLocation getRefQualifierLoc() const
Retrieve the location of the ref-qualifier, if any.
bool isConstQualified() const
Determine whether this type is const-qualified.
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
unsigned getSemanticSpelling() const
If the parsed attribute has a semantic equivalent, and it would have a semantic Spelling enumeration ...
RecordDecl * getDecl() const
static bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator, QualType Result)
Return true if this is omitted block return type.
void setStarLoc(SourceLocation Loc)
static const TST TST_char32
noexcept(expression), evals to 'false'
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
QualType getPackExpansionType(QualType Pattern, Optional< unsigned > NumExpansions)
static const TST TST_fract
SmallVector< NamedDecl *, 4 > TemplateParams
Store the list of the template parameters for a generic lambda.
void setTypeofLoc(SourceLocation Loc)
static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
handleObjCOwnershipTypeAttr - Process an objc_ownership attribute on the specified type...
bool SawTypeNullability
Whether we saw any type nullability annotations in the given file.
static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy, Declarator &D, unsigned FunctionChunkIndex)
A parameter attribute which changes the argument-passing ABI rule for the parameter.
Wrapper for source info for arrays.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
There is no lifetime qualification on this type.
Information about a FileID, basically just the logical file that it represents and include stack info...
is AltiVec 'vector Pixel'
static QualType applyObjCTypeArgs(Sema &S, SourceLocation loc, QualType type, ArrayRef< TypeSourceInfo *> typeArgs, SourceRange typeArgsRange, bool failOnError=false)
Apply Objective-C type arguments to the given type.
Assigning into this object requires the old value to be released and the new value to be retained...
bool isBuiltinType() const
Helper methods to distinguish type categories.
not a target-specific vector type
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
The attribute is in the decl-specifier-seq.
ExtProtoInfo getExtProtoInfo() const
SCS getStorageClassSpec() const
void setKNRPromoted(bool promoted)
ASTContext & getASTContext() const
SourceLocation getRParenLoc() const
static bool isPermittedNeonBaseType(QualType &Ty, VectorType::VectorKind VecKind, Sema &S)
static const TST TST_float16
static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
Process an individual function attribute.
const ExtParameterInfo * ExtParameterInfos
static void distributeObjCPointerTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType type)
Given that an objc_gc attribute was written somewhere on a declaration other than on the declarator i...
Encodes a location in the source.
bool isTypeSpecOwned() const
Sugar for parentheses used when specifying types.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
QualType getReturnType() const
static const TST TST_auto_type
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
bool CheckDistantExceptionSpec(QualType T)
CheckDistantExceptionSpec - Check if the given type is a pointer or pointer to member to a function w...
LangAS getAddressSpace() const
Return the address space of this type.
static void distributeObjCPointerTypeAttrFromDeclarator(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType)
Distribute an objc_gc type attribute that was written on the declarator.
PointerDeclaratorKind
Describes the kind of a pointer a declarator describes.
Interfaces are the core concept in Objective-C for object oriented design.
FunctionDefinitionKind getFunctionDefinitionKind() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword...
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Syntax
The style used to specify an attribute.
ParameterABI getABI() const
Return the ABI treatment of this parameter.
Represents the declaration of a struct/union/class/enum.
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, Qualifiers::ObjCLifetime ownership, unsigned chunkIndex)
static void distributeFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType type)
A function type attribute was written somewhere in a declaration other than on the declarator itself ...
ASTContext & getASTContext() const LLVM_READONLY
SourceLocation getEndLoc() const LLVM_READONLY
The maximum supported address space number.
static const TST TST_union
CallingConv getCC() const
ParsedAttr - Represents a syntactic attribute.
QualType getWritePipeType(QualType T) const
Return a write_only pipe type for the specified type.
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
static const TSS TSS_signed
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
RecordDecl * CFError
The struct behind the CFErrorRef pointer.
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
No ref-qualifier was provided.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
MemberPointerTypeInfo Mem
Qualifiers getMethodQuals() const
SimplePointerKind
A simple notion of pointer kinds, which matches up with the various pointer declarators.
QualType getEquivalentType() const
static CallingConv getCCForDeclaratorChunk(Sema &S, Declarator &D, const ParsedAttributesView &AttrList, const DeclaratorChunk::FunctionTypeInfo &FTI, unsigned ChunkIndex)
Helper for figuring out the default CC for a function declarator type.
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
void remove(ParsedAttr *ToBeRemoved)
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
bool isContextSensitiveKeywordAttribute() const
bool hasTrailingReturnType() const
Determine whether this function declarator had a trailing-return-type.
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
bool isObjCObjectPointerType() const
bool isAnyPointerType() const
static bool distributeFunctionTypeAttrToInnermost(TypeProcessingState &state, ParsedAttr &attr, ParsedAttributesView &attrList, QualType &declSpecType)
Try to distribute a function type attribute to the innermost function chunk or type.
bool isArgExpr(unsigned Arg) const
Decl * getRepAsDecl() const
bool isDecltypeType() const
static bool isBlockPointer(Expr *Arg)
is AltiVec 'vector bool ...'
SplitQualType getSplitUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
bool isFunctionProtoType() const
static const TST TST_typeofType
void setAmpLoc(SourceLocation Loc)
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
void setLBracketLoc(SourceLocation Loc)
AutoTypeKeyword getKeyword() const
TypeClass getTypeClass() const
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
bool HasRestrict
The type qualifier: restrict. [GNU] C++ extension.
SourceLocation getRAngleLoc() const
TypeLoc findExplicitQualifierLoc() const
Find a type with the location of an explicit type qualifier.
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/__unaligned/_Atomic.
static bool isVectorSizeTooLarge(unsigned NumElements)
static Attr * createNullabilityAttr(ASTContext &Ctx, ParsedAttr &Attr, NullabilityKind NK)
SourceLocation getPragmaAssumeNonNullLoc() const
The location of the currently-active #pragma clang assume_nonnull begin.
bool isStaticMember()
Returns true if this declares a static member.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
An rvalue ref-qualifier was provided (&&).
Assigning into this object requires a lifetime extension.
unsigned getFullDataSize() const
Returns the size of the type source info data block.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
bool isVLASupported() const
Whether target supports variable-length arrays.
std::string getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const
Get a string to suggest for zero-initialization of a type.
static void recordNullabilitySeen(Sema &S, SourceLocation loc)
Marks that a nullability feature has been used in the file containing loc.
SourceRange getRange() const
std::string getAsString() const
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;...
Represents a pack expansion of types.
static bool checkNullabilityTypeSpecifier(TypeProcessingState &state, QualType &type, ParsedAttr &attr, bool allowOnArrayType)
Applies a nullability type specifier to the given type, if possible.
void setLParenLoc(SourceLocation Loc)
StringRef getName() const
Return the actual identifier string.
static bool checkObjCKindOfType(TypeProcessingState &state, QualType &type, ParsedAttr &attr)
Check the application of the Objective-C '__kindof' qualifier to the given type.
void setTypeArgsLAngleLoc(SourceLocation Loc)
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
CanQualType UnsignedShortTy
static unsigned getMaxSizeBits(const ASTContext &Context)
Determine the maximum number of active bits that an array's size can require, which limits the maximu...
Base class for declarations which introduce a typedef-name.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
TSW getTypeSpecWidth() const
static const TST TST_decltype_auto
void setClassTInfo(TypeSourceInfo *TI)
TagTypeKind
The kind of a tag type.
QualType getTypeOfType(QualType t) const
getTypeOfType - Unlike many "get<Type>" functions, we don't unique TypeOfType nodes.
CanQualType ObjCBuiltinIdTy
Dataflow Directional Tag Classes.
unsigned TypeQuals
The type qualifiers for the array: const/volatile/restrict/__unaligned/_Atomic.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation ImplicitMSInheritanceAttrLoc
Source location for newly created implicit MSInheritanceAttrs.
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type...
static const TSS TSS_unspecified
SourceLocation getTypeSpecWidthLoc() const
ExtInfo getExtInfo() const
not evaluated yet, for special member function
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
void setAmpAmpLoc(SourceLocation Loc)
bool CheckFunctionReturnType(QualType T, SourceLocation Loc)
void diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, SourceLocation FallbackLoc, SourceLocation ConstQualLoc=SourceLocation(), SourceLocation VolatileQualLoc=SourceLocation(), SourceLocation RestrictQualLoc=SourceLocation(), SourceLocation AtomicQualLoc=SourceLocation(), SourceLocation UnalignedQualLoc=SourceLocation())
static const TST TST_decltype
static const TST TST_auto
static const TST TST_void
static TypeSourceInfo * GetTypeSourceInfoForDeclarator(TypeProcessingState &State, QualType T, TypeSourceInfo *ReturnTypeInfo)
Create and instantiate a TypeSourceInfo with type source information.
unsigned isVariadic
isVariadic - If this function has a prototype, and if that proto ends with ',...)', this is true.
const DeclaratorChunk * getInnermostNonParenChunk() const
Return the innermost (closest to the declarator) chunk of this declarator that is not a parens chunk...
static bool distributeNullabilityTypeAttr(TypeProcessingState &state, QualType type, ParsedAttr &attr)
Distribute a nullability type attribute that cannot be applied to the type specifier to a pointer...
static const TST TST_int128
SourceLocation PointerEndLoc
The end location for the first pointer declarator in the file.
QualType getUnderlyingType() const
CanQualType UnsignedLongLongTy
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
QualType BuildPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a pointer type.
static Attr * getCCTypeAttr(ASTContext &Ctx, ParsedAttr &Attr)
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
The name of a declaration.
Represents the declaration of an Objective-C type parameter.
SourceLocation getLoc() const
bool isBooleanType() const
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
LLVM_READONLY bool isIdentifierBody(unsigned char c, bool AllowDollar=false)
Returns true if this is a body character of a C identifier, which is [a-zA-Z0-9_].
SourceLocation getTypeSpecSignLoc() const
ParsedAttr * create(IdentifierInfo *attrName, SourceRange attrRange, IdentifierInfo *scopeName, SourceLocation scopeLoc, ArgsUnion *args, unsigned numArgs, ParsedAttr::Syntax syntax, SourceLocation ellipsisLoc=SourceLocation())
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
QualType BuildReadPipeType(QualType T, SourceLocation Loc)
Build a Read-only Pipe type.
#define FUNCTION_TYPE_ATTRS_CASELIST
static bool isArraySizeVLA(Sema &S, Expr *ArraySize, llvm::APSInt &SizeVal)
Check whether the specified array size makes the array type a VLA.
A pointer to member type per C++ 8.3.3 - Pointers to members.
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
bool hasObjCLifetime() const
static void processTypeAttrs(TypeProcessingState &state, QualType &type, TypeAttrLocation TAL, ParsedAttributesView &attrs)
SplitQualType getSingleStepDesugaredType() const
TypeLoc getModifiedLoc() const
The modified type, which is generally canonically different from the attribute type.
virtual bool hasFloat16Type() const
Determine whether the _Float16 type is supported on this target.
IdentifierInfo * getName() const
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration...
static void HandleOpenCLAccessAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S)
Handle OpenCL Access Qualifier Attribute.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
A type that was preceded by the 'template' keyword, stored as a Type*.
static const TST TST_unspecified
SourceLocation getBeginLoc() const LLVM_READONLY
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
QualType getUnsignedWCharType() const
Return the type of "unsigned wchar_t".
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
bool isValid() const
A scope specifier is present, and it refers to a real scope.
TemplateNameKindForDiagnostics getTemplateNameKindForDiagnostics(TemplateName Name)
void forEachQualifier(llvm::function_ref< void(TQ, StringRef, SourceLocation)> Handle)
This method calls the passed in handler on each qual being set.
QualType getModifiedType() const
unsigned getNumParams() const
void setNameLoc(SourceLocation Loc)
bool CheckAttrNoArgs(const ParsedAttr &CurrAttr)
Represents a pointer to an Objective C object.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
IdentifierInfo * getNSErrorIdent()
Retrieve the identifier "NSError".
bool IsEquivalent(Decl *D1, Decl *D2)
Determine whether the two declarations are structurally equivalent.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
static void HandleNeonVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S, VectorType::VectorKind VecKind)
HandleNeonVectorTypeAttr - The "neon_vector_type" and "neon_polyvector_type" attributes are used to c...
bool isIncompleteArrayType() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
static const TST TST_decimal128
static void distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType)
A function type attribute was written in the decl spec.
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6.7.5p3.
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
unsigned hasPrototype
hasPrototype - This is true if the function had at least one typed parameter.
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
This template specialization was declared or defined by an explicit specialization (C++ [temp...
#define OBJC_POINTER_TYPE_ATTRS_CASELIST
CanQualType UnsignedLongTy
static bool isFunctionOrMethod(const Decl *D)
isFunctionOrMethod - Return true if the given decl has function type (function or function-typed vari...
type_object_range type_objects() const
Returns the range of type objects, from the identifier outwards.
bool isAtomicType() const
bool isFunctionType() const
static const TST TST_typename
QualType BuildDecltypeType(Expr *E, SourceLocation Loc, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
Base for LValueReferenceType and RValueReferenceType.
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
void copy(TemplateSpecializationTypeLoc Loc)
Wraps an ObjCPointerType with source location information.
Holds information about the various types of exception specification.
unsigned AtomicQualLoc
The location of the _Atomic-qualifier, if any.
virtual bool hasFloat128Type() const
Determine whether the __float128 type is supported on this target.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
ExceptionSpecificationType getExceptionSpecType() const
Get the type of exception specification this function has.
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
SourceLocation getTypeSpecTypeNameLoc() const
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
CXXScopeSpec & getTypeSpecScope()
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
SourceRange getExceptionSpecRange() const
bool isObjectType() const
Determine whether this type is an object type.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const
ObjCIvarRefExpr - A reference to an ObjC instance variable.
static void warnAboutAmbiguousFunction(Sema &S, Declarator &D, DeclaratorChunk &DeclType, QualType RT)
Produce an appropriate diagnostic for an ambiguity between a function declarator and a C++ direct-ini...
bool isObjCObjectType() const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
bool hasObjCGCAttr() const
Describes whether we've seen any nullability information for the given file.
UnqualTypeLoc getUnqualifiedLoc() const
SourceLocation getIdentifierLoc() const
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool isSet() const
Deprecated.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
PointerWrappingDeclaratorKind
Describes a declarator chunk wrapping a pointer that marks inference as unexpected.
void setInvalidType(bool Val=true)
Reading or writing from this object requires a barrier call.
Context-sensitive version of a keyword attribute.
unsigned AutoTemplateParameterDepth
If this is a generic lambda, use this as the depth of each 'auto' parameter, during initial AST const...
An attributed type is a type to which a type attribute has been applied.
LangAS asOpenCLLangAS() const
If this is an OpenCL addr space attribute returns its representation in LangAS, otherwise returns def...
void setKWLoc(SourceLocation Loc)
unsigned TypeQuals
For now, sema will catch these as invalid.
TranslationUnitDecl * getTranslationUnitDecl() const
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
CallingConv getCallConv() const
Captures information about "declaration specifiers".
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
SourceLocation getRestrictSpecLoc() const
Represents a C++ struct/union/class.
SourceLocation getEllipsisLoc() const
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
Expr * NumElts
This is the size of the array, or null if [] or [*] was specified.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
void setParam(unsigned i, ParmVarDecl *VD)
Provides information a specialization of a member of a class template, which may be a member function...
LangOptions::PragmaMSPointersToMembersKind MSPointerToMemberRepresentationMethod
Controls member pointer representation format under the MS ABI.
static const TST TST_float128
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
void setLParenLoc(SourceLocation Loc)
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
static const TST TST_bool
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
static void assignInheritanceModel(Sema &S, CXXRecordDecl *RD)
Locks in the inheritance model for the given class and all of its bases.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
This class is used for builtin types like 'int'.
IdentifierInfo * getNullabilityKeyword(NullabilityKind nullability)
Retrieve the keyword associated.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
SourceManager & getSourceManager() const
A template-id, e.g., f<int>.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
ParsedType getRepAsType() const
Defines the clang::TargetInfo interface.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
A SourceLocation and its associated SourceManager.
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
SourceLocation getAtomicSpecLoc() const
QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement)
Completely replace the auto in TypeWithAuto by Replacement.
static Qualifiers fromCVRMask(unsigned CVR)
Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const
Recurses in pointer/array types until it finds an Objective-C retainable type and returns its ownersh...
static const TSW TSW_longlong
QualType getSignedWCharType() const
Return the type of "signed wchar_t".
static OpaquePtr make(QualType P)
Microsoft __declspec(nothrow) extension.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
static void emitNullabilityConsistencyWarning(Sema &S, SimplePointerKind PointerKind, SourceLocation PointerLoc, SourceLocation PointerEndLoc)
A reference to a declared variable, function, enum, etc.
bool hasRefQualifier() const
Determine whether this function declaration contains a ref-qualifier.
Represents an extended address space qualifier where the input address space value is dependent...
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
void copy(TypeLoc other)
Copies the other type loc into this one.
static const TST TST_atomic
bool isPointerType() const
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false) const
C++11 deduced auto type.
SourceManager & SourceMgr
bool isEmpty() const
isEmpty - Return true if this declaration specifier is completely empty: no tokens were parsed in the...
void addAddressSpace(LangAS space)
static const TST TST_struct
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
class clang::Sema::DelayedDiagnostics DelayedDiagnostics
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same type.
DeclaratorContext getContext() const
static StringRef getNameForCallConv(CallingConv CC)
Wrapper for source info for builtin types.
An l-value expression is a reference to an object with independent storage.
void setRParenLoc(SourceLocation Loc)
bool isArgIdent(unsigned Arg) const
A trivial tuple used to represent a source range.
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined...
static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type)
This represents a decl that may have a name.
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
virtual void diagnose(Sema &S, SourceLocation Loc, QualType T)=0
void copy(DependentNameTypeLoc Loc)
Expr * getRepAsExpr() const
QualifiedFunctionKind
Kinds of declarator that cannot contain a qualified function type.
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
__ptr16, alignas(...), etc.
No keyword precedes the qualified type name.
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type...
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
static void HandleAddressSpaceTypeAttribute(QualType &Type, const ParsedAttr &Attr, TypeProcessingState &State)
HandleAddressSpaceTypeAttribute - Process an address_space attribute on the specified type...
TypeAttrLocation
The location of a type attribute.
static TypeSourceInfo * GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo)
bool isAggregate() const
Determine whether this class is an aggregate (C++ [dcl.init.aggr]), which is a class with no user-dec...
attr::Kind getKind() const
bool isFirstDeclarationOfMember()
Returns true if this declares a real member and not a friend.
llvm::StringRef getNullabilitySpelling(NullabilityKind kind, bool isContextSensitive=false)
Retrieve the spelling of the given nullability kind.
The global specifier '::'. There is no stored value.
bool isPrototypeContext() const
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
void setType(QualType newType)
AttributePool & getAttributePool() const
Wrapper for source info for pointers.
SourceLocation getBegin() const
QualType getReadPipeType(QualType T) const
Return a read_only pipe type for the specified type.
bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type)
Wrapper for source info for block pointers.
unsigned size() const
Determine the number of type parameters in this list.
An implicit 'self' parameter.
base_class_range vbases()
ExceptionSpecInfo ExceptionSpec
A deduction-guide name (a template-name)
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
IdentifierLoc * getArgAsIdent(unsigned Arg) const
A class which abstracts out some details necessary for making a call.
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
void setElaboratedKeywordLoc(SourceLocation Loc)
Attr - This represents one attribute.
ParsedAttributes & getAttributes()
SourceLocation getLocation() const
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type...
SourceRange getTypeofParensRange() const
QualType getPointeeType() const
TypeSourceInfo * GetTypeForDeclarator(Declarator &D, Scope *S)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
QualType getType() const
Return the type wrapped by this type source info.
bool isBeingDefined() const
Return true if this decl is currently being defined.
This parameter (which must have pointer type) is a Swift indirect result parameter.
QualType BuildTypeofExprType(Expr *E, SourceLocation Loc)
void setUnderlyingTInfo(TypeSourceInfo *TI) const
noexcept(expression), evals to 'true'
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
CanQualType UnsignedIntTy
QualType getIncompleteArrayType(QualType EltTy, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
unsigned isAmbiguous
Can this declaration be a constructor-style initializer?