35 #include "llvm/ADT/SmallPtrSet.h" 36 #include "llvm/ADT/SmallString.h" 37 #include "llvm/ADT/StringSwitch.h" 38 #include "llvm/Support/ErrorHandling.h" 40 using namespace clang;
70 bool useExpansionLoc =
true;
72 case ParsedAttr::AT_ObjCGC:
75 case ParsedAttr::AT_ObjCOwnership:
81 useExpansionLoc =
false;
91 if (useExpansionLoc && loc.
isMacroID() && II) {
92 if (II->
isStr(
"strong")) {
94 }
else if (II->
isStr(
"weak")) {
99 S.
Diag(loc, diag::warn_type_attribute_wrong_type) << name << WhichType
105 #define OBJC_POINTER_TYPE_ATTRS_CASELIST \ 106 case ParsedAttr::AT_ObjCGC: \ 107 case ParsedAttr::AT_ObjCOwnership 110 #define CALLING_CONV_ATTRS_CASELIST \ 111 case ParsedAttr::AT_CDecl: \ 112 case ParsedAttr::AT_FastCall: \ 113 case ParsedAttr::AT_StdCall: \ 114 case ParsedAttr::AT_ThisCall: \ 115 case ParsedAttr::AT_RegCall: \ 116 case ParsedAttr::AT_Pascal: \ 117 case ParsedAttr::AT_SwiftCall: \ 118 case ParsedAttr::AT_VectorCall: \ 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 {
177 : sema(sema), declarator(declarator),
179 trivial(
true), hasSavedAttrs(
false) {}
181 Sema &getSema()
const {
189 bool isProcessingDeclSpec()
const {
193 unsigned getCurrentChunkIndex()
const {
197 void setCurrentChunkIndex(
unsigned idx) {
203 if (isProcessingDeclSpec())
204 return getMutableDeclSpec().getAttributes();
209 void saveDeclSpecAttrs() {
211 if (hasSavedAttrs)
return;
213 DeclSpec &spec = getMutableDeclSpec();
215 savedAttrs.push_back(&AL);
216 trivial &= savedAttrs.empty();
217 hasSavedAttrs =
true;
223 ignoredTypeAttrs.push_back(&attr);
229 for (
auto *
Attr : ignoredTypeAttrs)
233 ~TypeProcessingState() {
236 restoreDeclSpecAttrs();
240 DeclSpec &getMutableDeclSpec()
const {
244 void restoreDeclSpecAttrs() {
245 assert(hasSavedAttrs);
247 getMutableDeclSpec().getAttributes().clearListOnly();
249 getMutableDeclSpec().getAttributes().addAtStart(AL);
288 if (attr.
getKind() == ParsedAttr::AT_ObjCGC)
290 assert(attr.
getKind() == ParsedAttr::AT_ObjCOwnership);
305 bool onlyBlockPointers) {
311 for (; i != 0; --i) {
313 switch (fnChunk.
Kind) {
329 for (--i; i != 0; --i) {
331 switch (ptrChunk.
Kind) {
341 if (onlyBlockPointers)
350 llvm_unreachable(
"bad declarator chunk kind");
356 llvm_unreachable(
"bad declarator chunk kind");
373 Declarator &declarator = state.getDeclarator();
376 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
378 switch (chunk.
Kind) {
384 if (state.isProcessingDeclSpec() &&
385 attr.
getKind() == ParsedAttr::AT_ObjCOwnership)
388 if (!destChunk) destChunk = &chunk;
401 if (state.isProcessingDeclSpec() &&
402 attr.
getKind() == ParsedAttr::AT_ObjCOwnership) {
429 Declarator &declarator = state.getDeclarator();
433 unsigned innermost = -1U;
434 bool considerDeclSpec =
true;
437 switch (chunk.
Kind) {
451 considerDeclSpec =
false;
459 if (considerDeclSpec) {
464 state.saveDeclSpecAttrs();
473 if (innermost != -1U) {
481 state.addIgnoredTypeAttr(attr);
490 Declarator &declarator = state.getDeclarator();
494 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
496 switch (chunk.
Kind) {
522 Declarator &declarator = state.getDeclarator();
541 state.saveDeclSpecAttrs();
548 state.getDeclarator().getAttributes());
554 state, attr, state.getCurrentAttributes(), declSpecType))
559 state.addIgnoredTypeAttr(attr);
567 Declarator &declarator = state.getDeclarator();
577 state.addIgnoredTypeAttr(attr);
592 assert(!state.getDeclarator().getAttributes().empty() &&
593 "declarator has no attrs!");
601 if (attr.isCXX11Attribute())
604 switch (attr.getKind()) {
621 case ParsedAttr::AT_ObjCKindOf:
634 Declarator &declarator = state.getDeclarator();
685 loc, loc, declarator));
700 typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc;
705 if (!(RemoveTQs & Qual.first))
709 if (TypeQuals & Qual.first)
710 S.
Diag(Qual.second, DiagID)
715 TypeQuals &= ~Qual.first;
729 if (AL.isInvalid() || !AL.isTypeAttr())
732 diag::warn_block_literal_attributes_on_omitted_return_type)
734 ToBeRemoved.push_back(&AL);
744 diag::warn_block_literal_qualifiers_on_omitted_return_type);
754 bool failOnError =
false) {
757 if (!objcObjectType || !objcObjectType->getInterface()) {
758 S.
Diag(loc, diag::err_objc_type_args_non_class)
771 S.
Diag(loc, diag::err_objc_type_args_non_parameterized_class)
782 if (objcObjectType->isSpecialized()) {
783 S.
Diag(loc, diag::err_objc_type_args_specialized_class)
795 unsigned numTypeParams = typeParams->
size();
796 bool anyPackExpansions =
false;
797 for (
unsigned i = 0, n = typeArgs.size(); i != n; ++i) {
805 bool diagnosed =
false;
808 rangeToRemove = attr.getLocalSourceRange();
809 if (attr.getTypePtr()->getImmediateNullability()) {
810 typeArg = attr.
getTypePtr()->getModifiedType();
811 S.
Diag(attr.getLocStart(),
812 diag::err_objc_type_arg_explicit_nullability)
819 S.
Diag(qual.getLocStart(), diag::err_objc_type_arg_qualified)
828 finalTypeArgs.push_back(typeArg);
831 anyPackExpansions =
true;
835 if (!anyPackExpansions) {
836 if (i < numTypeParams) {
837 typeParam = typeParams->
begin()[i];
840 S.
Diag(loc, diag::err_objc_type_args_wrong_arity)
843 << (unsigned)typeArgs.size()
861 assert(anyPackExpansions &&
"Too many arguments?");
870 if (typeArgObjC->isObjCIdType()) {
873 if (boundObjC->isObjCIdType())
882 diag::err_objc_type_arg_does_not_match_bound)
899 assert(anyPackExpansions &&
"Too many arguments?");
910 diag::err_objc_type_arg_does_not_match_bound)
928 diag::err_objc_type_arg_not_id_compatible)
939 if (!anyPackExpansions && finalTypeArgs.size() != numTypeParams) {
940 S.
Diag(loc, diag::err_objc_type_args_wrong_arity)
941 << (typeArgs.size() < typeParams->
size())
943 << (unsigned)finalTypeArgs.size()
944 << (unsigned)numTypeParams;
965 if (!Protocols.empty()) {
971 <<
SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
972 if (FailOnError) Result =
QualType();
974 if (FailOnError && Result.
isNull())
992 if (!TypeArgs.empty()) {
997 if (FailOnError && Result.
isNull())
1001 if (!Protocols.empty()) {
1006 Diag(Loc, diag::err_invalid_protocol_qualifiers)
1007 <<
SourceRange(ProtocolLAngleLoc, ProtocolRAngleLoc);
1008 if (FailOnError) Result =
QualType();
1010 if (FailOnError && Result.
isNull())
1037 auto ObjCObjectTL = ObjCObjectPointerTL.getPointeeLoc()
1047 ObjCObjectTL.setProtocolLAngleLoc(lAngleLoc);
1048 ObjCObjectTL.setProtocolRAngleLoc(rAngleLoc);
1049 for (
unsigned i = 0, n = protocols.size(); i != n; ++i)
1050 ObjCObjectTL.setProtocolLoc(i, protocolLocs[i]);
1053 return CreateParsedType(Result, ResultTInfo);
1068 QualType T = GetTypeFromParser(BaseType, &BaseTypeInfo);
1078 for (
unsigned i = 0, n = TypeArgs.size(); i != n; ++i) {
1080 QualType TypeArg = GetTypeFromParser(TypeArgs[i], &TypeArgInfo);
1082 ActualTypeArgInfos.clear();
1086 assert(TypeArgInfo &&
"No type source info?");
1087 ActualTypeArgInfos.push_back(TypeArgInfo);
1093 TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc,
1097 ProtocolLocs, ProtocolRAngleLoc,
1112 ResultTL = ObjCObjectPointerTL.getPointeeLoc();
1117 if (OTPTL.getNumProtocols() > 0) {
1118 assert(OTPTL.getNumProtocols() == Protocols.size());
1119 OTPTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1120 OTPTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1121 for (
unsigned i = 0, n = Protocols.size(); i != n; ++i)
1122 OTPTL.setProtocolLoc(i, ProtocolLocs[i]);
1126 return CreateParsedType(Result, ResultTInfo);
1132 if (ObjCObjectTL.getNumTypeArgs() > 0) {
1133 assert(ObjCObjectTL.getNumTypeArgs() == ActualTypeArgInfos.size());
1135 ObjCObjectTL.setTypeArgsRAngleLoc(TypeArgsRAngleLoc);
1136 for (
unsigned i = 0, n = ActualTypeArgInfos.size(); i != n; ++i)
1137 ObjCObjectTL.setTypeArgTInfo(i, ActualTypeArgInfos[i]);
1144 if (ObjCObjectTL.getNumProtocols() > 0) {
1145 assert(ObjCObjectTL.getNumProtocols() == Protocols.size());
1146 ObjCObjectTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
1147 ObjCObjectTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
1148 for (
unsigned i = 0, n = Protocols.size(); i != n; ++i)
1149 ObjCObjectTL.setProtocolLoc(i, ProtocolLocs[i]);
1156 ObjCObjectTL.setHasBaseTypeAsWritten(
true);
1157 if (ObjCObjectTL.getType() == T)
1158 ObjCObjectTL.getBaseLoc().initializeFullCopy(BaseTypeInfo->
getTypeLoc());
1160 ObjCObjectTL.getBaseLoc().initialize(Context, Loc);
1163 return CreateParsedType(Result, ResultTInfo);
1166 static OpenCLAccessAttr::Spelling
1169 if (AL.getKind() == ParsedAttr::AT_OpenCLAccess)
1170 return static_cast<OpenCLAccessAttr::Spelling>(AL.getSemanticSpelling());
1171 return OpenCLAccessAttr::Keyword_read_only;
1184 Sema &S = state.getSema();
1185 Declarator &declarator = state.getDeclarator();
1205 "Unknown TSS value");
1219 "Unknown TSS value");
1228 "Unknown TSS value");
1233 "Unknown TSS value");
1238 "Unknown TSS value");
1270 S.
Diag(DeclLoc, diag::ext_missing_declspec)
1280 S.
Diag(DeclLoc, diag::err_missing_type_specifier)
1288 S.
Diag(DeclLoc, diag::err_missing_actual_pipe_type)
1292 S.
Diag(DeclLoc, diag::ext_missing_type_specifier)
1312 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1331 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
1352 llvm_unreachable(
"Unable to specify long long as _Accum width");
1375 llvm_unreachable(
"Unable to specify long long as _Fract width");
1416 Result = Context.
IntTy;
1427 Result = Context.
IntTy;
1451 "Can't handle qualifiers on typedef names yet!");
1453 if (Result.isNull()) {
1463 assert(!Result.isNull() &&
"Didn't get a type for typeof?");
1464 if (!Result->isDependentType())
1472 assert(E &&
"Didn't get an expression for typeof?");
1475 if (Result.isNull()) {
1476 Result = Context.
IntTy;
1483 assert(E &&
"Didn't get an expression for decltype?");
1486 if (Result.isNull()) {
1487 Result = Context.
IntTy;
1494 assert(!Result.isNull() &&
"Didn't get a type for __underlying_type?");
1498 if (Result.isNull()) {
1499 Result = Context.
IntTy;
1523 assert(!Result.isNull() &&
"Didn't get a type for _Atomic?");
1525 if (Result.isNull()) {
1526 Result = Context.
IntTy;
1531 #define GENERIC_IMAGE_TYPE(ImgType, Id) \ 1532 case DeclSpec::TST_##ImgType##_t: \ 1533 switch (getImageAccess(DS.getAttributes())) { \ 1534 case OpenCLAccessAttr::Keyword_write_only: \ 1535 Result = Context.Id##WOTy; \ 1537 case OpenCLAccessAttr::Keyword_read_write: \ 1538 Result = Context.Id##RWTy; \ 1540 case OpenCLAccessAttr::Keyword_read_only: \ 1541 Result = Context.Id##ROTy; \ 1545 #include "clang/Basic/OpenCLImageTypes.def" 1548 Result = Context.
IntTy;
1555 declarator.setInvalidType(
true);
1561 if (DS.isTypeSpecSat() && !IsFixedPointType)
1562 S.
Diag(DS.getTypeSpecSatLoc(), diag::err_invalid_saturation_spec)
1563 << DS.getSpecifierName(DS.getTypeSpecType(),
1569 S.
Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex);
1571 }
else if (DS.isTypeAltiVecVector()) {
1573 assert(typeSize > 0 &&
"type size for vector must be greater than 0 bits");
1575 if (DS.isTypeAltiVecPixel())
1577 else if (DS.isTypeAltiVecBool())
1584 S.
Diag(DS.getTypeSpecComplexLoc(), diag::err_imaginary_not_supported);
1595 if (!DS.isTypeSpecPipe())
1599 if (
unsigned TypeQuals = DS.getTypeQualifiers()) {
1608 if (TypeQuals &&
Result->isFunctionType()) {
1612 ? diag::warn_typecheck_function_qualifiers_ignored
1613 : diag::warn_typecheck_function_qualifiers_unspecified);
1626 if (TypeQuals &&
Result->isReferenceType()) {
1628 S, DS, TypeQuals,
Result,
1630 diag::warn_typecheck_reference_qualifiers);
1637 && TypeQuals &
Result.getCVRQualifiers()) {
1639 S.
Diag(DS.getConstSpecLoc(), diag::ext_duplicate_declspec)
1644 S.
Diag(DS.getVolatileSpecLoc(), diag::ext_duplicate_declspec)
1656 declarator.setInvalidType(
true);
1661 assert(!
Result.isNull() &&
"This function should not return a null type");
1686 unsigned DiagID = 0;
1702 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
1706 DiagID = diag::err_typecheck_invalid_restrict_not_pointer;
1720 unsigned CVRAU,
const DeclSpec *DS) {
1755 return BuildQualifiedType(T, Loc, Split.
Quals);
1760 return BuildQualifiedType(T, Loc, Q, DS);
1807 diag::err_arc_indirect_no_ownership, type, isReference));
1809 S.
Diag(loc, diag::err_arc_indirect_no_ownership) << type << isReference;
1813 assert(implicitLifetime &&
"didn't infer any lifetime!");
1867 S.
Diag(Loc, diag::err_compound_qualified_function_type)
1890 Diag(Loc, diag::err_illegal_decl_pointer_to_reference)
1896 Diag(Loc, diag::err_opencl_function_pointer);
1906 if (getLangOpts().ObjCAutoRefCount)
1930 "Unresolved overloaded function type");
1958 Diag(Loc, diag::err_reference_to_void);
1966 if (getLangOpts().ObjCAutoRefCount)
2012 S.
Diag(Loc, diag::ext_vla_folded_to_constant) << SR;
2037 Expr *ArraySize,
unsigned Quals,
2054 Diag(Loc, diag::err_illegal_decl_array_of_references)
2060 Diag(Loc, diag::err_illegal_decl_array_incomplete_type) << T;
2064 if (RequireNonAbstractType(Brackets.
getBegin(), T,
2065 diag::err_array_of_abstract_type))
2072 if (!MPTy->getClass()->isDependentType())
2073 (
void)isCompleteType(Loc, T);
2078 if (RequireCompleteType(Loc, T,
2079 diag::err_illegal_decl_array_incomplete_type))
2084 Diag(Loc, diag::err_illegal_decl_array_of_functions)
2092 if (EltTy->getDecl()->hasFlexibleArrayMember())
2093 Diag(Loc, diag::ext_flexible_array_in_array) << T;
2095 Diag(Loc, diag::err_objc_array_of_interfaces) << T;
2103 ArraySize = Result.
get();
2107 if (ArraySize && !ArraySize->
isRValue()) {
2112 ArraySize = Result.
get();
2138 if (getLangOpts().CPlusPlus11 &&
2152 if (ConstVal.isSigned() && ConstVal.isNegative()) {
2157 Diag(ArraySize->
getLocStart(), diag::err_typecheck_negative_array_size)
2161 if (ConstVal == 0) {
2165 isSFINAEContext()? diag::err_typecheck_zero_array_size
2166 : diag::ext_typecheck_zero_array_size)
2171 diag::warn_typecheck_zero_static_array_size)
2178 unsigned ActiveSizeBits
2182 << ConstVal.toString(10)
2193 Diag(Loc, diag::err_opencl_vla);
2198 if (getLangOpts().CUDA) {
2200 CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget();
2201 }
else if (!getLangOpts().OpenMP ||
2202 shouldDiagnoseTargetSupportFromOpenMP()) {
2204 Diag(Loc, diag::err_vla_unsupported);
2210 if (!getLangOpts().
C99) {
2213 if (isSFINAEContext()) {
2214 Diag(Loc, diag::err_vla_in_sfinae);
2219 Diag(Loc, diag::ext_vla);
2222 getLangOpts().
CPlusPlus? diag::err_c99_array_usage_cxx
2223 : diag::ext_c99_array_usage) << ASM;
2228 Diag(Loc, diag::warn_vla_used);
2234 if (getLangOpts().
OpenCL) {
2238 Diag(Loc, diag::err_opencl_invalid_type_array) << ArrType;
2253 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << CurType;
2261 llvm::APSInt VecSize(32);
2263 Diag(AttrLoc, diag::err_attribute_argument_type)
2273 unsigned VectorSize =
static_cast<unsigned>(VecSize.getZExtValue() * 8);
2274 unsigned TypeSize =
static_cast<unsigned>(Context.
getTypeSize(CurType));
2276 if (VectorSize == 0) {
2282 if (VectorSize % TypeSize) {
2283 Diag(AttrLoc, diag::err_attribute_invalid_size)
2289 Diag(AttrLoc, diag::err_attribute_size_too_large)
2294 return Context.
getVectorType(CurType, VectorSize / TypeSize,
2313 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << T;
2318 llvm::APSInt vecSize(32);
2320 Diag(AttrLoc, diag::err_attribute_argument_type)
2328 unsigned vectorSize =
static_cast<unsigned>(vecSize.getZExtValue());
2330 if (vectorSize == 0) {
2331 Diag(AttrLoc, diag::err_attribute_zero_size)
2337 Diag(AttrLoc, diag::err_attribute_size_too_large)
2350 Diag(Loc, diag::err_func_returning_array_function)
2356 if (T->
isHalfType() && !getLangOpts().HalfArgsAndReturns) {
2357 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 <<
2365 Diag(Loc, diag::err_object_cannot_be_passed_returned_by_value)
2381 bool hasCheckedSwiftCall =
false;
2382 auto checkForSwiftCC = [&](
unsigned paramIndex) {
2384 if (hasCheckedSwiftCall)
return;
2385 hasCheckedSwiftCall =
true;
2387 S.
Diag(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall)
2391 for (
size_t paramIndex = 0, numParams = paramTypes.size();
2392 paramIndex != numParams; ++paramIndex) {
2401 checkForSwiftCC(paramIndex);
2402 if (paramIndex != 0 &&
2405 S.
Diag(getParamLoc(paramIndex),
2406 diag::err_swift_indirect_result_not_first);
2411 checkForSwiftCC(paramIndex);
2416 checkForSwiftCC(paramIndex);
2417 if (paramIndex == 0 ||
2420 S.
Diag(getParamLoc(paramIndex),
2421 diag::err_swift_error_result_not_after_swift_context);
2425 llvm_unreachable(
"bad ABI kind");
2433 bool Invalid =
false;
2435 Invalid |= CheckFunctionReturnType(T, Loc);
2437 for (
unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) {
2441 Diag(Loc, diag::err_param_with_void_type);
2443 }
else if (ParamType->
isHalfType() && !getLangOpts().HalfArgsAndReturns) {
2445 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 <<
2450 ParamTypes[Idx] = ParamType;
2455 [=](
unsigned i) {
return Loc; });
2460 checkNSReturnsRetainedReturnType(Loc, T);
2483 if (CheckDistantExceptionSpec(T)) {
2484 Diag(Loc, diag::err_distant_exception_spec);
2491 Diag(Loc, diag::err_illegal_decl_mempointer_to_reference)
2497 Diag(Loc, diag::err_illegal_decl_mempointer_to_void)
2503 Diag(Loc, diag::err_mempointer_in_nonclass_type) << Class;
2513 adjustMemberFunctionCC(T,
false, IsCtorOrDtor, Loc);
2533 Diag(Loc, diag::err_nonfunction_block_type);
2546 if (TInfo) *TInfo =
nullptr;
2551 if (
const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
2552 QT = LIT->getType();
2553 DI = LIT->getTypeSourceInfo();
2556 if (TInfo) *TInfo = DI;
2562 unsigned chunkIndex);
2569 Sema &S = state.getSema();
2570 Declarator &declarator = state.getDeclarator();
2576 unsigned outermostPointerIndex = 0;
2578 unsigned numPointers = 0;
2580 unsigned chunkIndex = i;
2582 switch (chunk.
Kind) {
2592 outermostPointerIndex = chunkIndex;
2600 if (numPointers != 1)
return;
2602 outermostPointerIndex = chunkIndex;
2603 isBlockPointer =
true;
2620 if (numPointers == 1) {
2638 }
else if (numPointers == 2) {
2651 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership)
2655 outermostPointerIndex);
2677 }
const QualKinds[5] = {
2686 unsigned NumQuals = 0;
2691 for (
auto &E : QualKinds) {
2692 if (Quals & E.Mask) {
2693 if (!QualStr.empty()) QualStr +=
' ';
2701 getSourceManager().isBeforeInTranslationUnit(QualLoc, Loc))
2710 << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3];
2716 unsigned FunctionChunkIndex) {
2726 for (
unsigned OuterChunkIndex = FunctionChunkIndex + 1,
2728 OuterChunkIndex !=
End; ++OuterChunkIndex) {
2730 switch (OuterChunk.
Kind) {
2737 diag::warn_qual_return_type,
2763 llvm_unreachable(
"unknown declarator chunk kind");
2786 Sema &SemaRef = state.getSema();
2789 ReturnTypeInfo =
nullptr;
2792 TagDecl *OwnedTagDecl =
nullptr;
2843 bool IsCXXAutoType =
2865 assert(LSI &&
"No LambdaScopeInfo on the stack!");
2877 TemplateParameterDepth, AutoParameterPosition,
2878 nullptr,
false, IsParameterPack);
2893 switch (cast<TagDecl>(SemaRef.
CurContext)->getTagKind()) {
2894 case TTK_Enum: llvm_unreachable(
"unhandled tag kind");
2896 case TTK_Union: Error = Cxx ? 3 : 4;
break;
2909 if (isa<DeducedTemplateSpecializationType>(Deduced))
2920 if (isa<DeducedTemplateSpecializationType>(Deduced) &&
2934 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
2938 if (!SemaRef.
getLangOpts().CPlusPlus14 || !IsCXXAutoType)
2942 if (isa<DeducedTemplateSpecializationType>(Deduced))
2960 if (!IsCXXAutoType && !isa<DeducedTemplateSpecializationType>(Deduced))
2974 (!SemaRef.
getLangOpts().CPlusPlus11 || !IsCXXAutoType))
2977 bool HaveTrailing =
false;
2985 if (SemaRef.
getLangOpts().CPlusPlus11 && IsCXXAutoType &&
2987 HaveTrailing =
true;
3004 assert(isa<DeducedTemplateSpecializationType>(Deduced) &&
3005 "unknown auto type");
3012 SemaRef.
Diag(AutoRange.
getBegin(), diag::err_auto_not_allowed)
3014 <<
QualType(Deduced, 0) << AutoRange;
3015 if (
auto *TD = TN.getAsTemplateDecl())
3016 SemaRef.
Diag(TD->getLocation(), diag::note_template_decl_here);
3020 }
else if (!HaveTrailing &&
3026 diag::warn_cxx98_compat_auto_type_specifier)
3035 unsigned DiagID = 0;
3041 llvm_unreachable(
"parser should not have allowed this");
3057 DiagID = diag::err_type_defined_in_alias_template;
3068 DiagID = diag::err_type_defined_in_type_specifier;
3077 DiagID = diag::err_type_defined_in_param_type;
3083 DiagID = diag::err_type_defined_in_condition;
3094 assert(!T.
isNull() &&
"This function should not return a null type");
3103 assert(FTI.
isAmbiguous &&
"no direct-initializer / function ambiguity");
3134 FTI.
NumParams ? diag::warn_parens_disambiguated_as_function_declaration
3135 : diag::warn_empty_parens_are_function_decl)
3146 if (
Comma.getFileID() != Name.getFileID() ||
3147 Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) {
3154 Result.suppressDiagnostics();
3167 S.
Diag(B, diag::note_additional_parens_for_variable_declaration)
3182 S.
Diag(DeclType.
Loc, diag::note_empty_parens_default_ctor)
3187 if (Init.empty() && S.
LangOpts.CPlusPlus11)
3190 S.
Diag(DeclType.
Loc, diag::note_empty_parens_zero_initialize)
3201 "do not have redundant top-level parentheses");
3210 bool CouldBeTemporaryObject =
3217 bool StartsWithDeclaratorId =
true;
3225 StartsWithDeclaratorId =
false;
3230 CouldBeTemporaryObject =
false;
3238 CouldBeTemporaryObject =
false;
3239 StartsWithDeclaratorId =
false;
3249 CouldBeTemporaryObject =
false;
3256 CouldBeTemporaryObject =
false;
3257 StartsWithDeclaratorId =
false;
3267 if (CouldBeTemporaryObject) {
3271 CouldBeTemporaryObject =
false;
3272 Result.suppressDiagnostics();
3277 if (!CouldBeTemporaryObject) {
3290 S.
Diag(Paren.
Loc, diag::warn_redundant_parens_around_declarator)
3296 S.
Diag(Paren.
Loc, diag::warn_parens_disambiguated_as_variable_declaration)
3299 if (!RD || !RD->hasDefinition() || RD->hasNonTrivialDestructor())
3300 S.
Diag(Paren.
Loc, diag::note_raii_guard_add_name)
3305 S.
Diag(D.
getLocStart(), diag::note_function_style_cast_add_parentheses)
3308 S.
Diag(Paren.
Loc, diag::note_remove_parens_for_variable_declaration)
3324 switch (AL.getKind()) {
3342 bool IsCXXInstanceMethod =
false;
3348 unsigned I = ChunkIndex;
3349 bool FoundNonParen =
false;
3350 while (I && !FoundNonParen) {
3353 FoundNonParen =
true;
3356 if (FoundNonParen) {
3359 IsCXXInstanceMethod =
3364 IsCXXInstanceMethod =
true;
3371 IsCXXInstanceMethod =
3379 IsCXXInstanceMethod);
3387 if (AL.getKind() == ParsedAttr::AT_OpenCLKernel) {
3409 switch (nullability) {
3411 if (!Ident__Nonnull)
3412 Ident__Nonnull = PP.getIdentifierInfo(
"_Nonnull");
3413 return Ident__Nonnull;
3416 if (!Ident__Nullable)
3417 Ident__Nullable = PP.getIdentifierInfo(
"_Nullable");
3418 return Ident__Nullable;
3421 if (!Ident__Null_unspecified)
3422 Ident__Null_unspecified = PP.getIdentifierInfo(
"_Null_unspecified");
3423 return Ident__Null_unspecified;
3425 llvm_unreachable(
"Unknown nullability kind.");
3431 Ident_NSError = PP.getIdentifierInfo(
"NSError");
3433 return Ident_NSError;
3440 if (AL.getKind() == ParsedAttr::AT_TypeNonNull ||
3441 AL.getKind() == ParsedAttr::AT_TypeNullable ||
3442 AL.getKind() == ParsedAttr::AT_TypeNullUnspecified)
3459 MaybePointerToCFRef,
3463 NSErrorPointerPointer,
3486 unsigned numNormalPointers = 0;
3490 return PointerDeclaratorKind::NonPointer;
3495 switch (chunk.
Kind) {
3497 if (numNormalPointers == 0)
3498 wrappingKind = PointerWrappingDeclaratorKind::Array;
3507 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3508 : PointerDeclaratorKind::SingleLevelPointer;
3514 if (numNormalPointers == 0)
3515 wrappingKind = PointerWrappingDeclaratorKind::Reference;
3519 ++numNormalPointers;
3520 if (numNormalPointers > 2)
3521 return PointerDeclaratorKind::MultiLevelPointer;
3527 unsigned numTypeSpecifierPointers = 0;
3531 ++numNormalPointers;
3533 if (numNormalPointers > 2)
3534 return PointerDeclaratorKind::MultiLevelPointer;
3537 ++numTypeSpecifierPointers;
3543 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3544 : PointerDeclaratorKind::SingleLevelPointer;
3549 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
3550 : PointerDeclaratorKind::SingleLevelPointer;
3555 ++numNormalPointers;
3556 ++numTypeSpecifierPointers;
3559 if (
auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) {
3561 numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3562 return PointerDeclaratorKind::NSErrorPointerPointer;
3571 if (objcClass->getInterface()->getIdentifier() == S.
getNSErrorIdent()) {
3572 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2)
3573 return PointerDeclaratorKind::NSErrorPointerPointer;
3580 if (numNormalPointers == 0)
3581 return PointerDeclaratorKind::NonPointer;
3586 bool isCFError =
false;
3597 if (
auto bridgeAttr = recordDecl->
getAttr<ObjCBridgeAttr>())
3598 bridgedType = bridgeAttr->getBridgedType();
3599 else if (
auto bridgeAttr =
3600 recordDecl->
getAttr<ObjCBridgeMutableAttr>())
3601 bridgedType = bridgeAttr->getBridgedType();
3611 if (isCFError && numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
3612 return PointerDeclaratorKind::CFErrorRefPointer;
3620 switch (numNormalPointers) {
3622 return PointerDeclaratorKind::NonPointer;
3625 return PointerDeclaratorKind::SingleLevelPointer;
3628 return PointerDeclaratorKind::MaybePointerToCFRef;
3631 return PointerDeclaratorKind::MultiLevelPointer;
3640 if (ctx->isFunctionOrMethod())
3643 if (ctx->isFileContext())
3654 bool invalid =
false;
3656 if (invalid || !sloc.
isFile())
3682 if (!FixItLoc.
isValid() || FixItLoc == PointerLoc)
3691 InsertionTextBuf +=
" ";
3692 StringRef InsertionText = InsertionTextBuf.str();
3695 InsertionText = InsertionText.drop_back();
3696 }
else if (NextChar[-1] ==
'[') {
3697 if (NextChar[0] ==
']')
3698 InsertionText = InsertionText.drop_back().drop_front();
3700 InsertionText = InsertionText.drop_front();
3703 InsertionText = InsertionText.drop_back().drop_front();
3715 if (PointerKind == SimplePointerKind::Array) {
3716 S.
Diag(PointerLoc, diag::warn_nullability_missing_array);
3718 S.
Diag(PointerLoc, diag::warn_nullability_missing)
3719 <<
static_cast<unsigned>(PointerKind);
3722 auto FixItLoc = PointerEndLoc.
isValid() ? PointerEndLoc : PointerLoc;
3723 if (FixItLoc.isMacroID())
3727 auto Diag = S.
Diag(FixItLoc, diag::note_nullability_fix_it);
3729 Diag << static_cast<unsigned>(PointerKind);
3758 if (pointerKind == SimplePointerKind::Array)
3759 diagKind = diag::warn_nullability_missing_array;
3761 diagKind = diag::warn_nullability_missing;
3767 fileNullability.
PointerKind =
static_cast<unsigned>(pointerKind);
3814 unsigned i = endIndex;
3844 Sema &S = state.getSema();
3854 bool IsTypedefName =
3870 bool IsClassTemplateDeduction = isa<DeducedTemplateSpecializationType>(DT);
3873 unsigned Index = E - I - 1;
3875 unsigned DiagId = IsClassTemplateDeduction
3876 ? diag::err_deduced_class_template_compound_type
3877 : diag::err_decltype_auto_compound_type;
3878 unsigned DiagKind = 0;
3879 switch (DeclChunk.
Kind) {
3882 if (IsClassTemplateDeduction) {
3888 if (IsClassTemplateDeduction) {
3896 DiagId = diag::err_decltype_auto_function_declarator_not_declaration;
3914 S.
Diag(DeclChunk.
Loc, DiagId) << DiagKind;
3923 bool inferNullabilityCS =
false;
3924 bool inferNullabilityInnerOnly =
false;
3925 bool inferNullabilityInnerOnlyComplete =
false;
3928 bool inAssumeNonNullRegion =
false;
3930 if (assumeNonNullLoc.
isValid()) {
3931 inAssumeNonNullRegion =
true;
3945 } complainAboutMissingNullability = CAMN_No;
3946 unsigned NumPointersRemaining = 0;
3949 if (IsTypedefName) {
3953 complainAboutMissingNullability = CAMN_InnerPointers;
3958 ++NumPointersRemaining;
3963 switch (chunk.
Kind) {
3971 ++NumPointersRemaining;
3979 ++NumPointersRemaining;
3985 switch (
auto context = state.getDeclarator().getContext()) {
3991 isFunctionOrMethod =
true;
3996 complainAboutMissingNullability = CAMN_No;
4001 if (state.getDeclarator().isObjCWeakProperty() && inAssumeNonNullRegion) {
4010 complainAboutMissingNullability = CAMN_Yes;
4015 case PointerDeclaratorKind::NonPointer:
4016 case PointerDeclaratorKind::MultiLevelPointer:
4020 case PointerDeclaratorKind::SingleLevelPointer:
4022 if (inAssumeNonNullRegion) {
4023 complainAboutInferringWithinChunk = wrappingKind;
4025 inferNullabilityCS =
4031 case PointerDeclaratorKind::CFErrorRefPointer:
4032 case PointerDeclaratorKind::NSErrorPointerPointer:
4035 if (isFunctionOrMethod && inAssumeNonNullRegion)
4039 case PointerDeclaratorKind::MaybePointerToCFRef:
4040 if (isFunctionOrMethod) {
4044 auto hasCFReturnsAttr =
4046 return AttrList.hasAttribute(ParsedAttr::AT_CFReturnsRetained) ||
4047 AttrList.hasAttribute(ParsedAttr::AT_CFReturnsNotRetained);
4051 hasCFReturnsAttr(InnermostChunk->getAttrs()) ||
4054 inferNullabilityInnerOnly =
true;
4064 complainAboutMissingNullability = CAMN_Yes;
4090 auto isVaList = [&S](
QualType T) ->
bool {
4096 if (typedefTy->getDecl() == vaListTypedef)
4098 if (
auto *name = typedefTy->getDecl()->getIdentifier())
4099 if (name->isStr(
"va_list"))
4101 typedefTy = typedefTy->desugar()->getAs<
TypedefType>();
4102 }
while (typedefTy);
4108 auto inferPointerNullability =
4113 if (NumPointersRemaining > 0)
4114 --NumPointersRemaining;
4121 if (inferNullability && !inferNullabilityInnerOnlyComplete) {
4126 state.getDeclarator().getAttributePool().create(
4131 attrs.addAtStart(nullabilityAttr);
4133 if (inferNullabilityCS) {
4134 state.getDeclarator().getMutableDeclSpec().getObjCQualifiers()
4138 if (pointerLoc.isValid() &&
4139 complainAboutInferringWithinChunk !=
4142 S.
Diag(pointerLoc, diag::warn_nullability_inferred_on_nested_type);
4143 Diag << static_cast<int>(complainAboutInferringWithinChunk);
4147 if (inferNullabilityInnerOnly)
4148 inferNullabilityInnerOnlyComplete =
true;
4149 return nullabilityAttr;
4154 switch (complainAboutMissingNullability) {
4158 case CAMN_InnerPointers:
4159 if (NumPointersRemaining == 0)
4176 if (NumPointersRemaining > 0)
4177 --NumPointersRemaining;
4181 pointerKind = SimplePointerKind::BlockPointer;
4183 pointerKind = SimplePointerKind::MemberPointer;
4185 if (
auto *attr = inferPointerNullability(
4191 attr->setUsedAsTypeAttr();
4196 if (complainAboutMissingNullability == CAMN_Yes &&
4209 unsigned chunkIndex = e - i - 1;
4210 state.setCurrentChunkIndex(chunkIndex);
4213 switch (DeclType.
Kind) {
4221 if (!LangOpts.Blocks)
4222 S.
Diag(DeclType.
Loc, diag::err_blocks_disable) << LangOpts.OpenCL;
4225 inferPointerNullability(SimplePointerKind::BlockPointer, DeclType.
Loc,
4232 if (LangOpts.OpenCL)
4247 inferPointerNullability(SimplePointerKind::Pointer, DeclType.
Loc,
4260 if (LangOpts.OpenCL) {
4261 if (T->isImageType() || T->isSamplerT() || T->isPipeType() ||
4262 T->isBlockPointerType()) {
4307 S.
Diag(DeclType.
Loc, diag::err_array_star_outside_prototype);
4318 S.
Diag(DeclType.
Loc, diag::err_array_static_outside_prototype) <<
4330 S.
Diag(DeclType.
Loc, diag::err_array_static_not_outermost) <<
4345 S.
Diag(DeclType.
Loc, diag::err_illegal_decl_array_of_auto)
4353 if (complainAboutMissingNullability == CAMN_Yes &&
4382 ? diag::err_auto_missing_trailing_return
4383 : diag::err_deduced_return_type);
4388 if (isa<ParenType>(T)) {
4390 diag::err_trailing_return_in_parens)
4397 diag::err_deduction_guide_with_complex_decl)
4402 (T.hasQualifiers() || !isa<AutoType>(T) ||
4403 cast<AutoType>(T)->getKeyword() !=
4406 diag::err_trailing_return_without_auto)
4421 if (!D.
isInvalidType() && (T->isArrayType() || T->isFunctionType()) &&
4424 unsigned diagID = diag::err_func_returning_array_function;
4427 if (chunkIndex == 0 &&
4429 diagID = diag::err_block_returning_array_function;
4430 S.
Diag(DeclType.
Loc, diagID) << T->isFunctionType() << T;
4437 if (T->isHalfType()) {
4446 diag::err_parameters_retval_cannot_have_fp16_type) << 1;
4451 if (LangOpts.OpenCL) {
4454 if (T->isBlockPointerType() || T->isImageType() || T->isSamplerT() ||
4466 LangOpts.OpenCLVersion >= 120) ||
4475 if (T->isObjCObjectType()) {
4484 S.
Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value)
4502 if ((T.getCVRQualifiers() || T->isAtomicType()) &&
4504 (T->isDependentType() || T->isRecordType()))) {
4505 if (T->isVoidType() && !S.
getLangOpts().CPlusPlus &&
4510 S.
Diag(DeclType.
Loc, diag::err_func_returning_qualified_void) << T;
4518 if (T.getQualifiers().hasObjCLifetime()) {
4523 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
4524 AttrLoc = AL.getLoc();
4531 if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
4532 AttrLoc = AL.getLoc();
4546 S.
Diag(AttrLoc, diag::warn_arc_lifetime_result_type)
4547 << T.getQualifiers().getObjCLifetime();
4563 diag::err_exception_spec_in_typedef)
4576 && !LangOpts.OpenCL) {
4591 diag::err_ident_list_in_fn_declaration);
4614 bool HasAnyInterestingExtParameterInfos =
false;
4616 for (
unsigned i = 0, e = FTI.
NumParams; i != e; ++i) {
4619 assert(!ParamTy.isNull() &&
"Couldn't parse type?");
4624 if (ParamTy->isVoidType()) {
4629 S.
Diag(DeclType.
Loc, diag::err_void_only_param);
4630 ParamTy = Context.
IntTy;
4635 ParamTy = Context.
IntTy;
4639 if (ParamTy.hasQualifiers())
4640 S.
Diag(DeclType.
Loc, diag::err_void_param_qualified);
4645 }
else if (ParamTy->isHalfType()) {
4651 diag::err_opencl_half_param) << ParamTy;
4657 diag::err_parameters_retval_cannot_have_fp16_type) << 0;
4661 if (ParamTy->isPromotableIntegerType()) {
4665 if (BTy->getKind() == BuiltinType::Float) {
4672 if (LangOpts.ObjCAutoRefCount && Param->
hasAttr<NSConsumedAttr>()) {
4673 ExtParameterInfos[i] = ExtParameterInfos[i].withIsConsumed(
true);
4674 HasAnyInterestingExtParameterInfos =
true;
4678 ExtParameterInfos[i] =
4679 ExtParameterInfos[i].withABI(attr->getABI());
4680 HasAnyInterestingExtParameterInfos =
true;
4683 if (Param->
hasAttr<PassObjectSizeAttr>()) {
4684 ExtParameterInfos[i] = ExtParameterInfos[i].withHasPassObjectSize();
4685 HasAnyInterestingExtParameterInfos =
true;
4688 if (Param->
hasAttr<NoEscapeAttr>()) {
4689 ExtParameterInfos[i] = ExtParameterInfos[i].withIsNoEscape(
true);
4690 HasAnyInterestingExtParameterInfos =
true;
4693 ParamTys.push_back(ParamTy);
4696 if (HasAnyInterestingExtParameterInfos) {
4705 Expr *NoexceptExpr =
nullptr;
4711 DynamicExceptions.reserve(N);
4712 DynamicExceptionRanges.reserve(N);
4713 for (
unsigned I = 0; I != N; ++I) {
4724 DynamicExceptionRanges,
4739 inferPointerNullability(SimplePointerKind::MemberPointer, DeclType.
Loc,
4759 llvm_unreachable(
"Nested-name-specifier must name a type");
4769 if (NNSPrefix && isa<TemplateSpecializationType>(NNS->
getAsType()))
4775 diag::err_illegal_decl_mempointer_in_nonclass)
4819 bool IsBlock =
false;
4821 switch (DeclType.Kind) {
4828 S.
Diag(DeclType.Loc, diag::warn_strict_prototypes)
4840 assert(!T.
isNull() &&
"T must not be null after this point");
4844 assert(FnTy &&
"Why oh why is there not a FunctionProtoType here?");
4854 enum { NonMember, Member, DeductionGuide }
Kind = NonMember;
4856 Kind = DeductionGuide;
4884 if (IsQualifiedFunction &&
4905 if (!RemovalLocs.empty()) {
4906 llvm::sort(RemovalLocs.begin(), RemovalLocs.end(),
4908 RemovalRange =
SourceRange(RemovalLocs.front(), RemovalLocs.back());
4909 Loc = RemovalLocs.front();
4913 S.
Diag(Loc, diag::err_invalid_qualified_function_type)
4938 state.diagnoseIgnoredTypeAttrs(T);
4968 diag::err_function_parameter_pack_without_parameter_packs)
4988 LangOpts.CPlusPlus11
4989 ? diag::warn_cxx98_compat_variadic_templates
4990 : diag::ext_variadic_templates);
5021 diag::err_ellipsis_in_declarator_not_parameter);
5027 assert(!T.
isNull() &&
"T must not be null at the end of this function");
5043 TypeProcessingState
state(*
this, D);
5066 unsigned chunkIndex) {
5067 Sema &S = state.getSema();
5075 const char *attrStr =
nullptr;
5076 switch (ownership) {
5104 Sema &S = state.getSema();
5108 bool hasIndirection =
false;
5111 switch (chunk.
Kind) {
5120 hasIndirection =
true;
5153 TypeProcessingState
state(*
this, D);
5158 if (getLangOpts().ObjC1) {
5171 return ParsedAttr::AT_AddressSpace;
5173 return ParsedAttr::AT_Regparm;
5175 return ParsedAttr::AT_VectorSize;
5177 return ParsedAttr::AT_NeonVectorType;
5179 return ParsedAttr::AT_NeonPolyVectorType;
5181 return ParsedAttr::AT_ObjCGC;
5184 return ParsedAttr::AT_ObjCOwnership;
5186 return ParsedAttr::AT_NoReturn;
5188 return ParsedAttr::AT_AnyX86NoCfCheck;
5190 return ParsedAttr::AT_CDecl;
5192 return ParsedAttr::AT_FastCall;
5194 return ParsedAttr::AT_StdCall;
5196 return ParsedAttr::AT_ThisCall;
5198 return ParsedAttr::AT_RegCall;
5200 return ParsedAttr::AT_Pascal;
5202 return ParsedAttr::AT_SwiftCall;
5204 return ParsedAttr::AT_VectorCall;
5207 return ParsedAttr::AT_Pcs;
5209 return ParsedAttr::AT_IntelOclBicc;
5211 return ParsedAttr::AT_MSABI;
5213 return ParsedAttr::AT_SysVABI;
5215 return ParsedAttr::AT_PreserveMost;
5217 return ParsedAttr::AT_PreserveAll;
5219 return ParsedAttr::AT_Ptr32;
5221 return ParsedAttr::AT_Ptr64;
5223 return ParsedAttr::AT_SPtr;
5225 return ParsedAttr::AT_UPtr;
5227 return ParsedAttr::AT_TypeNonNull;
5229 return ParsedAttr::AT_TypeNullable;
5231 return ParsedAttr::AT_TypeNullUnspecified;
5233 return ParsedAttr::AT_ObjCKindOf;
5235 return ParsedAttr::AT_NSReturnsRetained;
5237 return ParsedAttr::AT_LifetimeBound;
5239 llvm_unreachable(
"unexpected attribute kind!");
5245 assert(attr.
isArgExpr(0) &&
"mismatched attribute operand kind");
5249 "unexpected attribute operand kind");
5265 assert((!Attrs.
empty() || !DeclAttrs.
empty()) &&
5266 "no type attributes in the expected location!");
5271 if (AL.getKind() == parsedKind)
5275 if (AL.isCXX11Attribute() || AL.getKind() == parsedKind)
5277 llvm_unreachable(
"no matching type attribute in expected location!");
5281 class TypeSpecLocFiller :
public TypeLocVisitor<TypeSpecLocFiller> {
5287 : Context(Context), DS(DS) {}
5401 void VisitDependentTemplateSpecializationTypeLoc(
5440 void VisitTypeLoc(
TypeLoc TL) {
5446 class DeclaratorLocFiller :
public TypeLocVisitor<DeclaratorLocFiller> {
5452 : Context(Context), Chunk(Chunk) {}
5455 llvm_unreachable(
"qualified type locs not expected here!");
5458 llvm_unreachable(
"decayed type locs not expected here!");
5491 assert(isa<DependentNameType>(ClsTy) &&
"Unexpected TypeLoc");
5502 if (isa<ElaboratedType>(ClsTy)) {
5517 llvm_unreachable(
"Nested-name-specifier must name a type");
5549 for (
unsigned i = 0, e = TL.
getNumParams(), tpi = 0; i != e; ++i) {
5565 void VisitTypeLoc(
TypeLoc TL) {
5566 llvm_unreachable(
"unsupported TypeLoc kind in declarator!");
5573 switch (Chunk.
Kind) {
5578 llvm_unreachable(
"cannot be _Atomic qualified");
5599 if (AL.getKind() == ParsedAttr::AT_AddressSpace) {
5608 "no address_space attribute found at the expected location!");
5626 if (isa<PackExpansionType>(T)) {
5656 DeclaratorLocFiller(Context, D.
getTypeObject(i)).Visit(CurrTL);
5662 if (ReturnTypeInfo) {
5667 TypeSpecLocFiller(Context, D.
getDeclSpec()).Visit(CurrTL);
5682 "LocInfoType's TypeClass conflicts with an existing Type class");
5688 llvm_unreachable(
"LocInfoType leaked into the type system; an opaque TypeTy*" 5689 " was used directly instead of getting the QualType through" 5690 " GetTypeFromParser");
5697 "Type name should have no identifier!");
5714 if (getLangOpts().CPlusPlus) {
5716 CheckExtraCXXDefaultArguments(D);
5719 return CreateParsedType(T, TInfo);
5725 return CreateParsedType(T, TInfo);
5740 llvm::APSInt addrSpace(32);
5742 Diag(AttrLoc, diag::err_attribute_argument_type)
5749 if (addrSpace.isSigned()) {
5750 if (addrSpace.isNegative()) {
5751 Diag(AttrLoc, diag::err_attribute_address_space_negative)
5755 addrSpace.setIsSigned(
false);
5758 llvm::APSInt
max(addrSpace.getBitWidth());
5761 if (addrSpace > max) {
5762 Diag(AttrLoc, diag::err_attribute_address_space_too_high)
5776 Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
5781 diag::warn_attribute_address_multiple_identical_qualifiers);
5793 Diag(AttrLoc, diag::err_attribute_address_multiple_qualifiers);
5808 S.
Diag(Attr.
getLoc(), diag::err_attribute_address_function_type);
5814 if (Attr.
getKind() == ParsedAttr::AT_AddressSpace) {
5818 S.
Diag(Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
5837 ASArgExpr =
static_cast<Expr *
>(AddrSpace.
get());
5853 case ParsedAttr::AT_OpenCLGlobalAddressSpace:
5855 case ParsedAttr::AT_OpenCLLocalAddressSpace:
5857 case ParsedAttr::AT_OpenCLConstantAddressSpace:
5859 case ParsedAttr::AT_OpenCLGenericAddressSpace:
5861 case ParsedAttr::AT_OpenCLPrivateAddressSpace:
5864 llvm_unreachable(
"Invalid address space");
5873 S.
Diag(Attr.
getLoc(), diag::err_attribute_address_multiple_qualifiers);
5879 diag::warn_attribute_address_multiple_identical_qualifiers);
5895 if (
const AttributedType *attr = dyn_cast<AttributedType>(type)) {
5899 type = attr->getModifiedType();
5902 }
else if (
const ParenType *paren = dyn_cast<ParenType>(type)) {
5903 type = paren->getInnerType();
5922 bool NonObjCPointer =
false;
5932 NonObjCPointer =
true;
5939 if (state.isProcessingDeclSpec()) {
5947 Sema &S = state.getSema();
5954 S.
Diag(AttrLoc, diag::err_attribute_argument_type)
5962 if (II->
isStr(
"none"))
5964 else if (II->
isStr(
"strong"))
5966 else if (II->
isStr(
"weak"))
5968 else if (II->
isStr(
"autoreleasing"))
5971 S.
Diag(AttrLoc, diag::warn_attribute_type_not_supported)
5992 S.
Diag(AttrLoc, diag::err_attr_objc_ownership_redundant)
5999 if (previousLifetime != lifetime) {
6002 const Type *prevTy =
nullptr;
6003 while (!prevTy || prevTy != underlyingType.
Ty) {
6004 prevTy = underlyingType.
Ty;
6013 if (NonObjCPointer) {
6023 S.
Diag(AttrLoc, diag::warn_type_attribute_wrong_type) << name
6047 if (!NonObjCPointer)
6062 diagnostic,
type, 0));
6064 S.
Diag(loc, diagnostic);
6073 unsigned diagnostic =
6074 (S.
getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled
6075 : diag::err_arc_weak_no_runtime);
6078 diagnoseOrDelay(S, AttrLoc, diagnostic, type);
6090 if (Class->isArcWeakrefUnavailable()) {
6091 S.
Diag(AttrLoc, diag::err_arc_unsupported_weak_class);
6092 S.
Diag(ObjT->getInterfaceDecl()->getLocation(),
6093 diag::note_class_declared);
6108 Sema &S = state.getSema();
6117 S.
Diag(attr.
getLoc(), diag::err_attribute_multiple_objc_gc);
6124 S.
Diag(attr.
getLoc(), diag::err_attribute_argument_type)
6131 S.
Diag(attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
6138 if (II->
isStr(
"weak"))
6140 else if (II->
isStr(
"strong"))
6143 S.
Diag(attr.
getLoc(), diag::warn_attribute_type_not_supported)
6171 struct FunctionTypeUnwrapper {
6186 FunctionTypeUnwrapper(
Sema &S,
QualType T) : Original(T) {
6189 if (isa<FunctionType>(Ty)) {
6190 Fn = cast<FunctionType>(Ty);
6192 }
else if (isa<ParenType>(Ty)) {
6193 T = cast<ParenType>(Ty)->getInnerType();
6194 Stack.push_back(Parens);
6195 }
else if (isa<PointerType>(Ty)) {
6196 T = cast<PointerType>(Ty)->getPointeeType();
6198 }
else if (isa<BlockPointerType>(Ty)) {
6199 T = cast<BlockPointerType>(Ty)->getPointeeType();
6200 Stack.push_back(BlockPointer);
6201 }
else if (isa<MemberPointerType>(Ty)) {
6202 T = cast<MemberPointerType>(Ty)->getPointeeType();
6203 Stack.push_back(MemberPointer);
6204 }
else if (isa<ReferenceType>(Ty)) {
6205 T = cast<ReferenceType>(Ty)->getPointeeType();
6206 Stack.push_back(Reference);
6207 }
else if (isa<AttributedType>(Ty)) {
6208 T = cast<AttributedType>(Ty)->getEquivalentType();
6209 Stack.push_back(Attributed);
6223 bool isFunctionType()
const {
return (Fn !=
nullptr); }
6228 if (New ==
get())
return Original;
6231 return wrap(S.
Context, Original, 0);
6236 if (I == Stack.size())
6245 return wrap(C, SplitOld.
Ty, I);
6250 if (I == Stack.size())
return QualType(Fn, 0);
6252 switch (static_cast<WrapKind>(Stack[I++])) {
6259 return wrap(C, cast<AttributedType>(Old)->getEquivalentType(), I);
6262 QualType New = wrap(C, cast<ParenType>(Old)->getInnerType(), I);
6267 QualType New = wrap(C, cast<PointerType>(Old)->getPointeeType(), I);
6271 case BlockPointer: {
6272 QualType New = wrap(C, cast<BlockPointerType>(Old)->getPointeeType(),I);
6276 case MemberPointer: {
6285 if (isa<LValueReferenceType>(OldRef))
6292 llvm_unreachable(
"unknown wrapping kind");
6299 Sema &S = State.getSema();
6310 S.
Diag(Attr.
getLoc(), diag::warn_duplicate_attribute_exact)
6318 Kind == ParsedAttr::AT_Ptr64) ||
6320 Kind == ParsedAttr::AT_Ptr32)) {
6321 S.
Diag(Attr.
getLoc(), diag::err_attributes_are_not_compatible)
6322 <<
"'__ptr32'" <<
"'__ptr64'";
6325 Kind == ParsedAttr::AT_UPtr) ||
6327 Kind == ParsedAttr::AT_SPtr)) {
6328 S.
Diag(Attr.
getLoc(), diag::err_attributes_are_not_compatible)
6329 <<
"'__sptr'" <<
"'__uptr'";
6339 if (!isa<PointerType>(Desugared)) {
6341 S.
Diag(Attr.
getLoc(), diag::err_attribute_no_member_pointers)
6344 S.
Diag(Attr.
getLoc(), diag::err_attribute_pointers_only)
6351 default: llvm_unreachable(
"Unknown attribute kind");
6352 case ParsedAttr::AT_Ptr32:
6355 case ParsedAttr::AT_Ptr64:
6358 case ParsedAttr::AT_SPtr:
6361 case ParsedAttr::AT_UPtr:
6373 bool isContextSensitive,
6374 bool allowOnArrayType) {
6379 while (
auto attributed = dyn_cast<AttributedType>(desugared.
getTypePtr())) {
6381 if (
auto existingNullability = attributed->getImmediateNullability()) {
6383 if (nullability == *existingNullability) {
6384 Diag(nullabilityLoc, diag::warn_nullability_duplicate)
6392 Diag(nullabilityLoc, diag::err_nullability_conflicting)
6398 desugared = attributed->getModifiedType();
6405 if (
auto existingNullability = desugared->
getNullability(Context)) {
6406 if (nullability != *existingNullability) {
6407 Diag(nullabilityLoc, diag::err_nullability_conflicting)
6415 if (
auto typedefNullability
6417 if (*typedefNullability == *existingNullability) {
6430 !(allowOnArrayType && desugared->
isArrayType())) {
6431 Diag(nullabilityLoc, diag::err_nullability_nonpointer)
6438 if (isContextSensitive) {
6440 const Type *pointeeType;
6449 Diag(nullabilityLoc, diag::err_nullability_cs_multilevel)
6452 Diag(nullabilityLoc, diag::note_nullability_type_specifier)
6468 if (isa<ObjCTypeParamType>(type)) {
6483 Diag(loc, diag::err_objc_kindof_nonobject)
6492 objType->getBaseType(), objType->getTypeArgsAsWritten(),
6493 objType->getProtocols(),
6494 objType->isObjCUnqualifiedId() ?
false :
true);
6516 case ParsedAttr::AT_TypeNonNull:
6519 case ParsedAttr::AT_TypeNullable:
6522 case ParsedAttr::AT_TypeNullUnspecified:
6526 llvm_unreachable(
"not a nullability attribute kind");
6538 Declarator &declarator = state.getDeclarator();
6541 auto moveToChunk = [&](
DeclaratorChunk &chunk,
bool inFunction) ->
bool {
6554 PK_MemberFunctionPointer,
6559 : inFunction? PK_MemberFunctionPointer : PK_MemberPointer;
6561 auto diag = state.getSema().Diag(attr.
getLoc(),
6562 diag::warn_nullability_declspec)
6566 << static_cast<unsigned>(pointerKind);
6572 state.getSema().getPreprocessor()
6573 .getLocForEndOfToken(chunk.
Loc),
6584 for (
unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
6586 switch (chunk.
Kind) {
6590 return moveToChunk(chunk,
false);
6602 return moveToChunk(*dest,
true);
6621 llvm_unreachable(
"not a calling convention attribute");
6622 case ParsedAttr::AT_CDecl:
6624 case ParsedAttr::AT_FastCall:
6626 case ParsedAttr::AT_StdCall:
6628 case ParsedAttr::AT_ThisCall:
6630 case ParsedAttr::AT_RegCall:
6632 case ParsedAttr::AT_Pascal:
6634 case ParsedAttr::AT_SwiftCall:
6636 case ParsedAttr::AT_VectorCall:
6638 case ParsedAttr::AT_Pcs: {
6644 Str = cast<StringLiteral>(Attr.
getArgAsExpr(0))->getString();
6647 return llvm::StringSwitch<AttributedType::Kind>(Str)
6651 case ParsedAttr::AT_IntelOclBicc:
6653 case ParsedAttr::AT_MSABI:
6655 case ParsedAttr::AT_SysVABI:
6657 case ParsedAttr::AT_PreserveMost:
6659 case ParsedAttr::AT_PreserveAll:
6662 llvm_unreachable(
"unexpected attribute kind!");
6669 Sema &S = state.getSema();
6671 FunctionTypeUnwrapper unwrapped(S, type);
6673 if (attr.
getKind() == ParsedAttr::AT_NoReturn) {
6678 if (!unwrapped.isFunctionType())
6689 if (attr.
getKind() == ParsedAttr::AT_NSReturnsRetained) {
6693 if (!unwrapped.isFunctionType())
6698 unwrapped.get()->getReturnType()))
6703 if (state.getSema().getLangOpts().ObjCAutoRefCount) {
6705 = unwrapped.get()->getExtInfo().withProducesResult(
true);
6713 if (attr.
getKind() == ParsedAttr::AT_AnyX86NoCallerSavedRegisters) {
6718 if (!unwrapped.isFunctionType())
6722 unwrapped.get()->getExtInfo().withNoCallerSavedRegs(
true);
6727 if (attr.
getKind() == ParsedAttr::AT_AnyX86NoCfCheck) {
6729 S.
Diag(attr.
getLoc(), diag::warn_nocf_check_attribute_ignored);
6739 if (!unwrapped.isFunctionType())
6743 unwrapped.get()->getExtInfo().withNoCfCheck(
true);
6748 if (attr.
getKind() == ParsedAttr::AT_Regparm) {
6754 if (!unwrapped.isFunctionType())
6761 S.
Diag(attr.
getLoc(), diag::err_attributes_are_not_compatible)
6769 unwrapped.get()->getExtInfo().withRegParm(value);
6775 if (!unwrapped.isFunctionType())
return false;
6791 S.
Diag(attr.
getLoc(), diag::err_attributes_are_not_compatible)
6809 unsigned DiagID = diag::err_cconv_varargs;
6813 bool IsInvalid =
true;
6815 DiagID = diag::warn_cconv_varargs;
6827 S.
Diag(attr.
getLoc(), diag::err_attributes_are_not_compatible)
6840 auto EI = unwrapped.get()->getExtInfo().withCallingConv(CC);
6851 if (AT->isCallingConv())
6853 R = AT->getModifiedType().IgnoreParens();
6860 FunctionTypeUnwrapper Unwrapped(*
this, T);
6862 bool IsVariadic = (isa<FunctionProtoType>(FT) &&
6863 cast<FunctionProtoType>(FT)->isVariadic());
6876 Diag(Loc, diag::warn_cconv_structors)
6886 if (CurCC != DefaultCC || DefaultCC == ToCC)
6889 if (hasExplicitCallingConv(T))
6894 QualType Wrapped = Unwrapped.wrap(*
this, FT);
6909 S.
Diag(Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
6928 SizeExpr = Size.
get();
6946 S.
Diag(Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
6965 sizeExpr = Size.
get();
6986 bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 ||
6987 Triple.getArch() == llvm::Triple::aarch64_be;
6989 if (IsPolyUnsigned) {
6991 return BTy->
getKind() == BuiltinType::UChar ||
6992 BTy->
getKind() == BuiltinType::UShort ||
6993 BTy->
getKind() == BuiltinType::ULong ||
6994 BTy->
getKind() == BuiltinType::ULongLong;
6997 return BTy->
getKind() == BuiltinType::SChar ||
6998 BTy->
getKind() == BuiltinType::Short;
7004 bool Is64Bit = Triple.getArch() == llvm::Triple::aarch64 ||
7005 Triple.getArch() == llvm::Triple::aarch64_be;
7007 if (Is64Bit && BTy->
getKind() == BuiltinType::Double)
7010 return BTy->
getKind() == BuiltinType::SChar ||
7011 BTy->
getKind() == BuiltinType::UChar ||
7012 BTy->
getKind() == BuiltinType::Short ||
7013 BTy->
getKind() == BuiltinType::UShort ||
7014 BTy->
getKind() == BuiltinType::Int ||
7015 BTy->
getKind() == BuiltinType::UInt ||
7016 BTy->
getKind() == BuiltinType::Long ||
7017 BTy->
getKind() == BuiltinType::ULong ||
7018 BTy->
getKind() == BuiltinType::LongLong ||
7019 BTy->
getKind() == BuiltinType::ULongLong ||
7020 BTy->
getKind() == BuiltinType::Float ||
7021 BTy->
getKind() == BuiltinType::Half;
7041 S.
Diag(Attr.
getLoc(), diag::err_attribute_wrong_number_arguments)
7048 llvm::APSInt numEltsInt(32);
7051 S.
Diag(Attr.
getLoc(), diag::err_attribute_argument_type)
7059 S.
Diag(Attr.
getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
7066 unsigned numElts =
static_cast<unsigned>(numEltsInt.getZExtValue());
7067 unsigned vecSize = typeSize * numElts;
7068 if (vecSize != 64 && vecSize != 128) {
7069 S.
Diag(Attr.
getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType;
7082 S.
Diag(Attr.
getLoc(), diag::err_opencl_invalid_access_qualifier);
7088 QualType PointeeTy = TypedefTy->desugar();
7089 S.
Diag(Attr.
getLoc(), diag::err_opencl_multiple_access_qualifiers);
7091 std::string PrevAccessQual;
7093 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 7094 case BuiltinType::Id: \ 7095 PrevAccessQual = #Access; \ 7097 #include "clang/Basic/OpenCLImageTypes.def" 7099 assert(0 &&
"Unable to find corresponding image type.");
7102 S.
Diag(TypedefTy->getDecl()->getLocStart(),
7103 diag::note_opencl_typedef_access_qualifier) << PrevAccessQual;
7135 auto ChunkIndex = State.getCurrentChunkIndex();
7140 bool IsFuncReturnType =
7148 IsFuncReturnType || IsFuncType ||
7168 if (State.getSema().getLangOpts().OpenCLVersion <= 120 &&
7169 !State.getSema().getLangOpts().OpenCLCPlusPlus) {
7196 T = State.getSema().Context.getAddrSpaceQualType(T, ImpAddr);
7226 if (attr.isInvalid())
7229 if (attr.isCXX11Attribute()) {
7234 if (attr.getScopeName() && attr.getScopeName()->isStr(
"gnu")) {
7235 bool IsTypeAttr = attr.isTypeAttr();
7237 state.getSema().Diag(attr.getLoc(),
7239 ? diag::warn_gcc_ignores_type_attr
7240 : diag::warn_cxx11_gnu_attribute_on_type)
7254 switch (attr.getKind()) {
7258 state.getSema().Diag(attr.getLoc(), diag::err_attribute_not_type_attr)
7260 attr.setUsedAsTypeAttr();
7266 state.getSema().Diag(attr.getLoc(),
7267 diag::warn_unknown_attribute_ignored)
7274 case ParsedAttr::AT_MayAlias:
7277 attr.setUsedAsTypeAttr();
7279 case ParsedAttr::AT_OpenCLPrivateAddressSpace:
7280 case ParsedAttr::AT_OpenCLGlobalAddressSpace:
7281 case ParsedAttr::AT_OpenCLLocalAddressSpace:
7282 case ParsedAttr::AT_OpenCLConstantAddressSpace:
7283 case ParsedAttr::AT_OpenCLGenericAddressSpace:
7284 case ParsedAttr::AT_AddressSpace:
7286 attr.setUsedAsTypeAttr();
7291 attr.setUsedAsTypeAttr();
7293 case ParsedAttr::AT_VectorSize:
7295 attr.setUsedAsTypeAttr();
7297 case ParsedAttr::AT_ExtVectorType:
7299 attr.setUsedAsTypeAttr();
7301 case ParsedAttr::AT_NeonVectorType:
7304 attr.setUsedAsTypeAttr();
7306 case ParsedAttr::AT_NeonPolyVectorType:
7309 attr.setUsedAsTypeAttr();
7311 case ParsedAttr::AT_OpenCLAccess:
7313 attr.setUsedAsTypeAttr();
7315 case ParsedAttr::AT_LifetimeBound:
7318 state.getDeclarator());
7319 attr.setUsedAsTypeAttr();
7325 attr.setUsedAsTypeAttr();
7338 endIndex = state.getCurrentChunkIndex();
7340 endIndex = state.getDeclarator().getNumTypeObjects();
7341 bool allowOnArrayType =
7342 state.getDeclarator().isPrototypeContext() &&
7344 if (state.getSema().checkNullabilityTypeSpecifier(
7348 attr.isContextSensitiveKeywordAttribute(),
7349 allowOnArrayType)) {
7353 attr.setUsedAsTypeAttr();
7357 case ParsedAttr::AT_ObjCKindOf:
7365 state.getSema().Diag(attr.getLoc(),
7366 diag::err_objc_kindof_wrong_position)
7369 state.getDeclarator().getDeclSpec().getLocStart(),
"__kindof ");
7374 if (state.getSema().checkObjCKindOfType(type, attr.getLoc()))
7376 attr.setUsedAsTypeAttr();
7380 attr.setUsedAsTypeAttr();
7394 if (!state.getSema().getLangOpts().OpenCL ||
7403 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
7405 auto *Def = Var->getDefinition();
7408 InstantiateVariableDefinition(PointOfInstantiation, Var);
7409 Def = Var->getDefinition();
7416 if (Var->getPointOfInstantiation().isInvalid() && Def) {
7417 assert(Var->getTemplateSpecializationKind() ==
7419 "explicit instantiation with no point of instantiation");
7420 Var->setTemplateSpecializationKind(
7421 Var->getTemplateSpecializationKind(), PointOfInstantiation);
7465 completeExprArrayBound(E);
7472 return RequireCompleteType(E->
getExprLoc(), T, Diagnoser);
7477 return RequireCompleteExprType(E, Diagnoser);
7499 if (RequireCompleteTypeImpl(Loc, T, &Diagnoser))
7502 if (!Tag->getDecl()->isCompleteDefinitionRequired()) {
7503 Tag->getDecl()->setCompleteDefinitionRequired();
7504 Consumer.HandleTagDeclRequiredDefinition(Tag->getDecl());
7535 bool OnlyNeedComplete) {
7537 if (!getLangOpts().Modules && !getLangOpts().ModulesLocalVisibility)
7542 if (isa<TagDecl>(D) && cast<TagDecl>(D)->isBeingDefined()) {
7546 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(D)) {
7547 if (
auto *Pattern = RD->getTemplateInstantiationPattern())
7549 D = RD->getDefinition();
7550 }
else if (
auto *ED = dyn_cast<EnumDecl>(D)) {
7551 if (
auto *Pattern = ED->getTemplateInstantiationPattern())
7553 if (OnlyNeedComplete && ED->isFixed()) {
7557 *Suggested =
nullptr;
7558 for (
auto *Redecl : ED->redecls()) {
7559 if (isVisible(Redecl))
7561 if (Redecl->isThisDeclarationADefinition() ||
7562 (Redecl->isCanonicalDecl() && !*Suggested))
7563 *Suggested = Redecl;
7567 D = ED->getDefinition();
7568 }
else if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
7569 if (
auto *Pattern = FD->getTemplateInstantiationPattern())
7571 D = FD->getDefinition();
7572 }
else if (
auto *VD = dyn_cast<VarDecl>(D)) {
7573 if (
auto *Pattern = VD->getTemplateInstantiationPattern())
7575 D = VD->getDefinition();
7577 assert(D &&
"missing definition for pattern of instantiated definition");
7586 Source->CompleteRedeclChain(D);
7587 return isVisible(D);
7596 if (!RD->
hasAttr<MSInheritanceAttr>()) {
7597 MSInheritanceAttr::Spelling IM;
7604 IM = MSInheritanceAttr::Keyword_single_inheritance;
7607 IM = MSInheritanceAttr::Keyword_multiple_inheritance;
7610 IM = MSInheritanceAttr::Keyword_unspecified_inheritance;
7614 RD->
addAttr(MSInheritanceAttr::CreateImplicit(
7627 TypeDiagnoser *Diagnoser) {
7637 if (!MPTy->getClass()->isDependentType()) {
7638 if (getLangOpts().CompleteMemberPointers &&
7639 !MPTy->getClass()->getAsCXXRecordDecl()->isBeingDefined() &&
7640 RequireCompleteType(Loc,
QualType(MPTy->getClass(), 0),
7641 diag::err_memptr_incomplete))
7647 (void)isCompleteType(Loc,
QualType(MPTy->getClass(), 0));
7658 if (Def && !isa<EnumDecl>(Def))
7659 checkSpecializationVisibility(Loc, Def);
7666 !hasVisibleDefinition(Def, &SuggestedDef,
true)) {
7669 bool TreatAsComplete = Diagnoser && !isSFINAEContext();
7670 if (Diagnoser && SuggestedDef)
7671 diagnoseMissingImport(Loc, SuggestedDef, MissingImportKind::Definition,
7673 return !TreatAsComplete;
7674 }
else if (Def && !TemplateInstCallbacks.empty()) {
7675 CodeSynthesisContext TempInst;
7676 TempInst.Kind = CodeSynthesisContext::Memoization;
7677 TempInst.Template = Def;
7678 TempInst.Entity = Def;
7679 TempInst.PointOfInstantiation = Loc;
7714 Source->CompleteType(TagD);
7718 Source->CompleteType(IFace->getDecl());
7723 return RequireCompleteTypeImpl(Loc, T, Diagnoser);
7733 MaybeTemplate = Array->getElementType();
7735 bool Instantiated =
false;
7736 bool Diagnosed =
false;
7738 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
7739 if (ClassTemplateSpec->getSpecializationKind() ==
TSK_Undeclared) {
7740 Diagnosed = InstantiateClassTemplateSpecialization(
7743 Instantiated =
true;
7746 = dyn_cast<CXXRecordDecl>(Record->getDecl())) {
7748 if (!Rec->isBeingDefined() && Pattern) {
7750 assert(MSI &&
"Missing member specialization information?");
7754 Diagnosed = InstantiateClass(Loc, Rec, Pattern,
7755 getTemplateInstantiationArgs(Rec),
7758 Instantiated =
true;
7766 if (Diagnoser && Diagnosed)
7772 return RequireCompleteTypeImpl(Loc, T, Diagnoser);
7782 Diagnoser->diagnose(*
this, Loc, T);
7789 : diag::note_forward_declaration)
7793 if (IFace && !IFace->getDecl()->isInvalidDecl())
7794 Diag(IFace->getDecl()->getLocation(), diag::note_forward_class);
7799 ExternalSource->MaybeDiagnoseMissingCompleteType(Loc, T);
7807 return RequireCompleteType(Loc, T, Diagnoser);
7820 default: llvm_unreachable(
"Invalid tag kind for literal type diagnostic!");
7847 if ((isCompleteType(Loc, ElemType) || ElemType->isVoidType()) &&
7865 if (RequireCompleteType(Loc, ElemType, diag::note_non_literal_incomplete, T))
7870 if (RD->
isLambda() && !getLangOpts().CPlusPlus17) {
7882 for (
const auto &I : RD->
vbases())
7883 Diag(I.getLocStart(), diag::note_constexpr_virtual_base_here)
7884 << I.getSourceRange();
7887 Diag(RD->
getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD;
7889 for (
const auto &I : RD->
bases()) {
7890 if (!I.getType()->isLiteralType(Context)) {
7891 Diag(I.getLocStart(),
7892 diag::note_non_literal_base_class)
7893 << RD << I.getType() << I.getSourceRange();
7897 for (
const auto *I : RD->
fields()) {
7898 if (!I->getType()->isLiteralType(Context) ||
7899 I->getType().isVolatileQualified()) {
7900 Diag(I->getLocation(), diag::note_non_literal_field)
7901 << RD << I << I->getType()
7902 << I->getType().isVolatileQualified();
7910 assert(Dtor &&
"class has literal fields and bases but no dtor?");
7915 diag::note_non_literal_user_provided_dtor :
7916 diag::note_non_literal_nontrivial_dtor) << RD;
7918 SpecialMemberIsTrivial(Dtor, CXXDestructor, TAH_IgnoreTrivialABI,
7927 return RequireLiteralType(Loc, T, Diagnoser);
7955 Diag(E->
getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 2;
7960 DiagnoseUseOfDecl(TT->getDecl(), E->
getExprLoc());
7984 }
else if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
7985 if (
const ValueDecl *VD = ME->getMemberDecl())
7986 if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
7987 return VD->getType();
7988 }
else if (
const ObjCIvarRefExpr *IR = dyn_cast<ObjCIvarRefExpr>(E)) {
7989 return IR->getDecl()->getType();
7991 if (PR->isExplicitProperty())
7992 return PR->getExplicitProperty()->getType();
7993 }
else if (
auto *PE = dyn_cast<PredefinedExpr>(E)) {
7994 return PE->getType();
8004 using namespace sema;
8006 if (isa<ParenExpr>(E)) {
8008 if (
VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
8036 bool AsUnevaluated) {
8041 if (AsUnevaluated && CodeSynthesisContexts.empty() &&
8045 Diag(E->
getExprLoc(), diag::warn_side_effects_unevaluated_context);
8057 Diag(Loc, diag::err_only_enums_have_underlying_types);
8066 Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
8067 Diag(FwdDecl->
getLocation(), diag::note_forward_declaration) << FwdDecl;
8072 assert(ED &&
"EnumType has no EnumDecl");
8074 DiagnoseUseOfDecl(ED, Loc);
8077 assert(!Underlying.
isNull());
8083 llvm_unreachable(
"unknown unary transform type");
8090 if (RequireCompleteType(Loc, T, diag::err_atomic_specifier_bad_type, 0))
8093 int DisallowedKind = -1;
8108 if (DisallowedKind != -1) {
8109 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
ParameterABI getABI() const
Return the ABI treatment of this parameter.
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.
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 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...
QualType BuildUnaryTransformType(QualType BaseType, UnaryTransformType::UTTKind UKind, SourceLocation Loc)
__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
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)
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.
static void fillAttributedTypeLoc(AttributedTypeLoc TL, const ParsedAttributesView &Attrs, const ParsedAttributesView &DeclAttrs)
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...
TagDecl * getDecl() const
static void HandleAddressSpaceTypeAttribute(QualType &Type, const ParsedAttr &Attr, Sema &S)
HandleAddressSpaceTypeAttribute - Process an address_space attribute on the specified type...
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...
SourceLocation getVolatileQualifierLoc() const
Retrieve the location of the 'volatile' qualifier, if any.
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
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".
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.
#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.
bool checkObjCKindOfType(QualType &type, SourceLocation loc)
Check the application of the Objective-C '__kindof' qualifier to the given type.
void setParensRange(SourceRange range)
static ParsedAttr::Kind getAttrListKind(AttributedType::Kind kind)
Map an AttributedType::Kind to an ParsedAttr::Kind.
An identifier, stored as an IdentifierInfo*.
QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace, SourceLocation AttrLoc)
BuildAddressSpaceAttr - Builds a DependentAddressSpaceType if an expression is uninstantiated.
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.
Describes how types, statements, expressions, and declarations should be printed. ...
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
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()
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
The collection of all-type qualifiers we support.
bool isVariableArrayType() const
bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value)
Checks a regparm attribute, returning true if it is ill-formed and otherwise setting numParams to the...
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.
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
Represents a class template specialization, which refers to a class template with a given set of temp...
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...
static void HandleLifetimeBoundAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S, Declarator &D)
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
static void deduceOpenCLImplicitAddrSpace(TypeProcessingState &State, QualType &T, TypeAttrLocation TAL)
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 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
static const TST TST_class
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.
unsigned TypeQuals
The type qualifiers: const/volatile/restrict/__unaligned The qualifier bitmask values are the same as...
static const TST TST_double
bool hasAutoTypeSpec() const
bool isReferenceType() const
void setElaboratedKeywordLoc(SourceLocation Loc)
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...
SourceLocation getLocStart() const LLVM_READONLY
TypeLoc getNextTypeLoc() const
static const TSW TSW_unspecified
void copy(DependentTemplateSpecializationTypeLoc Loc)
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
SourceLocation getRestrictQualifierLoc() const
Retrieve the location of the 'restrict' qualifier, if any.
A user-defined literal name, e.g., operator "" _i.
unsigned getTypeQuals() const
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
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)
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.
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 ...
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 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.
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)
void AddInnermostTypeInfo(const DeclaratorChunk &TI)
Add a new innermost chunk to this declarator.
const Type * getClass() const
void expandBuiltinRange(SourceRange Range)
TSS getTypeSpecSign() const
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.
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.
enum clang::DeclaratorChunk::@196 Kind
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...
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
void setLocalRangeBegin(SourceLocation L)
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 getLocStart() const LLVM_READONLY
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.
SmallVector< TemplateTypeParmDecl *, 4 > AutoTemplateParams
Store the list of the auto parameters for a generic lambda.
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
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...
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
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.
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.
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
bool isDeclarationOfFunction() const
Determine whether the declaration that will be produced from this declaration will be a function...
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...
void setAttrNameLoc(SourceLocation loc)
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...
void setAttrExprOperand(Expr *e)
unsigned hasStatic
True if this dimension included the 'static' keyword.
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 ...
Expr - This represents one expression.
QualType getPointeeType() const
llvm::StringRef getAsString(SyncScope S)
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, unsigned TypeQuals, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation ConstQualifierLoc, SourceLocation VolatileQualifierLoc, SourceLocation RestrictQualifierLoc, 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())
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
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...
bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC, const FunctionDecl *FD=nullptr)
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
getNameAsString - 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.
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
bool isConstexprSpecified() 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.
TypeSourceInfo * GetTypeSourceInfoForDeclarator(Declarator &D, QualType T, TypeSourceInfo *ReturnTypeInfo)
Create and instantiate a TypeSourceInfo with type source information.
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.
bool CheckAttrNoArgs(const ParsedAttr &CurrAttr)
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...
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
SourceLocation getLocEnd() const LLVM_READONLY
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
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
AttributedType::Kind getAttrKind() const
TypeSourceInfo * GetTypeForDeclaratorCast(Declarator &D, QualType FromTy)
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
bool hasAttrExprOperand() const
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const
Return the uniqued reference to the type for an Objective-C gc-qualified type.
bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type)
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.
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent) const
C++11 deduced auto type.
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
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
QualType getPackExpansionType(QualType Pattern, Optional< unsigned > NumExpansions)
static const TST TST_fract
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)
void addAtStart(ParsedAttr *newAttr)
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...
void setAttrOperandParensRange(SourceRange range)
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.
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 getLocStart() const LLVM_READONLY
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
const ConstantArrayType * getAsConstantArrayType(QualType T) const
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
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
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)
void setLBracketLoc(SourceLocation Loc)
AutoTypeKeyword getKeyword() const
TypeClass getTypeClass() const
QualType getAttributedType(AttributedType::Kind attrKind, QualType modifiedType, QualType equivalentType)
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)
SourceLocation getPragmaAssumeNonNullLoc() const
The location of the currently-active #pragma clang assume_nonnull begin.
SourceLocation getConstQualifierLoc() const
Retrieve the location of the 'const' qualifier, if any.
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.
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...
static AttributedType::Kind getCCTypeAttrKind(ParsedAttr &Attr)
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;...
Represents a pack expansion of types.
void setLParenLoc(SourceLocation Loc)
StringRef getName() const
Return the actual identifier string.
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...
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current target.
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 void setAttributedTypeLoc(AttributedTypeLoc TL, const ParsedAttr &attr)
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
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
SourceLocation getLocStart() const LLVM_READONLY
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.
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
DeclarationName - 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
SourceLocation getLocEnd() const LLVM_READONLY
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.
The maximum supported address space number.
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.
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
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)
unsigned getNumParams() const
void setNameLoc(SourceLocation Loc)
bool hasAttrEnumOperand() const
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
void setAttrEnumOperandLoc(SourceLocation loc)
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.
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.
bool isBeingDefined() const
Determines whether this type is in the process of being defined.
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...
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, std::unique_ptr< CorrectionCandidateCallback > CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
Describes whether we've seen any nullability information for the given file.
bool CheckAttrTarget(const ParsedAttr &CurrAttr)
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.
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.
bool checkNullabilityTypeSpecifier(QualType &type, NullabilityKind nullability, SourceLocation nullabilityLoc, bool isContextSensitive, bool allowArrayTypes)
Check whether a nullability type specifier can be added to the given 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...
bool hasAttrOperand() const
SourceManager & getSourceManager() const
A template-id, e.g., f<int>.
static void checkUnusedDeclAttributes(Sema &S, const ParsedAttributesView &A)
checkUnusedDeclAttributes - Check a list of attributes to see if it contains any decl attributes that...
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
__DEVICE__ int max(int __a, int __b)
static Decl::Kind getKind(const Decl *D)
QualType getSignedWCharType() const
Return the type of "signed wchar_t".
static OpaquePtr make(QualType P)
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
SourceManager & SourceMgr
bool isEmpty() const
isEmpty - Return true if this declaration specifier is completely empty: no tokens were parsed in the...
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.
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...
bool hasExplicitCallingConv(QualType &T)
__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.
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...
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.
SourceLocation getLocEnd() const LLVM_READONLY
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)
Wrapper for source info for pointers.
SourceLocation getBegin() const
QualType getReadPipeType(QualType T) const
Return a read_only pipe type for the specified 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()
Represents the canonical version of C arrays with a specified constant size.
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.
This parameter (which must have pointer type) is a Swift indirect result parameter.
QualType BuildTypeofExprType(Expr *E, SourceLocation Loc)
void setUnderlyingTInfo(TypeSourceInfo *TI) const
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
IgnoreParens - Ignore parentheses.
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?