28#include "llvm/ADT/DenseMap.h"
29#include "llvm/ADT/DenseSet.h"
61 assert(resultClass &&
"unexpected object type!");
66 if (receiverTypeIfCall.
isNull() &&
76 if (receiverTypeIfCall.
isNull())
83 if (!receiverClass)
return false;
86 assert(receiverClass &&
"method not associated with a class!");
102 UnavailableAttr::IR_ARCInitReturnsUnrelated, loc));
107 Diag(loc, diag::err_arc_init_method_unrelated_result_type);
116 if (OldD->
hasAttr<NoEscapeAttr>() && !NewD->
hasAttr<NoEscapeAttr>()) {
117 S.
Diag(NewD->
getLocation(), diag::warn_overriding_method_missing_noescape);
153 CurrentClass = Cat->getClassInterface();
154 else if (
ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(DC))
155 CurrentClass = Impl->getClassInterface();
157 = dyn_cast<ObjCCategoryImplDecl>(DC))
158 CurrentClass = CatImpl->getClassInterface();
163 diag::warn_related_result_type_compatibility_class)
169 diag::warn_related_result_type_compatibility_protocol)
176 diag::note_related_result_type_family)
181 diag::note_related_result_type_overridden);
184 if ((NewMethod->
hasAttr<NSReturnsRetainedAttr>() !=
185 Overridden->
hasAttr<NSReturnsRetainedAttr>())) {
188 ? diag::err_nsreturns_retained_attribute_mismatch
189 : diag::warn_nsreturns_retained_attribute_mismatch)
193 if ((NewMethod->
hasAttr<NSReturnsNotRetainedAttr>() !=
194 Overridden->
hasAttr<NSReturnsNotRetainedAttr>())) {
197 ? diag::err_nsreturns_retained_attribute_mismatch
198 : diag::warn_nsreturns_retained_attribute_mismatch)
207 ni != ne && oi != oe; ++ni, ++oi) {
210 if (newDecl->
hasAttr<NSConsumedAttr>() !=
211 oldDecl->
hasAttr<NSConsumedAttr>()) {
214 ? diag::err_nsconsumed_attribute_mismatch
215 : diag::warn_nsconsumed_attribute_mismatch);
263 if (method->
hasAttr<NSReturnsRetainedAttr>())
271 if (method->
hasAttr<NSReturnsRetainedAttr>() ||
272 method->
hasAttr<NSReturnsNotRetainedAttr>() ||
273 method->
hasAttr<NSReturnsAutoreleasedAttr>())
286 bool IsCategory =
false;
287 StringRef RealizedPlatform;
289 nullptr, VersionTuple(),
292 if (isa<ObjCMethodDecl>(ND)) {
295 if (RealizedPlatform.empty())
299 if (RealizedPlatform.ends_with(
"_app_extension"))
301 S.
Diag(ImplLoc, diag::warn_unavailable_def);
306 if (
const auto *CD = dyn_cast<ObjCCategoryDecl>(ND)) {
307 if (!CD->getClassInterface()->isDeprecated())
309 ND = CD->getClassInterface();
314 S.
Diag(ImplLoc, diag::warn_deprecated_def)
315 << (isa<ObjCMethodDecl>(ND)
317 : isa<ObjCCategoryDecl>(ND) || IsCategory ? 2
319 if (isa<ObjCMethodDecl>(ND))
324 << (isa<ObjCCategoryDecl>(ND) ?
"category" :
"class");
377 diag::err_func_def_incomplete_result))
399 if (!Param->isInvalidDecl() &&
402 Diag(Param->getLocation(), diag::warn_arc_strong_pointer_objc_pointer) <<
405 if (Param->getIdentifier())
448 ImplDeclOfMethodDecl = OID->getImplementation();
449 else if (
ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ContDeclOfMethodDecl)) {
450 if (CD->IsClassExtension()) {
452 ImplDeclOfMethodDecl = OID->getImplementation();
454 ImplDeclOfMethodDecl = CD->getImplementation();
458 if (!ImplDeclOfMethodDecl || ImplDeclOfMethodDecl != ImplDeclOfMethodDef)
466 IC->getSuperClass() !=
nullptr;
467 }
else if (IC->hasDesignatedInitializers()) {
493 (SuperMethod && SuperMethod->
hasAttr<ObjCRequiresSuperAttr>());
506 ObjCInterfaceValidatorCCC() : CurrentIDecl(nullptr) {}
508 : CurrentIDecl(IDecl) {}
510 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
515 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
516 return std::make_unique<ObjCInterfaceValidatorCCC>(*
this);
528 unsigned NumProtoRefs,
533 for (
unsigned i = 0; i < NumProtoRefs; ++i) {
558 ObjCInterfaceValidatorCCC CCC(IDecl);
563 << SuperName << ClassName);
569 Diag(SuperLoc, diag::err_recursive_superclass)
570 << SuperName << ClassName <<
SourceRange(AtInterfaceLoc, ClassLoc);
574 dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
578 if (SuperClassDecl) {
583 if (PrevDecl && !SuperClassDecl) {
587 dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
588 QualType T = TDecl->getUnderlyingType();
591 SuperClassDecl = dyn_cast<ObjCInterfaceDecl>(IDecl);
608 if (!SuperClassDecl) {
609 Diag(SuperLoc, diag::err_redefinition_different_kind) << SuperName;
614 if (!isa_and_nonnull<TypedefNameDecl>(PrevDecl)) {
616 Diag(SuperLoc, diag::err_undef_superclass)
617 << SuperName << ClassName <<
SourceRange(AtInterfaceLoc, ClassLoc);
620 diag::err_forward_superclass,
624 SuperClassDecl =
nullptr;
629 if (SuperClassType.
isNull()) {
630 assert(!SuperClassDecl &&
"Failed to set SuperClassType?");
636 if (!SuperTypeArgs.empty()) {
644 SuperTypeArgsRange.
getEnd(),
656 if (!SuperClassTInfo) {
676 if (parsedTypeBound) {
687 diag::err_objc_type_param_bound_missing_pointer)
688 << typeBound << paramName
707 diag::err_objc_type_param_bound_nonobject)
708 << typeBound << paramName;
711 typeBoundInfo =
nullptr;
720 bool diagnosed =
false;
724 rangeToRemove =
attr.getLocalSourceRange();
725 if (
attr.getTypePtr()->getImmediateNullability()) {
727 diag::err_objc_type_param_bound_explicit_nullability)
728 << paramName << typeBound
738 diag::err_objc_type_param_bound_qualified)
739 << paramName << typeBound
749 if (!quals.
empty()) {
759 if (!typeBoundInfo) {
766 index, paramLoc, paramName, colonLoc,
778 typeParamsIn.size());
784 llvm::SmallDenseMap<IdentifierInfo *, ObjCTypeParamDecl *> knownParams;
785 for (
auto *typeParam : typeParams) {
786 auto known = knownParams.find(typeParam->getIdentifier());
787 if (known != knownParams.end()) {
788 Diag(typeParam->getLocation(), diag::err_objc_type_param_redecl)
789 << typeParam->getIdentifier()
792 typeParam->setInvalidDecl();
794 knownParams.insert(std::make_pair(typeParam->getIdentifier(), typeParam));
806 for (
auto *typeParam : *typeParamList) {
807 if (!typeParam->isInvalidDecl()) {
808 S->RemoveDecl(typeParam);
817 enum class TypeParamListContext {
831 TypeParamListContext newContext) {
833 if (prevTypeParams->
size() != newTypeParams->
size()) {
835 if (newTypeParams->
size() > prevTypeParams->
size()) {
841 S.
Diag(diagLoc, diag::err_objc_type_param_arity_mismatch)
842 <<
static_cast<unsigned>(newContext)
843 << (newTypeParams->
size() > prevTypeParams->
size())
844 << prevTypeParams->
size()
845 << newTypeParams->
size();
851 for (
unsigned i = 0, n = prevTypeParams->
size(); i != n; ++i) {
858 newContext != TypeParamListContext::Definition) {
877 auto diag = S.
Diag(diagLoc,
878 diag::err_objc_type_param_variance_conflict)
879 <<
static_cast<unsigned>(newTypeParam->
getVariance())
881 <<
static_cast<unsigned>(prevTypeParam->
getVariance())
890 StringRef newVarianceStr
897 (newVarianceStr +
" ").str());
924 S.
Diag(newBoundRange.
getBegin(), diag::err_objc_type_param_bound_conflict)
948 if (newContext == TypeParamListContext::ForwardDeclaration ||
949 newContext == TypeParamListContext::Definition) {
957 diag::err_objc_type_param_bound_missing)
960 << (newContext == TypeParamListContext::ForwardDeclaration)
979 Decl *
const *ProtoRefs,
unsigned NumProtoRefs,
982 assert(ClassName &&
"Missing class identifier");
989 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
990 Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
1017 if (typeParamList) {
1021 TypeParamListContext::Definition)) {
1022 typeParamList =
nullptr;
1025 Diag(ClassLoc, diag::err_objc_parameterized_forward_class_first)
1027 Diag(prevTypeParamList->getLAngleLoc(), diag::note_previous_decl)
1032 for (
auto *typeParam : *prevTypeParamList) {
1033 clonedTypeParams.push_back(
1037 typeParam->getVariance(),
1039 typeParam->getIndex(),
1041 typeParam->getIdentifier(),
1056 typeParamList, PrevIDecl, ClassLoc);
1062 SkipBody->
New = IDecl;
1065 Diag(AtInterfaceLoc, diag::err_duplicate_class_def)
1067 Diag(Def->getLocation(), diag::note_previous_definition);
1095 ClassName, ClassLoc,
1096 SuperName, SuperLoc, SuperTypeArgs,
1097 SuperTypeArgsRange);
1105 NumProtoRefs, ProtoLocs);
1130 if (
const TypedefNameDecl *TDecl = dyn_cast_or_null<TypedefNameDecl>(IDecl)) {
1131 QualType T = TDecl->getUnderlyingType();
1134 ProtocolRefs.append(OPT->qual_begin(), OPT->qual_end());
1139 ProtocolLocs.append(OPT->getNumProtocols(), SuperLoc);
1156 Diag(AliasLocation, diag::err_conflicting_aliasing_type) << AliasName;
1165 dyn_cast_or_null<TypedefNameDecl>(CDeclU)) {
1166 QualType T = TDecl->getUnderlyingType();
1169 ClassName = IDecl->getIdentifier();
1178 Diag(ClassLocation, diag::warn_undef_interface) << ClassName;
1201 E = PList.
end(); I != E; ++I) {
1204 if (PDecl->getIdentifier() == PName) {
1205 Diag(Ploc, diag::err_protocol_has_circular_dependency);
1206 Diag(PrevLoc, diag::note_previous_definition);
1210 if (!PDecl->hasDefinition())
1214 PDecl->getLocation(), PDecl->getReferencedProtocols()))
1228 assert(ProtocolName &&
"Missing protocol identifier");
1238 ProtocolLoc, AtProtoInterfaceLoc,
1243 SkipBody->
New = PDecl;
1247 Diag(ProtocolLoc, diag::warn_duplicate_protocol_def) << ProtocolName;
1248 Diag(Def->getLocation(), diag::note_previous_definition);
1263 ProtocolName, ProtocolLoc, PrevDecl->
getLocation(), PList);
1268 ProtocolLoc, AtProtoInterfaceLoc,
1283 if (!err && NumProtoRefs ) {
1286 NumProtoRefs, ProtoLocs);
1300 UndefinedProtocol = PDecl;
1306 UndefinedProtocol = PI;
1332 Diag(Pair.second, diag::err_undeclared_protocol) << Pair.first;
1341 if (!ForObjCContainer) {
1350 if (WarnOnDeclarations &&
1352 Diag(Pair.second, diag::warn_undef_protocolref) << Pair.first;
1353 Diag(UndefinedProtocol->
getLocation(), diag::note_protocol_decl_undefined)
1354 << UndefinedProtocol;
1356 Protocols.push_back(PDecl);
1363class ObjCTypeArgOrProtocolValidatorCCC final
1368 ObjCTypeArgOrProtocolValidatorCCC(
ASTContext &context,
1370 : Context(context), LookupKind(lookupKind) { }
1372 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
1386 if (isa<RecordDecl>(typeDecl) && !Context.
getLangOpts().CPlusPlus)
1392 if (
type->isObjCObjectPointerType() ||
1393 type->isBlockPointerType() ||
1394 type->isDependentType() ||
1395 type->isObjCObjectType())
1412 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
1413 return std::make_unique<ObjCTypeArgOrProtocolValidatorCCC>(*
this);
1422 bool SelectProtocolFirst) {
1423 Diag(TypeArgLoc, diag::err_objc_type_args_and_protocols)
1424 << SelectProtocolFirst << TypeArgId << ProtocolId
1441 bool warnOnIncompleteProtocols) {
1444 unsigned numProtocolsResolved = 0;
1445 auto resolvedAsProtocols = [&] {
1446 assert(numProtocolsResolved == identifiers.size() &&
"Unresolved protocols");
1453 bool allAreTypeNames =
false;
1457 baseClass = objcObjectType->getInterface();
1460 if (typeParams->size() == numProtocolsResolved) {
1462 allAreTypeNames =
true;
1469 for (
unsigned i = 0, n = protocols.size(); i != n; ++i) {
1474 if (!warnOnIncompleteProtocols) {
1486 if (warnOnIncompleteProtocols &&
1488 Diag(identifierLocs[i], diag::warn_undef_protocolref)
1497 if (allAreTypeNames) {
1500 if (isa<ObjCInterfaceDecl>(
decl)) {
1502 firstClassNameLoc = identifierLocs[i];
1503 }
else if (!isa<TypeDecl>(
decl)) {
1505 allAreTypeNames =
false;
1508 allAreTypeNames =
false;
1517 if (allAreTypeNames && firstClassNameLoc.
isValid()) {
1520 bool allProtocolsDeclared =
true;
1521 for (
auto *proto : protocols) {
1523 allProtocolsDeclared =
false;
1528 if (allProtocolsDeclared) {
1529 Diag(firstClassNameLoc, diag::warn_objc_redundant_qualified_class_type)
1536 protocolLAngleLoc = lAngleLoc;
1537 protocolRAngleLoc = rAngleLoc;
1538 assert(protocols.size() == identifierLocs.size());
1542 for (
unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1544 protocols.push_back(proto);
1546 ++numProtocolsResolved;
1550 if (numProtocolsResolved == identifiers.size())
1551 return resolvedAsProtocols();
1557 typedef llvm::PointerUnion<TypeDecl *, ObjCInterfaceDecl *> TypeOrClassDecl;
1559 unsigned numTypeDeclsResolved = 0;
1560 for (
unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1564 typeDecls.push_back(TypeOrClassDecl());
1568 if (
auto typeDecl = dyn_cast<TypeDecl>(
decl)) {
1569 typeDecls.push_back(typeDecl);
1570 ++numTypeDeclsResolved;
1574 if (
auto objcClass = dyn_cast<ObjCInterfaceDecl>(
decl)) {
1575 typeDecls.push_back(objcClass);
1576 ++numTypeDeclsResolved;
1580 typeDecls.push_back(TypeOrClassDecl());
1587 auto resolveTypeReference = [&](TypeOrClassDecl typeDecl,
SourceLocation loc)
1591 const char* prevSpec;
1594 if (
auto *actualTypeDecl = typeDecl.dyn_cast<
TypeDecl *>())
1622 Diag(loc, diag::err_objc_type_arg_missing_star)
1633 auto resolvedAsTypeDecls = [&] {
1637 assert(numTypeDeclsResolved == identifiers.size() &&
"Unresolved type decl");
1639 for (
unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1641 TypeResult type = resolveTypeReference(typeDecls[i], identifierLocs[i]);
1642 if (!
type.isUsable()) {
1647 typeArgs.push_back(
type.get());
1650 typeArgsLAngleLoc = lAngleLoc;
1651 typeArgsRAngleLoc = rAngleLoc;
1656 if (numTypeDeclsResolved == identifiers.size())
1657 return resolvedAsTypeDecls();
1663 for (
unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1666 if (protocols[i] || typeDecls[i]) {
1672 if (protocols[i] && typeDecls[i])
1695 identifiers[i], identifierLocs[i],
1696 protocols[i] !=
nullptr);
1704 ObjCTypeArgOrProtocolValidatorCCC CCC(
Context, lookupKind);
1712 PDiag(diag::err_undeclared_protocol_suggest)
1715 protocols[i] = proto;
1716 ++numProtocolsResolved;
1723 PDiag(diag::err_unknown_typename_suggest)
1726 typeDecls[i] = typeDecl;
1727 ++numTypeDeclsResolved;
1734 PDiag(diag::err_unknown_type_or_class_name_suggest)
1735 << identifiers[i] <<
true);
1737 typeDecls[i] = objcClass;
1738 ++numTypeDeclsResolved;
1744 Diag(identifierLocs[i],
1745 (lookupKind ==
LookupAnyName ? diag::err_objc_type_arg_missing
1747 : diag::err_unknown_typename))
1756 if (numProtocolsResolved == identifiers.size())
1757 return resolvedAsProtocols();
1760 assert(numTypeDeclsResolved == identifiers.size() &&
"Not all types?");
1761 return resolvedAsTypeDecls();
1772 llvm::DenseMap<Selector, const ObjCMethodDecl*> MethodMap;
1773 for (
auto *MD : ID->methods())
1774 MethodMap[MD->getSelector()] = MD;
1776 if (MethodMap.empty())
1778 for (
const auto *Method : CAT->
methods()) {
1779 const ObjCMethodDecl *&PrevMethod = MethodMap[Method->getSelector()];
1783 Diag(Method->getLocation(), diag::err_duplicate_method_decl)
1784 << Method->getDeclName();
1802 IdentPair.second, AtProtocolLoc,
1814 DeclsInGroup.push_back(PDecl);
1824 Decl *
const *ProtoRefs,
unsigned NumProtoRefs,
1834 diag::err_category_forward_interface,
1835 CategoryName ==
nullptr)) {
1840 ClassLoc, CategoryLoc, CategoryName,
1841 IDecl, typeParamList);
1846 Diag(ClassLoc, diag::err_undef_interface) << ClassName;
1852 Diag(ClassLoc, diag::err_class_extension_after_impl) << ClassName;
1854 diag::note_implementation_declared);
1862 Diag(CategoryLoc, diag::warn_dup_category_def)
1863 << ClassName << CategoryName;
1864 Diag(
Previous->getLocation(), diag::note_previous_definition);
1869 if (typeParamList) {
1873 ? TypeParamListContext::Category
1874 : TypeParamListContext::Extension))
1875 typeParamList =
nullptr;
1878 diag::err_objc_parameterized_category_nonclass)
1879 << (CategoryName !=
nullptr)
1883 typeParamList =
nullptr;
1888 ClassLoc, CategoryLoc, CategoryName, IDecl,
1901 NumProtoRefs, ProtoLocs);
1939 ClassLoc, AtCatImplLoc, CatLoc);
1942 Diag(ClassLoc, diag::err_undef_interface) << ClassName;
1945 diag::err_undef_interface)) {
1957 if (IDecl && IDecl->
hasAttr<ObjCRuntimeVisibleAttr>()) {
1958 Diag(ClassLoc, diag::err_objc_runtime_visible_category)
1965 Diag(ClassLoc, diag::err_dup_implementation_category) << ClassName
1968 diag::note_previous_definition);
1993 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
1994 Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
1996 }
else if ((IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl))) {
2000 diag::warn_undef_interface);
2004 ObjCInterfaceValidatorCCC CCC{};
2013 PDiag(diag::warn_undef_interface_suggest) << ClassName,
2016 Diag(ClassLoc, diag::warn_undef_interface) << ClassName;
2022 if (SuperClassname) {
2026 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
2027 Diag(SuperClassLoc, diag::err_redefinition_different_kind)
2031 SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
2035 Diag(SuperClassLoc, diag::err_undef_superclass)
2036 << SuperClassname << ClassName;
2040 Diag(SuperClassLoc, diag::err_conflicting_super_class)
2079 ClassLoc, AtClassImplLoc, SuperClassLoc);
2092 Diag(ClassLoc, diag::err_dup_implementation_class) << ClassName;
2094 diag::note_previous_definition);
2108 Diag(ClassLoc, diag::err_objc_runtime_visible_subclass)
2120 DeclsInGroup.reserve(Decls.size() + 1);
2122 for (
unsigned i = 0, e = Decls.size(); i != e; ++i) {
2123 Decl *Dcl = Decls[i];
2128 DeclsInGroup.push_back(Dcl);
2131 DeclsInGroup.push_back(ObjCImpDecl);
2139 assert(ImpDecl &&
"missing implementation decl");
2149 for (
unsigned i = 0, e = numIvars; i != e; ++i) {
2166 assert(ivars &&
"missing @implementation ivars");
2170 for (
unsigned i = 0; i < numIvars; i++) {
2175 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
2183 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
2200 for (; numIvars > 0 && IVI != IVE; ++IVI) {
2203 assert (ImplIvar &&
"missing implementation ivar");
2204 assert (ClsIvar &&
"missing class ivar");
2216 diag::err_conflicting_ivar_bitwidth)
2219 diag::note_previous_definition);
2231 Diag(ivars[j]->getLocation(), diag::err_inconsistent_ivar_count);
2232 else if (IVI != IVE)
2233 Diag(IVI->getLocation(), diag::err_inconsistent_ivar_count);
2260 std::string FixItStr;
2261 llvm::raw_string_ostream Out(FixItStr);
2272 S.
Diag(MethodLoc, diag::note_method_declared_at) << method;
2348 (y &
~Decl::OBJC_TQ_CSNullability);
2354 bool IsProtocolMethodDecl,
2355 bool IsOverridingMode,
2357 if (IsProtocolMethodDecl &&
2363 ? diag::warn_conflicting_overriding_ret_type_modifiers
2364 : diag::warn_conflicting_ret_type_modifiers))
2373 if (Warn && IsOverridingMode &&
2381 diag::warn_conflicting_nullability_attr_overriding_ret_types)
2398 IsOverridingMode ? diag::warn_conflicting_overriding_ret_types
2399 : diag::warn_conflicting_ret_types;
2415 IsOverridingMode ? diag::warn_non_covariant_overriding_ret_types
2416 : diag::warn_non_covariant_ret_types;
2425 ? diag::note_previous_declaration
2426 : diag::note_previous_definition)
2436 bool IsProtocolMethodDecl,
2437 bool IsOverridingMode,
2439 if (IsProtocolMethodDecl &&
2443 if (IsOverridingMode)
2445 diag::warn_conflicting_overriding_param_modifiers)
2449 diag::warn_conflicting_param_modifiers)
2461 if (Warn && IsOverridingMode &&
2465 diag::warn_conflicting_nullability_attr_overriding_param_types)
2480 IsOverridingMode ? diag::warn_conflicting_overriding_param_types
2481 : diag::warn_conflicting_param_types;
2497 IsOverridingMode ? diag::warn_non_contravariant_overriding_param_types
2498 : diag::warn_non_contravariant_param_types;
2504 << MethodImpl->
getDeclName() << IfaceTy << ImplTy;
2506 (IsOverridingMode ? diag::note_previous_declaration
2507 : diag::note_previous_definition))
2518 if (implFamily == declFamily)
return false;
2530 unsigned errorID = diag::err_arc_lost_method_convention;
2531 unsigned noteID = diag::note_arc_lost_method_convention;
2534 family = implFamily;
2535 errorID = diag::err_arc_gained_method_convention;
2536 noteID = diag::note_arc_gained_method_convention;
2540 enum FamilySelector {
2541 F_alloc, F_copy, F_mutableCopy = F_copy, F_init, F_new
2543 FamilySelector familySelector = FamilySelector();
2546 case OMF_None: llvm_unreachable(
"logic error, no method convention");
2560 case OMF_init: familySelector = F_init;
break;
2561 case OMF_alloc: familySelector = F_alloc;
break;
2562 case OMF_copy: familySelector = F_copy;
break;
2564 case OMF_new: familySelector = F_new;
break;
2567 enum ReasonSelector { R_NonObjectReturn, R_UnrelatedReturn };
2568 ReasonSelector reasonSelector;
2573 reasonSelector = R_UnrelatedReturn;
2575 reasonSelector = R_NonObjectReturn;
2579 S.
Diag(
decl->getLocation(), noteID) <<
int(familySelector) <<
int(reasonSelector);
2586 bool IsProtocolMethodDecl) {
2592 IsProtocolMethodDecl,
false,
2598 IM != EM && IF != EF; ++IM, ++IF) {
2600 IsProtocolMethodDecl,
false,
true);
2605 diag::warn_conflicting_variadic);
2612 bool IsProtocolMethodDecl) {
2615 IsProtocolMethodDecl,
true,
2621 IM != EM && IF != EF; ++IM, ++IF) {
2623 IsProtocolMethodDecl,
true,
true);
2628 diag::warn_conflicting_overriding_variadic);
2637 bool IsProtocolMethodDecl) {
2646 if (MethodDecl->
hasAttr<UnavailableAttr>() ||
2647 MethodDecl->
hasAttr<DeprecatedAttr>())
2651 IsProtocolMethodDecl,
false,
false);
2656 IM != EM && IF != EF; ++IM, ++IF) {
2659 IsProtocolMethodDecl,
false,
false);
2671 diag::warn_category_method_impl_match);
2688 if (PDecl->
hasAttr<ObjCExplicitProtocolImplAttr>())
2690 for (
const auto *PI : PDecl->
protocols())
2716 : dyn_cast<ObjCInterfaceDecl>(CDecl);
2717 assert (IDecl &&
"CheckProtocolMethodDefs - IDecl is null");
2733 if (PDecl->
hasAttr<ObjCExplicitProtocolImplAttr>()) {
2734 if (!ProtocolsExplictImpl) {
2756 if (InsMap.count(fISelector))
2775 if (method->getImplementationControl() !=
2777 !method->isPropertyAccessor() &&
2778 !InsMap.count(method->getSelector()) &&
2780 method->getSelector(),
true ,
2793 method->getSelector(),
true ,
2795 if (
C || MethodInClass->isPropertyAccessor())
2797 unsigned DIAG = diag::warn_unimplemented_protocol_method;
2805 if (method->getImplementationControl() !=
2807 !ClsMap.count(method->getSelector()) &&
2809 method->getSelector(),
false ,
2811 true ,
nullptr ))) {
2819 unsigned DIAG = diag::warn_unimplemented_protocol_method;
2828 ProtocolsExplictImpl);
2840 bool &IncompleteImpl,
2841 bool ImmediateClass,
2842 bool WarnCategoryMethodImpl) {
2846 if (!InsMapSeen.insert(I->getSelector()).second)
2848 if (!I->isPropertyAccessor() &&
2849 !InsMap.count(I->getSelector())) {
2852 diag::warn_undef_method_impl);
2858 "Expected to find the method through lookup as well");
2860 if (ImpMethodDecl) {
2864 if (!WarnCategoryMethodImpl)
2866 isa<ObjCProtocolDecl>(CDecl));
2867 else if (!I->isPropertyAccessor())
2876 if (!ClsMapSeen.insert(I->getSelector()).second)
2878 if (!I->isPropertyAccessor() &&
2879 !ClsMap.count(I->getSelector())) {
2882 diag::warn_undef_method_impl);
2887 "Expected to find the method through lookup as well");
2889 if (ImpMethodDecl) {
2893 if (!WarnCategoryMethodImpl)
2895 isa<ObjCProtocolDecl>(CDecl));
2896 else if (!I->isPropertyAccessor())
2905 for (
auto *PI : PD->protocols())
2907 IMPDecl, PI, IncompleteImpl,
false,
2908 WarnCategoryMethodImpl);
2915 if (!WarnCategoryMethodImpl) {
2916 for (
auto *Cat : I->visible_categories())
2918 IMPDecl, Cat, IncompleteImpl,
2919 ImmediateClass && Cat->IsClassExtension(),
2920 WarnCategoryMethodImpl);
2923 for (
auto *Ext : I->visible_extensions())
2925 IMPDecl, Ext, IncompleteImpl,
false,
2926 WarnCategoryMethodImpl);
2930 for (
auto *PI : I->all_referenced_protocols())
2932 IMPDecl, PI, IncompleteImpl,
false,
2933 WarnCategoryMethodImpl);
2937 if (!WarnCategoryMethodImpl && I->getSuperClass())
2940 I->getSuperClass(), IncompleteImpl,
false);
2971 if (SuperIDecl && SuperIDecl->
lookupMethod(Sel,
false))
2975 if (InsMap.empty() && ClsMap.empty())
2979 bool IncompleteImpl =
false;
2982 IncompleteImpl,
false,
2988 bool IncompleteImpl) {
2993 InsMap.insert(I->getSelector());
3001 const auto *
P = PImpl->getPropertyDecl();
3004 InsMap.insert(
P->getGetterName());
3005 if (!
P->getSetterName().isNull())
3006 InsMap.insert(
P->getSetterName());
3013 bool SynthesizeProperties =
LangOpts.ObjCDefaultSynthProperties &&
3015 !IDecl->isObjCRequiresPropertyDefs();
3024 ClsMap.insert(I->getSelector());
3031 IncompleteImpl,
true);
3036 dyn_cast<ObjCCategoryImplDecl>(IMPDecl))
3047 for (
auto *PI : I->all_referenced_protocols())
3049 ClsMap, I, ExplicitImplProtocols);
3053 if (!
C->IsClassExtension()) {
3054 for (
auto *
P :
C->protocols())
3056 ClsMap, CDecl, ExplicitImplProtocols);
3061 llvm_unreachable(
"invalid ObjCContainerDecl type.");
3071 for (
unsigned i = 0; i != NumElts; ++i) {
3076 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
3086 Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i];
3094 Diag(AtClassLoc, diag::warn_forward_class_redefinition)
3104 = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
3126 if (PrevIDecl && TypeParams) {
3130 *
this, PrevTypeParams, TypeParams,
3131 TypeParamListContext::ForwardDeclaration)) {
3132 TypeParams =
nullptr;
3136 Diag(IdentLocs[i], diag::err_objc_parameterized_forward_class)
3139 Diag(Def->getLocation(), diag::note_defined_here)
3142 TypeParams =
nullptr;
3148 ClassName, TypeParams, PrevIDecl,
3157 DeclsInGroup.push_back(IDecl);
3165 const Type *left,
const Type *right);
3174 if (left == right)
return true;
3197 if (isa<VectorType>(left))
return isa<VectorType>(right);
3198 if (isa<VectorType>(right))
return false;
3221 return (leftSK == rightSK);
3227 assert(lt && rt && lt != rt);
3229 if (!isa<RecordType>(lt) || !isa<RecordType>(rt))
return false;
3230 RecordDecl *left = cast<RecordType>(lt)->getDecl();
3231 RecordDecl *right = cast<RecordType>(rt)->getDecl();
3237 if ((isa<CXXRecordDecl>(left) && !cast<CXXRecordDecl>(left)->isPOD()) ||
3238 (isa<CXXRecordDecl>(right) && !cast<CXXRecordDecl>(right)->isPOD()))
3253 for (; li != le && ri != re; ++li, ++ri) {
3254 if (!
matchTypes(Context, strategy, li->getType(), ri->getType()))
3257 return (li == le && ri == re);
3278 (left->
hasAttr<NSReturnsRetainedAttr>()
3279 != right->
hasAttr<NSReturnsRetainedAttr>() ||
3280 left->
hasAttr<NSConsumesSelfAttr>()
3281 != right->
hasAttr<NSConsumesSelfAttr>()))
3288 for (; li != le && ri != re; ++li, ++ri) {
3289 assert(ri != right->
param_end() &&
"Param mismatch");
3296 lparm->
hasAttr<NSConsumedAttr>() != rparm->hasAttr<NSConsumedAttr>())
3304 auto *MethodProtocol = dyn_cast<ObjCProtocolDecl>(Method->
getDeclContext());
3305 auto *MethodInListProtocol =
3309 if ((MethodProtocol && !MethodInListProtocol) ||
3310 (!MethodProtocol && MethodInListProtocol))
3313 if (MethodProtocol && MethodInListProtocol)
3319 return MethodInterface == MethodInListInterface;
3328 if (!CD->IsClassExtension() && List->getBits() < 2)
3329 List->setBits(List->getBits() + 1);
3332 if (List->getMethod() ==
nullptr) {
3333 List->setMethod(Method);
3334 List->setNext(
nullptr);
3342 for (; List;
Previous = List, List = List->getNext()) {
3359 if (!SameDeclaration ||
3365 List->setHasMoreThanOneDecl(
true);
3370 !ListWithSameDeclaration && !List->getMethod()->isDeprecated())
3371 ListWithSameDeclaration = List;
3374 !ListWithSameDeclaration &&
3376 ListWithSameDeclaration = List;
3390 List->setHasMoreThanOneDecl(
true);
3397 List->setMethod(Method);
3403 List->setMethod(Method);
3414 if (ListWithSameDeclaration) {
3417 ListWithSameDeclaration->
setMethod(Method);
3418 ListWithSameDeclaration->
setNext(List);
3438void Sema::AddMethodToGlobalPool(
ObjCMethodDecl *Method,
bool impl,
3456 ObjCMethodList &Entry = instance ? Pos->second.first : Pos->second.second;
3493 assert(BoundInterface &&
"unexpected object type!");
3497 auto *MethodProtocol = dyn_cast<ObjCProtocolDecl>(Method->
getDeclContext());
3498 if (MethodProtocol) {
3508 return MethodInterface == BoundInterface ||
3509 MethodInterface->isSuperClassOf(BoundInterface) ||
3510 BoundInterface->isSuperClassOf(MethodInterface);
3512 llvm_unreachable(
"unknown method context");
3519 bool InstanceFirst,
bool CheckTheOther,
3532 if (M->getMethod() && M->getMethod()->isUnconditionallyVisible()) {
3534 Methods.push_back(M->getMethod());
3538 if (!Methods.empty())
3539 return Methods.size() > 1;
3548 if (M->getMethod() && M->getMethod()->isUnconditionallyVisible()) {
3550 Methods.push_back(M->getMethod());
3553 return Methods.size() > 1;
3561 FilteredMethods.push_back(BestMethod);
3563 for (
auto *M : Methods)
3564 if (M != BestMethod && !M->
hasAttr<UnavailableAttr>())
3565 FilteredMethods.push_back(M);
3567 if (FilteredMethods.size() > 1)
3582 bool receiverIdOrClass,
3592 ObjCMethodList &MethList = instance ? Pos->second.first : Pos->second.second;
3595 if (M->getMethod() && M->getMethod()->isUnconditionallyVisible())
3596 return M->getMethod();
3603 bool receiverIdOrClass) {
3605 bool issueDiagnostic =
false, issueError =
false;
3609 bool strictSelectorMatch =
3610 receiverIdOrClass &&
3612 if (strictSelectorMatch) {
3613 for (
unsigned I = 1, N = Methods.size(); I != N; ++I) {
3615 issueDiagnostic =
true;
3624 if (!strictSelectorMatch ||
3625 (issueDiagnostic &&
getLangOpts().ObjCAutoRefCount))
3626 for (
unsigned I = 1, N = Methods.size(); I != N; ++I) {
3630 issueDiagnostic =
true;
3637 if (issueDiagnostic) {
3639 Diag(R.
getBegin(), diag::err_arc_multiple_method_decl) << Sel << R;
3640 else if (strictSelectorMatch)
3641 Diag(R.getBegin(), diag::warn_strict_multiple_method_decl) << Sel << R;
3643 Diag(R.getBegin(), diag::warn_multiple_method_decl) << Sel << R;
3645 Diag(Methods[0]->getBeginLoc(),
3646 issueError ? diag::note_possibility : diag::note_using)
3647 << Methods[0]->getSourceRange();
3648 for (
unsigned I = 1, N = Methods.size(); I != N; ++I) {
3649 Diag(Methods[I]->getBeginLoc(), diag::note_also_found)
3650 << Methods[I]->getSourceRange();
3662 Method = Method->getNext())
3663 if (Method->getMethod() &&
3666 return Method->getMethod();
3669 Method = Method->getNext())
3670 if (Method->getMethod() &&
3673 return Method->getMethod();
3681 const unsigned MaxEditDistance = 1;
3682 unsigned BestEditDistance = MaxEditDistance + 1;
3685 unsigned MinPossibleEditDistance =
abs((
int)MethodName.size() - (
int)Typo.size());
3686 if (MinPossibleEditDistance > 0 &&
3687 Typo.size() / MinPossibleEditDistance < 1)
3689 unsigned EditDistance = Typo.edit_distance(MethodName,
true, MaxEditDistance);
3690 if (EditDistance > MaxEditDistance)
3692 if (EditDistance == BestEditDistance)
3693 BestMethod.push_back(Method);
3694 else if (EditDistance < BestEditDistance) {
3696 BestMethod.push_back(Method);
3715 bool ObjectIsId =
true, ObjectIsClass =
true;
3717 ObjectIsId = ObjectIsClass =
false;
3722 ObjectType =
QualType(ObjCPtr->getInterfaceType(), 0);
3723 ObjectIsId = ObjectIsClass =
false;
3726 ObjectIsClass =
false;
3736 if (M->getMethod() &&
3737 (M->getMethod()->getSelector().getNumArgs() == NumArgs) &&
3738 (M->getMethod()->getSelector() != Sel)) {
3740 Methods.push_back(M->getMethod());
3741 else if (!ObjectIsClass &&
3744 Methods.push_back(M->getMethod());
3748 if (M->getMethod() &&
3749 (M->getMethod()->getSelector().getNumArgs() == NumArgs) &&
3750 (M->getMethod()->getSelector() != Sel)) {
3752 Methods.push_back(M->getMethod());
3753 else if (!ObjectIsId &&
3756 Methods.push_back(M->getMethod());
3761 for (
unsigned i = 0, e = Methods.size(); i < e; i++) {
3765 return (SelectedMethods.size() == 1) ? SelectedMethods[0] :
nullptr;
3775 for (
auto *Ivar : ID->ivars()) {
3776 if (Ivar->isInvalidDecl())
3781 Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
3783 Ivar->setInvalidDecl();
3793 for (
auto ivar = ID->getClassInterface()->all_declared_ivar_begin();
3794 ivar; ivar = ivar->getNextIvar()) {
3795 if (ivar->isInvalidDecl())
continue;
3798 S.
Diag(ivar->getLocation(), diag::err_arc_weak_disabled);
3800 S.
Diag(ivar->getLocation(), diag::err_arc_weak_no_runtime);
3812 for (
auto ivar = ID->all_declared_ivar_begin(); ivar;
3813 ivar = ivar->getNextIvar()) {
3814 if (ivar->isInvalidDecl())
3820 S.
Diag(ivar->getLocation(), diag::err_flexible_array_arc_retainable);
3821 ivar->setInvalidDecl();
3828 case Decl::ObjCInterface:
3830 case Decl::ObjCProtocol:
3832 case Decl::ObjCCategory:
3833 if (cast<ObjCCategoryDecl>(
CurContext)->IsClassExtension())
3836 case Decl::ObjCImplementation:
3838 case Decl::ObjCCategoryImpl:
3850 return (RecordTy && RecordTy->getDecl()->hasFlexibleArrayMember());
3857 if ((IntfDecl = dyn_cast<ObjCInterfaceDecl>(OCD))) {
3858 Ivars = IntfDecl->
ivars();
3859 }
else if (
auto *ImplDecl = dyn_cast<ObjCImplementationDecl>(OCD)) {
3860 IntfDecl = ImplDecl->getClassInterface();
3861 Ivars = ImplDecl->
ivars();
3862 }
else if (
auto *CategoryDecl = dyn_cast<ObjCCategoryDecl>(OCD)) {
3863 if (CategoryDecl->IsClassExtension()) {
3864 IntfDecl = CategoryDecl->getClassInterface();
3865 Ivars = CategoryDecl->
ivars();
3870 if (!isa<ObjCInterfaceDecl>(OCD)) {
3871 for (
auto *ivar : Ivars) {
3873 S.
Diag(ivar->getLocation(), diag::warn_variable_sized_ivar_visibility)
3874 << ivar->getDeclName() << ivar->getType();
3886 if (ivar->isInvalidDecl() || !ivar->getNextIvar())
3889 bool IsInvalidIvar =
false;
3891 S.
Diag(ivar->getLocation(), diag::err_flexible_array_not_at_end)
3892 << ivar->getDeclName() << IvarTy
3894 IsInvalidIvar =
true;
3896 if (RecordTy->getDecl()->hasFlexibleArrayMember()) {
3897 S.
Diag(ivar->getLocation(),
3898 diag::err_objc_variable_sized_type_not_at_end)
3899 << ivar->getDeclName() << IvarTy;
3900 IsInvalidIvar =
true;
3903 if (IsInvalidIvar) {
3904 S.
Diag(ivar->getNextIvar()->getLocation(),
3905 diag::note_next_ivar_declaration)
3906 << ivar->getNextIvar()->getSynthesize();
3907 ivar->setInvalidDecl();
3915 (Ivars.begin() == Ivars.end()) ?
nullptr : *Ivars.begin();
3918 while (SuperClass && SuperClass->
ivar_empty())
3922 std::advance(IvarIter, SuperClass->
ivar_size() - 1);
3926 diag::warn_superclass_variable_sized_type_not_at_end)
3941 const llvm::iterator_range<ObjCProtocolList::iterator> &Protocols) {
3942 for (
auto *PI : Protocols)
3953 for (
auto *MD : PDecl->
methods()) {
3954 if (!MD->isPropertyAccessor()) {
3955 if (
const auto *CMD =
3956 IDecl->getMethod(MD->getSelector(), MD->isInstanceMethod())) {
3957 if (CMD->isDirectMethod())
3958 DirectMembers.push_back(CMD);
3963 if (
const auto *CPD = IDecl->FindPropertyVisibleInPrimaryClass(
3964 PD->getIdentifier(),
3965 PD->isClassProperty()
3968 if (CPD->isDirectProperty())
3969 DirectMembers.push_back(CPD);
3972 if (!DirectMembers.empty()) {
3973 S.
Diag(CDecl->
getLocation(), diag::err_objc_direct_protocol_conformance)
3975 for (
const auto *MD : DirectMembers)
3976 S.
Diag(MD->getLocation(), diag::note_direct_member_here);
3991 assert(AtEnd.
isValid() &&
"Invalid location for '@end'");
3993 auto *OCD = cast<ObjCContainerDecl>(
CurContext);
3994 Decl *ClassDecl = OCD;
3996 bool isInterfaceDeclKind =
3997 isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl)
3998 || isa<ObjCProtocolDecl>(ClassDecl);
3999 bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl);
4005 if (
auto *OID = dyn_cast<ObjCImplementationDecl>(
CurContext)) {
4006 for (
auto *PropImpl : OID->property_impls()) {
4007 if (
auto *Getter = PropImpl->getGetterMethodDecl())
4008 if (Getter->isSynthesizedAccessorStub())
4009 OID->addDecl(Getter);
4010 if (
auto *Setter = PropImpl->getSetterMethodDecl())
4011 if (Setter->isSynthesizedAccessorStub())
4012 OID->addDecl(Setter);
4017 llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
4018 llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;
4020 for (
unsigned i = 0, e = allMethods.size(); i != e; i++ ) {
4022 cast_or_null<ObjCMethodDecl>(allMethods[i]);
4024 if (!Method)
continue;
4030 if ((isInterfaceDeclKind && PrevMethod && !
match)
4031 || (checkIdenticalMethods &&
match)) {
4054 if ((isInterfaceDeclKind && PrevMethod && !
match)
4055 || (checkIdenticalMethods &&
match)) {
4074 if (isa<ObjCInterfaceDecl>(ClassDecl)) {
4081 if (
C->IsClassExtension()) {
4089 if (CDecl->getIdentifier())
4093 for (
auto *I : CDecl->properties())
4095 CDecl->setAtEndRange(AtEnd);
4098 IC->setAtEndRange(AtEnd);
4105 for (
const auto *Ext : IDecl->visible_extensions()) {
4106 for (
const auto *
Property : Ext->instance_properties()) {
4109 = IC->FindPropertyImplDecl(
Property->getIdentifier(),
4111 if (PIDecl->getPropertyImplementation()
4115 for (
const auto *Ext : IDecl->visible_extensions()) {
4117 Ext->getInstanceMethod(
Property->getGetterName()))
4118 GetterMethod->setPropertyAccessor(
true);
4121 = Ext->getInstanceMethod(
Property->getSetterName()))
4122 SetterMethod->setPropertyAccessor(
true);
4130 if (IDecl->hasDesignatedInitializers())
4135 bool HasRootClassAttr = IDecl->hasAttr<ObjCRootClassAttr>();
4136 if (IDecl->getSuperClass() ==
nullptr) {
4139 if (!HasRootClassAttr) {
4142 Diag(DeclLoc, diag::warn_objc_root_class_missing)
4143 << IDecl->getIdentifier();
4151 Diag(SuperClassLoc, diag::note_objc_needs_superclass)
4154 Diag(SuperClassLoc, diag::note_objc_needs_superclass);
4157 }
else if (HasRootClassAttr) {
4159 Diag(IDecl->getLocation(), diag::err_objc_root_class_subclass);
4167 if (IDecl->hasAttr<ObjCSubclassingRestrictedAttr>() &&
4168 Super->hasAttr<ObjCSubclassingRestrictedAttr>()) {
4169 Diag(IC->getLocation(), diag::err_restricted_superclass_mismatch);
4170 Diag(Super->getLocation(), diag::note_class_declared);
4174 if (IDecl->hasAttr<ObjCClassStubAttr>())
4175 Diag(IC->getLocation(), diag::err_implementation_of_class_stub);
4178 while (IDecl->getSuperClass()) {
4180 IDecl = IDecl->getSuperClass();
4186 dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {
4187 CatImplClass->setAtEndRange(AtEnd);
4193 = IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier())) {
4197 }
else if (
const auto *IntfDecl = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
4199 if (!IntfDecl->hasAttr<ObjCSubclassingRestrictedAttr>() &&
4200 Super->hasAttr<ObjCSubclassingRestrictedAttr>()) {
4201 Diag(IntfDecl->getLocation(), diag::err_restricted_superclass_mismatch);
4202 Diag(Super->getLocation(), diag::note_class_declared);
4206 if (IntfDecl->hasAttr<ObjCClassStubAttr>() &&
4207 !IntfDecl->hasAttr<ObjCSubclassingRestrictedAttr>())
4208 Diag(IntfDecl->getLocation(), diag::err_class_stub_subclassing_mismatch);
4211 if (isInterfaceDeclKind) {
4213 for (
unsigned i = 0, e = allTUVars.size(); i != e; i++) {
4216 if (
VarDecl *VDecl = dyn_cast<VarDecl>(*I)) {
4217 if (!VDecl->hasExternalStorage())
4218 Diag(VDecl->getLocation(), diag::err_objc_var_decl_inclass);
4224 for (
unsigned i = 0, e = allTUVars.size(); i != e; i++) {
4227 (*I)->setTopLevelDeclInObjCContainer();
4256 if (ResultObjectType->isObjCIdType() ||
4257 ResultObjectType->isObjCQualifiedIdType())
4262 = ResultObjectType->getInterfaceDecl()) {
4268 if (ResultClass->isSuperClassOf(CurrentClass))
4284class OverrideSearch {
4316 dyn_cast<ObjCCategoryDecl>(container)) {
4317 searchFromContainer(container);
4321 searchFromContainer(container);
4325 typedef decltype(Overridden)::iterator iterator;
4326 iterator begin()
const {
return Overridden.begin(); }
4327 iterator end()
const {
return Overridden.end(); }
4334#define OBJCCONTAINER(type, base) \
4336 searchFrom(cast<type##Decl>(container)); \
4338#define ABSTRACT_DECL(expansion)
4339#define DECL(type, base) \
4341#include "clang/AST/DeclNodes.inc"
4342 llvm_unreachable(
"not an ObjC container!");
4402 for (
const auto *Proto : protocols)
4414 Overridden.insert(meth);
4424 searchFromContainer(container);
4432 const auto *
attr = overridden->
getAttr<ObjCDirectAttr>();
4434 Diag(
attr->getLocation(), diag::note_previous_declaration);
4436 const auto *
attr = method->
getAttr<ObjCDirectAttr>();
4437 Diag(
attr->getLocation(), diag::err_objc_direct_on_override)
4448 auto IsMethodInCurrentClass = [CurrentClass](
const ObjCMethodDecl *M) {
4450 return M->getClassInterface()->getCanonicalDecl() ==
4454 OverrideSearch overrides(*
this, ObjCMethod);
4460 bool hasOverriddenMethodsInBaseOrProtocol =
false;
4462 if (!hasOverriddenMethodsInBaseOrProtocol) {
4463 if (isa<ObjCProtocolDecl>(overridden->getDeclContext()) ||
4464 !IsMethodInCurrentClass(overridden) || overridden->isOverriding()) {
4466 hasOverriddenMethodsInBaseOrProtocol =
true;
4480 unsigned CategCount = List.getBits();
4481 if (CategCount > 0) {
4484 if (CategCount > 1 ||
4485 !isa<ObjCCategoryImplDecl>(overridden->getDeclContext())) {
4486 OverrideSearch overrides(*
this, overridden);
4488 if (isa<ObjCProtocolDecl>(SuperOverridden->getDeclContext()) ||
4489 !IsMethodInCurrentClass(SuperOverridden)) {
4491 hasOverriddenMethodsInBaseOrProtocol =
true;
4492 overridden->setOverriding(
true);
4509 if (ObjCMethod->
isImplicit() && overridden->isImplicit())
4516 isa<ObjCProtocolDecl>(overridden->getDeclContext()));
4518 if (CurrentClass && overridden->
getDeclContext() != CurrentClass &&
4519 isa<ObjCInterfaceDecl>(overridden->getDeclContext()) &&
4524 PrevE = overridden->param_end();
4525 for (; ParamI != E && PrevI != PrevE; ++ParamI, ++PrevI) {
4526 assert(PrevI != overridden->param_end() &&
"Param mismatch");
4532 Diag((*ParamI)->getLocation(), diag::ext_typecheck_base_super)
4534 Diag(overridden->getLocation(), diag::note_previous_declaration);
4541 ObjCMethod->
setOverriding(hasOverriddenMethodsInBaseOrProtocol);
4551 bool prevUsesCSKeyword) {
4553 auto nullability =
type->getNullability();
4557 if (nullability.has_value() == prevNullability.has_value()) {
4563 if (*nullability == *prevNullability)
4567 S.
Diag(loc, diag::err_nullability_conflicting)
4590 if (prevMethod->
hasAttr<ObjCRequiresSuperAttr>() &&
4591 !method->
hasAttr<ObjCRequiresSuperAttr>()) {
4594 ObjCRequiresSuperAttr::CreateImplicit(S.
Context,
4611 unsigned numPrevParams = prevMethod->
param_size();
4612 for (
unsigned i = 0, n = std::min(numParams, numPrevParams); i != n; ++i) {
4632 llvm::Triple::x86 &&
4633 "x86-specific check invoked for a different target");
4637 if (
P->getType()->isVectorType()) {
4638 Loc =
P->getBeginLoc();
4654 VersionTuple AcceptedInVersion;
4655 if (Triple.getOS() == llvm::Triple::IOS)
4656 AcceptedInVersion = VersionTuple(9);
4657 else if (Triple.isMacOSX())
4658 AcceptedInVersion = VersionTuple(10, 11);
4664 SemaRef.
Diag(Loc, diag::err_objc_method_unsupported_param_ret_type)
4667 << (Triple.isMacOSX() ?
"macOS 10.11" :
"iOS 9");
4672 CD->
hasAttr<ObjCDirectMembersAttr>()) {
4683 bool diagnosed =
false;
4686 if (diagnosed || IMD->isImplicit())
4692 S.
Diag(IMD->getLocation(), diag::note_previous_declaration);
4710 if (
auto *IMD = IDecl->
getMethod(Sel, isInstance))
4713 if (Impl != ImpDecl)
4718 if (
auto *IMD = Cat->getMethod(Sel, isInstance))
4720 else if (
auto CatImpl = Cat->getImplementation())
4721 if (CatImpl != ImpDecl)
4722 if (
auto *IMD = Cat->getMethod(Sel, isInstance))
4735 bool isVariadic,
bool MethodDefinition) {
4738 Diag(MethodLoc, diag::err_missing_method_context);
4745 bool HasRelatedResultType =
false;
4753 QualType bareResultType = resultDeclType;
4758 Diag(MethodLoc, diag::warn_missing_method_return_type)
4764 MethodType == tok::minus, isVariadic,
4767 MethodDeclKind == tok::objc_optional
4770 HasRelatedResultType);
4774 for (
unsigned i = 0, e = Sel.
getNumArgs(); i != e; ++i) {
4778 if (!ArgInfo[i].
Type) {
4785 LookupResult R(*
this, ArgInfo[i].Name, ArgInfo[i].NameLoc,
4790 if (S->isDeclScope(PrevDecl)) {
4791 Diag(ArgInfo[i].NameLoc,
4792 (MethodDefinition ? diag::warn_method_param_redefinition
4793 : diag::warn_method_param_declaration))
4796 diag::note_previous_declaration);
4805 ArgInfo[i].NameLoc, ArgInfo[i].Name,
4818 if (Param->
hasAttr<BlocksAttr>()) {
4825 Params.push_back(Param);
4828 for (
unsigned i = 0, e = CNumArgs; i != e; ++i) {
4829 ParmVarDecl *Param = cast<ParmVarDecl>(CParamInfo[i].Param);
4838 Params.push_back(Param);
4851 if (
ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(ClassDecl)) {
4852 if (MethodType == tok::minus) {
4853 PrevMethod = ImpDecl->getInstanceMethod(Sel);
4854 ImpDecl->addInstanceMethod(ObjCMethod);
4856 PrevMethod = ImpDecl->getClassMethod(Sel);
4857 ImpDecl->addClassMethod(ObjCMethod);
4866 if (
auto *Setter = PropertyImpl->getSetterMethodDecl())
4867 if (Setter->getSelector() == Sel &&
4869 assert(Setter->isSynthesizedAccessorStub() &&
"autosynth stub expected");
4870 PropertyImpl->setSetterMethodDecl(ObjCMethod);
4872 if (
auto *Getter = PropertyImpl->getGetterMethodDecl())
4873 if (Getter->getSelector() == Sel &&
4875 assert(Getter->isSynthesizedAccessorStub() &&
"autosynth stub expected");
4876 PropertyImpl->setGetterMethodDecl(ObjCMethod);
4890 const auto *
attr = CanonicalMD->
getAttr<ObjCDirectAttr>();
4892 ObjCDirectAttr::CreateImplicit(
Context,
attr->getLocation()));
4899 if (
auto *IMD = IDecl->lookupMethod(ObjCMethod->
getSelector(),
4919 if (IDecl == IMD->getClassInterface()) {
4920 auto diagContainerMismatch = [&] {
4921 int decl = 0, impl = 0;
4923 if (
auto *Cat = dyn_cast<ObjCCategoryDecl>(IMD->getDeclContext()))
4924 decl = Cat->IsClassExtension() ? 1 : 2;
4926 if (isa<ObjCCategoryImplDecl>(ImpDecl))
4927 impl = 1 + (
decl != 0);
4930 diag::err_objc_direct_impl_decl_mismatch)
4932 Diag(IMD->getLocation(), diag::note_previous_declaration);
4936 const auto *
attr = ObjCMethod->
getAttr<ObjCDirectAttr>();
4938 diagContainerMismatch();
4939 }
else if (!IMD->isDirectMethod()) {
4940 Diag(
attr->getLocation(), diag::err_objc_direct_missing_on_decl);
4941 Diag(IMD->getLocation(), diag::note_previous_declaration);
4943 }
else if (IMD->isDirectMethod()) {
4944 const auto *
attr = IMD->getAttr<ObjCDirectAttr>();
4946 diagContainerMismatch();
4949 ObjCDirectAttr::CreateImplicit(
Context,
attr->getLocation()));
4955 if (isa<ObjCCategoryImplDecl>(ImpDecl) && IMD->isOverriding() &&
4968 for (
auto *
C : IDecl->visible_categories())
4969 for (
auto &
P :
C->protocols())
4970 if (
auto *IMD =
P->lookupMethod(ObjCMethod->
getSelector(),
4973 IMD->parameters().size() &&
4974 "Methods have different number of parameters");
4975 auto OI = IMD->param_begin(), OE = IMD->param_end();
4977 for (; OI != OE; ++OI, ++NI)
4982 if (!isa<ObjCProtocolDecl>(ClassDecl)) {
4987 IDecl = cast<ObjCCategoryDecl>(ClassDecl)->getClassInterface();
4995 cast<DeclContext>(ClassDecl)->addDecl(ObjCMethod);
5011 if (!CurrentClass) {
5013 CurrentClass = Cat->getClassInterface();
5014 else if (
ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(ClassDecl))
5015 CurrentClass = Impl->getClassInterface();
5017 = dyn_cast<ObjCCategoryImplDecl>(ClassDecl))
5018 CurrentClass = CatImpl->getClassInterface();
5026 bool ARCError =
false;
5033 LangOpts.ObjCInferRelatedResultType) {
5034 bool InferRelatedResultType =
false;
5060 if (InferRelatedResultType &&
5065 if (MethodDefinition &&
5071 if (
const auto *
attr = ObjCMethod->
getAttr<AvailabilityAttr>()) {
5074 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
5076 ObjCMethod->
dropAttr<AvailabilityAttr>();
5099 Diag(D->
getLocation(), diag::err_objc_decls_may_only_appear_in_global_scope);
5113 Diag(DeclStart, diag::err_undef_interface) << ClassName;
5117 Diag(DeclStart, diag::err_atdef_nonfragile_interface);
5125 for (
unsigned i = 0; i < Ivars.size(); i++) {
5131 ID->getIdentifier(), ID->getType(),
5133 Decls.push_back(FD);
5138 D != Decls.end(); ++D) {
5158 Diag(IdLoc, diag::err_arg_with_address_space);
5170 Diag(IdLoc, diag::err_illegal_qualifiers_on_catch_parm);
5175 Diag(IdLoc, diag::err_catch_param_not_objc_type);
5178 Diag(IdLoc, diag::err_catch_param_not_objc_type);
5211 diag::err_invalid_thread)
5245 if (New->
hasAttr<BlocksAttr>())
5258 Ivars.push_back(Iv);
5267 for (
unsigned I = 0, N = Sels.size(); I != N; ++I)
5278 Selector Sel = SelectorAndLocation.first;
5281 Diag(Loc, diag::warn_unimplemented_selector) << Sel;
5304 IV->getIdentifier());
5313 class UnusedBackingIvarChecker :
5320 bool InvokedSelfMethod;
5324 : S(S), Method(Method), IvarD(IvarD),
5325 AccessedIvar(
false), InvokedSelfMethod(
false) {
5331 AccessedIvar =
true;
5340 InvokedSelfMethod =
true;
5349 if (S->hasUnrecoverableErrorOccurred())
5353 unsigned DIAG = diag::warn_unused_property_backing_ivar;
5363 if (CurMethod->isSynthesizedAccessorStub())
5366 UnusedBackingIvarChecker Checker(*
this, CurMethod, IV);
5367 Checker.TraverseStmt(CurMethod->getBody());
5368 if (Checker.AccessedIvar)
5375 if (!IV->
isReferenced() || !Checker.InvokedSelfMethod) {
Defines the clang::ASTContext interface.
#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, SHOWINSYSHEADER, SHOWINSYSMACRO, DEFERRABLE, CATEGORY)
static QualType getObjectType(APValue::LValueBase B)
Retrieves the "underlying object type" of the given expression, as used by __builtin_object_size.
llvm::MachO::Record Record
static bool IsVariableSizedType(QualType T)
static void DiagnoseVariableSizedIvars(Sema &S, ObjCContainerDecl *OCD)
static bool HasExplicitOwnershipAttr(Sema &S, ParmVarDecl *Param)
HasExplicitOwnershipAttr - returns true when pointer to ObjC pointer has explicit ownership attribute...
static void checkObjCDirectMethodClashes(Sema &S, ObjCInterfaceDecl *IDecl, ObjCMethodDecl *Method, ObjCImplDecl *ImpDecl=nullptr)
static bool CheckMethodOverrideParam(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, ParmVarDecl *ImplVar, ParmVarDecl *IfaceVar, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn)
static SourceRange getTypeRange(TypeSourceInfo *TSI)
std::unique_ptr< ProtocolNameSet > LazyProtocolNameSet
static bool CheckMethodOverrideReturn(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn)
static void DiagnoseCategoryDirectMembersProtocolConformance(Sema &S, ObjCProtocolDecl *PDecl, ObjCCategoryDecl *CDecl)
static bool checkTypeParamListConsistency(Sema &S, ObjCTypeParamList *prevTypeParams, ObjCTypeParamList *newTypeParams, TypeParamListContext newContext)
Check consistency between two Objective-C type parameter lists, e.g., between a category/extension an...
static bool tryMatchRecordTypes(ASTContext &Context, Sema::MethodMatchStrategy strategy, const Type *left, const Type *right)
static void HelperSelectorsForTypoCorrection(SmallVectorImpl< const ObjCMethodDecl * > &BestMethod, StringRef Typo, const ObjCMethodDecl *Method)
static bool objcModifiersConflict(Decl::ObjCDeclQualifier x, Decl::ObjCDeclQualifier y)
Determine whether two set of Objective-C declaration qualifiers conflict.
static bool shouldWarnUndefinedMethod(const ObjCMethodDecl *M)
static bool FilterMethodsByTypeBound(ObjCMethodDecl *Method, const ObjCObjectType *TypeBound)
Return true if the given method is wthin the type bound.
static void DiagnoseObjCImplementedDeprecations(Sema &S, const NamedDecl *ND, SourceLocation ImplLoc)
static void findProtocolsWithExplicitImpls(const ObjCProtocolDecl *PDecl, ProtocolNameSet &PNS)
static bool matchTypes(ASTContext &Context, Sema::MethodMatchStrategy strategy, QualType leftQT, QualType rightQT)
static void DiagnoseRetainableFlexibleArrayMember(Sema &S, ObjCInterfaceDecl *ID)
Diagnose attempts to use flexible array member with retainable object type.
static void mergeInterfaceMethodToImpl(Sema &S, ObjCMethodDecl *method, ObjCMethodDecl *prevMethod)
Merge information from the declaration of a method in the @interface (or a category/extension) into t...
static bool HelperIsMethodInObjCType(Sema &S, Selector Sel, QualType ObjectType)
static void CheckProtocolMethodDefs(Sema &S, ObjCImplDecl *Impl, ObjCProtocolDecl *PDecl, bool &IncompleteImpl, const Sema::SelectorSet &InsMap, const Sema::SelectorSet &ClsMap, ObjCContainerDecl *CDecl, LazyProtocolNameSet &ProtocolsExplictImpl)
CheckProtocolMethodDefs - This routine checks unimplemented methods Declared in protocol,...
static void WarnUndefinedMethod(Sema &S, ObjCImplDecl *Impl, ObjCMethodDecl *method, bool &IncompleteImpl, unsigned DiagID, NamedDecl *NeededFor=nullptr)
static bool NestedProtocolHasNoDefinition(ObjCProtocolDecl *PDecl, ObjCProtocolDecl *&UndefinedProtocol)
static bool isObjCTypeSubstitutable(ASTContext &Context, const ObjCObjectPointerType *A, const ObjCObjectPointerType *B, bool rejectId)
Determines if type B can be substituted for type A.
llvm::DenseSet< IdentifierInfo * > ProtocolNameSet
FIXME: Type hierarchies in Objective-C can be deep.
static QualType mergeTypeNullabilityForRedecl(Sema &S, SourceLocation loc, QualType type, bool usesCSKeyword, SourceLocation prevLoc, QualType prevType, bool prevUsesCSKeyword)
Merge type nullability from for a redeclaration of the same entity, producing the updated type of the...
static bool diagnoseNoescape(const ParmVarDecl *NewD, const ParmVarDecl *OldD, Sema &S)
Issue a warning if the parameter of the overridden method is non-escaping but the parameter of the ov...
static bool isAcceptableMethodMismatch(ObjCMethodDecl *chosen, ObjCMethodDecl *other)
Determines if this is an "acceptable" loose mismatch in the global method pool.
static void mergeObjCDirectMembers(Sema &S, Decl *CD, ObjCMethodDecl *Method)
static void DiagnoseWeakIvars(Sema &S, ObjCImplementationDecl *ID)
Diagnose attempts to define ARC-__weak ivars when __weak is disabled.
static void checkObjCMethodX86VectorTypes(Sema &SemaRef, const ObjCMethodDecl *Method)
Verify that the method parameters/return value have types that are supported by the x86 target.
static bool checkMethodFamilyMismatch(Sema &S, ObjCMethodDecl *impl, ObjCMethodDecl *decl)
In ARC, check whether the conventional meanings of the two methods match.
static bool isMethodContextSameForKindofLookup(ObjCMethodDecl *Method, ObjCMethodDecl *MethodInList)
static Sema::ResultTypeCompatibilityKind CheckRelatedResultTypeCompatibility(Sema &S, ObjCMethodDecl *Method, ObjCInterfaceDecl *CurrentClass)
Check whether the declared result type of the given Objective-C method declaration is compatible with...
static Decl::ObjCDeclQualifier CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal)
CvtQTToAstBitMask - utility routine to produce an AST bitmask for objective-c's type qualifier from t...
static void diagnoseUseOfProtocols(Sema &TheSema, ObjCContainerDecl *CD, ObjCProtocolDecl *const *ProtoRefs, unsigned NumProtoRefs, const SourceLocation *ProtoLocs)
Defines the SourceManager interface.
__DEVICE__ long long abs(long long __n)
virtual void HandleTopLevelDeclInObjCContainer(DeclGroupRef D)
Handle the specified top-level declaration that occurred inside and ObjC container.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
SourceManager & getSourceManager()
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
bool AnyObjCImplementation()
Return true if there is at least one @implementation in the TU.
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
void adjustObjCTypeParamBoundType(const ObjCTypeParamDecl *Orig, ObjCTypeParamDecl *New) const
bool ObjCQualifiedIdTypesAreCompatible(const ObjCObjectPointerType *LHS, const ObjCObjectPointerType *RHS, bool ForCompare)
ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an ObjCQualifiedIDType.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
const LangOptions & getLangOpts() const
SelectorTable & Selectors
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
void DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, bool leafClass, SmallVectorImpl< const ObjCIvarDecl * > &Ivars) const
DeepCollectObjCIvars - This routine first collects all declared, but not synthesized,...
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
const clang::PrintingPolicy & getPrintingPolicy() const
QualType getObjCIdType() const
Represents the Objective-CC id type.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
const TargetInfo & getTargetInfo() const
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
bool hasSameNullabilityTypeQualifier(QualType SubT, QualType SuperT, bool IsParam) const
void CollectInheritedProtocols(const Decl *CDecl, llvm::SmallPtrSet< ObjCProtocolDecl *, 8 > &Protocols)
CollectInheritedProtocols - Collect all protocols in current class and those inherited by it.
The result of parsing/analyzing an expression, statement etc.
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
Type source information for an attributed type.
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
static std::optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
SourceRange getRange() const
bool isSet() const
Deprecated.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
bool isFileContext() const
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
bool isObjCContainer() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDecl(Decl *D)
Add the declaration D into this context.
Decl::Kind getDeclKind() const
Simple template class for restricting typo correction candidates to ones having a single Decl* of the...
Captures information about "declaration specifiers".
static const TST TST_typename
void ClearStorageClassSpecs()
SourceLocation getStorageClassSpecLoc() const
SCS getStorageClassSpec() const
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
void SetRangeEnd(SourceLocation Loc)
void SetRangeStart(SourceLocation Loc)
SCS
storage-class-specifier
TSCS getThreadStorageClassSpec() const
bool isInlineSpecified() const
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
SourceLocation getThreadStorageClassSpecLoc() const
SourceLocation getInlineSpecLoc() const
Decl - This represents one declaration (or definition), e.g.
SourceLocation getEndLoc() const LLVM_READONLY
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked 'unavailable'.
AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple(), StringRef *RealizedPlatform=nullptr) const
Determine the availability of the given declaration.
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
bool isUnconditionallyVisible() const
Determine whether this declaration is definitely visible to name lookup, independent of whether the o...
void setTopLevelDeclInObjCContainer(bool V=true)
bool isReferenced() const
Whether any declaration of this entity was referenced.
ObjCDeclQualifier
ObjCDeclQualifier - 'Qualifiers' written next to the return and parameter types in method declaration...
@ OBJC_TQ_CSNullability
The nullability qualifier is set when the nullability of the result or parameter was expressed via a ...
bool isInvalidDecl() const
SourceLocation getLocation() const
bool isDeprecated(std::string *Message=nullptr) const
Determine whether this declaration is marked 'deprecated'.
void setImplicit(bool I=true)
DeclContext * getDeclContext()
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
void setLexicalDeclContext(DeclContext *DC)
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
SourceLocation getIdentifierLoc() const
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
IdentifierInfo * getIdentifier() const
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
bool isInvalidType() const
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
unsigned getBitWidthValue(const ASTContext &Ctx) const
Computes the bit width of this field, if this is a bit field.
Expr * getBitWidth() const
Returns the expression that represents the bit width, if this field is a bit field.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
One of these records is kept for each identifier that is lexed.
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
void AddDecl(NamedDecl *D)
AddDecl - Link the decl to its shadowed decl chain.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
clang::ObjCRuntime ObjCRuntime
Represents the results of name lookup.
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
static ObjCAtDefsFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, Expr *BW)
ObjCCategoryDecl - Represents a category declaration.
static ObjCCategoryDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation AtLoc, SourceLocation ClassNameLoc, SourceLocation CategoryNameLoc, IdentifierInfo *Id, ObjCInterfaceDecl *IDecl, ObjCTypeParamList *typeParamList, SourceLocation IvarLBraceLoc=SourceLocation(), SourceLocation IvarRBraceLoc=SourceLocation())
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
ObjCCategoryImplDecl * getImplementation() const
ObjCInterfaceDecl * getClassInterface()
bool IsClassExtension() const
const ObjCProtocolList & getReferencedProtocols() const
void setImplementation(ObjCCategoryImplDecl *ImplD)
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
static ObjCCategoryImplDecl * Create(ASTContext &C, DeclContext *DC, IdentifierInfo *Id, ObjCInterfaceDecl *classInterface, SourceLocation nameLoc, SourceLocation atStartLoc, SourceLocation CategoryNameLoc)
ObjCCategoryDecl * getCategoryDecl() const
ObjCCompatibleAliasDecl - Represents alias of a class.
static ObjCCompatibleAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, ObjCInterfaceDecl *aliasedClass)
ObjCContainerDecl - Represents a container for method declarations.
ObjCMethodDecl * getMethod(Selector Sel, bool isInstance, bool AllowHidden=false) const
method_range methods() const
SourceRange getAtEndRange() const
instmeth_range instance_methods() const
ObjCIvarDecl * getIvarDecl(IdentifierInfo *Id) const
getIvarDecl - This method looks up an ivar in this ContextDecl.
void setAtEndRange(SourceRange atEnd)
ObjCMethodDecl * getClassMethod(Selector Sel, bool AllowHidden=false) const
prop_range properties() const
classmeth_range class_methods() const
ObjCMethodDecl * getInstanceMethod(Selector Sel, bool AllowHidden=false) const
Captures information about "declaration specifiers" specific to Objective-C.
ObjCDeclQualifier
ObjCDeclQualifier - Qualifier used on types in method declarations.
ObjCDeclQualifier getObjCDeclQualifier() const
propimpl_range property_impls() const
const ObjCInterfaceDecl * getClassInterface() const
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
static ObjCImplementationDecl * Create(ASTContext &C, DeclContext *DC, ObjCInterfaceDecl *classInterface, ObjCInterfaceDecl *superDecl, SourceLocation nameLoc, SourceLocation atStartLoc, SourceLocation superLoc=SourceLocation(), SourceLocation IvarLBraceLoc=SourceLocation(), SourceLocation IvarRBraceLoc=SourceLocation())
const ObjCInterfaceDecl * getSuperClass() const
Represents an ObjC class declaration.
void mergeClassExtensionProtocolList(ObjCProtocolDecl *const *List, unsigned Num, ASTContext &C)
mergeClassExtensionProtocolList - Merge class extension's protocol list into the protocol list for th...
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
ObjCInterfaceDecl * lookupInheritedClass(const IdentifierInfo *ICName)
lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super class whose name is passe...
ivar_iterator ivar_end() const
static ObjCInterfaceDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation atLoc, IdentifierInfo *Id, ObjCTypeParamList *typeParamList, ObjCInterfaceDecl *PrevDecl, SourceLocation ClassLoc=SourceLocation(), bool isInternal=false)
llvm::iterator_range< specific_decl_iterator< ObjCIvarDecl > > ivar_range
unsigned ivar_size() const
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
bool hasDefinition() const
Determine whether this class has been defined.
all_protocol_range all_referenced_protocols() const
visible_extensions_range visible_extensions() const
bool isImplicitInterfaceDecl() const
isImplicitInterfaceDecl - check that this is an implicitly declared ObjCInterfaceDecl node.
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
ivar_iterator ivar_begin() const
void setImplementation(ObjCImplementationDecl *ImplD)
known_categories_range known_categories() const
void setSuperClass(TypeSourceInfo *superClass)
ObjCCategoryDecl * FindCategoryDeclaration(IdentifierInfo *CategoryId) const
FindCategoryDeclaration - Finds category declaration in the list of categories for this class and ret...
const ObjCProtocolList & getReferencedProtocols() const
ObjCMethodDecl * lookupMethod(Selector Sel, bool isInstance, bool shallowCategoryLookup=false, bool followSuper=true, const ObjCCategoryDecl *C=nullptr) const
lookupMethod - This method returns an instance/class method by looking in the class,...
ObjCImplementationDecl * getImplementation() const
void setEndOfDefinitionLoc(SourceLocation LE)
void startDefinition()
Starts the definition of this Objective-C class, taking it from a forward declaration (@class) to a d...
visible_categories_range visible_categories() const
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
ObjCInterfaceDecl * getSuperClass() const
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
void startDuplicateDefinitionForComparison()
Starts the definition without sharing it with other redeclarations.
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
Interfaces are the core concept in Objective-C for object oriented design.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCIvarDecl * getNextIvar()
ObjCIvarRefExpr - A reference to an ObjC instance variable.
ObjCList - This is a simple template class used to hold various lists of decls etc,...
void set(T *const *InList, unsigned Elts, ASTContext &Ctx)
An expression that sends a message to the given Objective-C object or class.
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
@ Instance
The receiver is an object instance.
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
ObjCMethodDecl - Represents an instance or class method declaration.
bool isDesignatedInitializerForTheInterface(const ObjCMethodDecl **InitMethod=nullptr) const
Returns true if the method selector resolves to a designated initializer in the class's interface.
ImplicitParamDecl * getSelfDecl() const
void setObjCDeclQualifier(ObjCDeclQualifier QV)
void setDefined(bool isDefined)
ObjCDeclQualifier getObjCDeclQualifier() const
ArrayRef< ParmVarDecl * > parameters() const
unsigned param_size() const
bool isPropertyAccessor() const
static ObjCMethodDecl * Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc, Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo, DeclContext *contextDecl, bool isInstance=true, bool isVariadic=false, bool isPropertyAccessor=false, bool isSynthesizedAccessorStub=false, bool isImplicitlyDeclared=false, bool isDefined=false, ObjCImplementationControl impControl=ObjCImplementationControl::None, bool HasRelatedResultType=false)
const ObjCPropertyDecl * findPropertyDecl(bool CheckOverrides=true) const
Returns the property associated with this method's selector.
param_const_iterator param_end() const
param_const_iterator param_begin() const
ObjCMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
void setAsRedeclaration(const ObjCMethodDecl *PrevMethod)
void setRelatedResultType(bool RRT=true)
Note whether this method has a related result type.
bool isSynthesizedAccessorStub() const
SourceLocation getSelectorLoc(unsigned Index) const
SourceRange getReturnTypeSourceRange() const
void setOverriding(bool IsOver)
const ParmVarDecl *const * param_const_iterator
bool hasRelatedResultType() const
Determine whether this method has a result type that is related to the message receiver's type.
SourceLocation getBeginLoc() const LLVM_READONLY
void setMethodParams(ASTContext &C, ArrayRef< ParmVarDecl * > Params, ArrayRef< SourceLocation > SelLocs=std::nullopt)
Sets the method's parameters and selector source locations.
bool isDirectMethod() const
True if the method is tagged as objc_direct.
Selector getSelector() const
ImplicitParamDecl * getCmdDecl() const
bool isInstanceMethod() const
void setReturnType(QualType T)
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID)
createImplicitParams - Used to lazily create the self and cmd implicit parameters.
QualType getReturnType() const
ParmVarDecl *const * param_iterator
ObjCImplementationControl getImplementationControl() const
bool isClassMethod() const
ObjCInterfaceDecl * getClassInterface()
Wraps an ObjCPointerType with source location information.
void setStarLoc(SourceLocation Loc)
Represents a pointer to an Objective C object.
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
bool isObjCIdType() const
True if this is equivalent to the 'id' type, i.e.
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Represents a class type in Objective C.
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface.
Represents one property declaration in an Objective-C interface.
ObjCIvarDecl * getPropertyIvarDecl() const
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Represents an Objective-C protocol declaration.
void startDuplicateDefinitionForComparison()
Starts the definition without sharing it with other redeclarations.
bool hasDefinition() const
Determine whether this protocol has a definition.
bool isThisDeclarationADefinition() const
Determine whether this particular declaration is also the definition.
static ObjCProtocolDecl * Create(ASTContext &C, DeclContext *DC, IdentifierInfo *Id, SourceLocation nameLoc, SourceLocation atStartLoc, ObjCProtocolDecl *PrevDecl)
const ObjCProtocolList & getReferencedProtocols() const
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
void startDefinition()
Starts the definition of this Objective-C protocol.
protocol_range protocols() const
A list of Objective-C protocols, along with the source locations at which they were referenced.
bool isNeXTFamily() const
Is this runtime basically of the NeXT family of runtimes?
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
bool isFragile() const
The inverse of isNonFragile(): does this runtime follow the set of implied behaviors for a "fragile" ...
Represents the declaration of an Objective-C type parameter.
static ObjCTypeParamDecl * Create(ASTContext &ctx, DeclContext *dc, ObjCTypeParamVariance variance, SourceLocation varianceLoc, unsigned index, SourceLocation nameLoc, IdentifierInfo *name, SourceLocation colonLoc, TypeSourceInfo *boundInfo)
bool hasExplicitBound() const
Whether this type parameter has an explicitly-written type bound, e.g., "T : NSView".
ObjCTypeParamVariance getVariance() const
Determine the variance of this type parameter.
void setVariance(ObjCTypeParamVariance variance)
Set the variance of this type parameter.
SourceLocation getVarianceLoc() const
Retrieve the location of the variance keyword.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
SourceRange getSourceRange() const
unsigned size() const
Determine the number of type parameters in this list.
ObjCTypeParamDecl * back() const
static ObjCTypeParamList * create(ASTContext &ctx, SourceLocation lAngleLoc, ArrayRef< ObjCTypeParamDecl * > typeParams, SourceLocation rAngleLoc)
Create a new Objective-C type parameter list.
SourceLocation getLAngleLoc() const
Represents a parameter to a function.
void setObjCDeclQualifier(ObjCDeclQualifier QTVal)
ObjCDeclQualifier getObjCDeclQualifier() const
void setObjCMethodScopeInfo(unsigned parameterIndex)
static const ParsedAttributesView & none()
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
LangAS getAddressSpace() const
Return the address space of this type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
The collection of all-type qualifiers we support.
void removeCVRQualifiers(unsigned mask)
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
bool hasObjCLifetime() const
std::string getAsString() const
Represents a struct/union/class.
field_iterator field_end() const
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
Base for LValueReferenceType and RValueReferenceType.
Scope - A scope is a transient data structure that is used while parsing the program.
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
Smart pointer class that efficiently represents Objective-C method names.
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
std::string getAsString() const
Derive the full selector name (e.g.
ObjCMethodFamily getMethodFamily() const
Derive the conventional family of this method.
bool isUnarySelector() const
unsigned getNumArgs() const
llvm::DenseMap< Selector, Lists >::iterator iterator
iterator find(Selector Sel)
std::pair< ObjCMethodList, ObjCMethodList > Lists
std::pair< iterator, bool > insert(std::pair< Selector, Lists > &&Val)
A generic diagnostic builder for errors which may or may not be deferred.
Sema - This implements semantic analysis and AST building for C.
ObjCMethodDecl * LookupMethodInObjectType(Selector Sel, QualType Ty, bool IsInstance)
LookupMethodInType - Look up a method in an ObjCObjectType.
void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI, SmallVectorImpl< ObjCIvarDecl * > &Ivars)
CollectIvarsToConstructOrDestruct - Collect those ivars which require initialization.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
void ActOnObjCContainerStartDefinition(ObjCContainerDecl *IDecl)
llvm::MapVector< Selector, SourceLocation > ReferencedSelectors
Method selectors used in a @selector expression.
void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, const ObjCMethodDecl *Overridden)
Check whether the given new method is a valid override of the given overridden method,...
bool CheckARCMethodDecl(ObjCMethodDecl *method)
Check a method declaration for compatibility with the Objective-C ARC conventions.
void ActOnStartOfObjCMethodDef(Scope *S, Decl *D)
ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible and user declared,...
DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl, ArrayRef< Decl * > Decls)
LookupNameKind
Describes the kind of name lookup to perform.
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupObjCProtocolName
Look up the name of an Objective-C protocol.
@ LookupAnyName
Look up any declaration with any name.
void DiagnoseFunctionSpecifiers(const DeclSpec &DS)
Diagnose function specifiers on a declaration of an identifier that does not identify a function.
ObjCCategoryDecl * ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, ObjCTypeParamList *typeParamList, IdentifierInfo *CategoryName, SourceLocation CategoryLoc, Decl *const *ProtoRefs, unsigned NumProtoRefs, const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList)
bool isSelfExpr(Expr *RExpr)
Private Helper predicate to check for 'self'.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc, IdentifierInfo **IdentList, SourceLocation *IdentLocs, ArrayRef< ObjCTypeParamList * > TypeParamLists, unsigned NumElts)
void CheckConflictingOverridingMethod(ObjCMethodDecl *Method, ObjCMethodDecl *Overridden, bool IsProtocolMethodDecl)
ObjCImplementationDecl * ActOnStartClassImplementation(SourceLocation AtClassImplLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *SuperClassname, SourceLocation SuperClassLoc, const ParsedAttributesView &AttrList)
@ OCK_CategoryImplementation
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
void AddPragmaAttributes(Scope *S, Decl *D)
Adds the attributes that have been specified using the '#pragma clang attribute push' directives to t...
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
ObjCTypeParamList * actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc, ArrayRef< Decl * > typeParams, SourceLocation rAngleLoc)
void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP)
CheckCategoryVsClassMethodMatches - Checks that methods implemented in category matches with those im...
void ActOnTypedefedProtocols(SmallVectorImpl< Decl * > &ProtocolRefs, SmallVectorImpl< SourceLocation > &ProtocolLocs, IdentifierInfo *SuperName, SourceLocation SuperLoc)
ActOnTypedefedProtocols - this action finds protocol list as part of the typedef'ed use for a qualifi...
void WarnExactTypedMethods(ObjCMethodDecl *Method, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl)
WarnExactTypedMethods - This routine issues a warning if method implementation declaration matches ex...
Decl * ActOnAtEnd(Scope *S, SourceRange AtEnd, ArrayRef< Decl * > allMethods=std::nullopt, ArrayRef< DeclGroupPtrTy > allTUVars=std::nullopt)
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.
Decl * ActOnCompatibilityAlias(SourceLocation AtCompatibilityAliasLoc, IdentifierInfo *AliasName, SourceLocation AliasLocation, IdentifierInfo *ClassName, SourceLocation ClassLocation)
ActOnCompatibilityAlias - this action is called after complete parsing of a @compatibility_alias decl...
void DiagnoseUnusedBackingIvarInAccessor(Scope *S, const ObjCImplementationDecl *ImplD)
DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which backs the property is n...
void ActOnSuperClassOfClassInterface(Scope *S, SourceLocation AtInterfaceLoc, ObjCInterfaceDecl *IDecl, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *SuperName, SourceLocation SuperLoc, ArrayRef< ParsedType > SuperTypeArgs, SourceRange SuperTypeArgsRange)
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
ASTContext & getASTContext() const
void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod, ObjCInterfaceDecl *CurrentClass, ResultTypeCompatibilityKind RTC)
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall)
Check whether the given method, which must be in the 'init' family, is a valid member of that family.
void MatchAllMethodDeclarations(const SelectorSet &InsMap, const SelectorSet &ClsMap, SelectorSet &InsMapSeen, SelectorSet &ClsMapSeen, ObjCImplDecl *IMPDecl, ObjCContainerDecl *IDecl, bool &IncompleteImpl, bool ImmediateClass, bool WarnCategoryMethodImpl=false)
MatchAllMethodDeclarations - Check methods declaraed in interface or or protocol against those declar...
void CheckObjCMethodDirectOverrides(ObjCMethodDecl *method, ObjCMethodDecl *overridden)
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
void PushFunctionScope()
Enter a new function scope.
bool CheckFunctionReturnType(QualType T, SourceLocation Loc)
void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, ObjCIvarDecl **Fields, unsigned nIvars, SourceLocation Loc)
CheckImplementationIvars - This routine checks if the instance variables listed in the implelementati...
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
void AddAnyMethodToGlobalPool(Decl *D)
AddAnyMethodToGlobalPool - Add any method, instance or factory to global pool.
const LangOptions & getLangOpts() const
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId, SourceLocation ProtocolLoc, IdentifierInfo *TypeArgId, SourceLocation TypeArgLoc, bool SelectProtocolFirst=false)
ObjCProtocolDecl * ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc, Decl *const *ProtoRefNames, unsigned NumProtoRefs, const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList, SkipBodyInfo *SkipBody)
void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D)
void updateOutOfDateSelector(Selector Sel)
void AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl)
AtomicPropertySetterGetterRules - This routine enforces the rule (via warning) when atomic property h...
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
const LangOptions & LangOpts
void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation)
SetIvarInitializers - This routine builds initialization ASTs for the Objective-C implementation whos...
void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false)
AddInstanceMethodToGlobalPool - All instance methods in a translation unit are added to a global pool...
void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart, IdentifierInfo *ClassName, SmallVectorImpl< Decl * > &Decls)
Called whenever @defs(ClassName) is encountered in the source.
void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList)
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
const ObjCMethodDecl * SelectorsForTypoCorrection(Selector Sel, QualType ObjectType=QualType())
DeclContext * getCurLexicalContext() const
sema::FunctionScopeInfo * getCurFunction() const
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
Decl * ActOnMethodDeclaration(Scope *S, SourceLocation BeginLoc, SourceLocation EndLoc, tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType, ArrayRef< SourceLocation > SelectorLocs, Selector Sel, ObjCArgInfo *ArgInfo, DeclaratorChunk::ParamInfo *CParamInfo, unsigned CNumArgs, const ParsedAttributesView &AttrList, tok::ObjCKeywordKind MethodImplKind, bool isVariadic, bool MethodDefinition)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
bool CollectMultipleMethodsInGlobalPool(Selector Sel, SmallVectorImpl< ObjCMethodDecl * > &Methods, bool InstanceFirst, bool CheckTheOther, const ObjCObjectType *TypeBound=nullptr)
We first select the type of the method: Instance or Factory, then collect all methods with that type.
DeclResult actOnObjCTypeParam(Scope *S, ObjCTypeParamVariance variance, SourceLocation varianceLoc, unsigned index, IdentifierInfo *paramName, SourceLocation paramLoc, SourceLocation colonLoc, ParsedType typeBound)
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
bool AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod, SourceRange R, bool receiverIdOrClass, SmallVectorImpl< ObjCMethodDecl * > &Methods)
ObjCProtocolDecl * LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc, RedeclarationKind Redecl=NotForRedeclaration)
Find the protocol with the given name, if any.
VarDecl * BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, bool Invalid=false)
Build a type-check a new Objective-C exception variable declaration.
ObjCMethodDecl * LookupImplementedMethodInGlobalPool(Selector Sel)
LookupImplementedMethodInGlobalPool - Returns the method which has an implementation.
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
void ActOnObjCContainerFinishDefinition()
SourceManager & getSourceManager() const
void DiagnoseMissingDesignatedInitOverrides(const ObjCImplementationDecl *ImplD, const ObjCInterfaceDecl *IFD)
void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT, ObjCInterfaceDecl *ID)
DiagnoseClassExtensionDupMethods - Check for duplicate declaration of a class method in its extension...
RedeclarationKind forRedeclarationInCurContext() const
void WarnConflictingTypedMethods(ObjCMethodDecl *Method, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl)
TypeResult ActOnTypeName(Declarator &D)
void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false)
AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
ExternalSemaSource * getExternalSource() const
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
bool CheckParmsForFunctionDef(ArrayRef< ParmVarDecl * > Parameters, bool CheckParameterNames)
CheckParmsForFunctionDef - Check that the parameters of the given function are appropriate for the de...
void ProcessPropertyDecl(ObjCPropertyDecl *property)
Process the specified property declaration and create decls for the setters and getters as needed.
ObjCInterfaceDecl * getObjCInterfaceDecl(IdentifierInfo *&Id, SourceLocation IdLoc, bool TypoCorrection=false)
Look for an Objective-C class in the translation unit.
ObjCInterfaceDecl * ActOnStartClassInterface(Scope *S, SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, ObjCTypeParamList *typeParamList, IdentifierInfo *SuperName, SourceLocation SuperLoc, ArrayRef< ParsedType > SuperTypeArgs, SourceRange SuperTypeArgsRange, Decl *const *ProtoRefs, unsigned NumProtoRefs, const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList, SkipBodyInfo *SkipBody)
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
void actOnObjCTypeArgsOrProtocolQualifiers(Scope *S, ParsedType baseType, SourceLocation lAngleLoc, ArrayRef< IdentifierInfo * > identifiers, ArrayRef< SourceLocation > identifierLocs, SourceLocation rAngleLoc, SourceLocation &typeArgsLAngleLoc, SmallVectorImpl< ParsedType > &typeArgs, SourceLocation &typeArgsRAngleLoc, SourceLocation &protocolLAngleLoc, SmallVectorImpl< Decl * > &protocols, SourceLocation &protocolRAngleLoc, bool warnOnIncompleteProtocols)
Given a list of identifiers (and their locations), resolve the names to either Objective-C protocol q...
void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCContainerDecl *CDecl, bool SynthesizeProperties)
DiagnoseUnimplementedProperties - This routine warns on those properties which must be implemented by...
bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method, const ObjCMethodDecl *PrevMethod, MethodMatchStrategy strategy=MMS_strict)
MatchTwoMethodDeclarations - Checks if two methods' type match and returns true, or false,...
ObjCIvarDecl * GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method, const ObjCPropertyDecl *&PDecl) const
GetIvarBackingPropertyAccessor - If method is a property setter/getter and it property has a backing ...
void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl *IMPDecl, ObjCContainerDecl *IDecl, bool IncompleteImpl=false)
ImplMethodsVsClassMethods - This is main routine to warn if any method remains unimplemented in the c...
bool inferObjCARCLifetime(ValueDecl *decl)
TypeSourceInfo * GetTypeForDeclarator(Declarator &D)
GetTypeForDeclarator - Convert the type for the specified declarator to Type instances.
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method)
Add the given method to the list of globally-known methods.
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
void DiagnoseUseOfUnimplementedSelectors()
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
ResultTypeCompatibilityKind
Describes the compatibility of a result type with its method.
void ReadMethodPool(Selector Sel)
Read the contents of the method pool for a given selector from external storage.
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
DiagnosticsEngine & Diags
DeclGroupPtrTy ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc, ArrayRef< IdentifierLocPair > IdentList, const ParsedAttributesView &attrList)
ActOnForwardProtocolDeclaration - Handle @protocol foo;.
void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID)
DiagnoseDuplicateIvars - Check for duplicate ivars in the entire class at the start of @implementatio...
bool CheckObjCDeclScope(Decl *D)
Checks that the Objective-C declaration is declared in the global scope.
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D.
llvm::BumpPtrAllocator BumpAlloc
void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old)
void ProcessAPINotes(Decl *D)
Map any API notes provided for this declaration to attributes on the declaration.
Decl * ActOnObjCExceptionDecl(Scope *S, Declarator &D)
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
bool CheckForwardProtocolDeclarationForCircularDependency(IdentifierInfo *PName, SourceLocation &PLoc, SourceLocation PrevLoc, const ObjCList< ObjCProtocolDecl > &PList)
IdentifierResolver IdResolver
llvm::SmallVector< std::pair< SourceLocation, const BlockDecl * >, 1 > ImplicitlyRetainedSelfLocs
List of SourceLocations where 'self' is implicitly retained inside a block.
void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer, ArrayRef< IdentifierLocPair > ProtocolId, SmallVectorImpl< Decl * > &Protocols)
FindProtocolDeclaration - This routine looks up protocols and issues an error if they are not declare...
ObjCContainerKind getObjCContainerKind() const
void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl)
Diagnose any null-resettable synthesized setters.
void DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl< ObjCMethodDecl * > &Methods, Selector Sel, SourceRange R, bool receiverIdOrClass)
ObjCCategoryImplDecl * ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *CatName, SourceLocation CatLoc, const ParsedAttributesView &AttrList)
ActOnStartCategoryImplementation - Perform semantic checks on the category implementation declaration...
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
SourceLocation getBeginLoc() const LLVM_READONLY
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
StringRef getPlatformName() const
Retrieve the name of the platform as it is used in the availability attribute.
VersionTuple getPlatformMinVersion() const
Retrieve the minimum desired version of the platform, to which the program should be compiled.
Represents a declaration of a type.
SourceLocation getBeginLoc() const LLVM_READONLY
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
void pushFullCopy(TypeLoc L)
Pushes a copy of the given TypeLoc onto this builder.
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
Base wrapper for a particular "section" of type source info.
TypeLoc findExplicitQualifierLoc() const
Find a type with the location of an explicit type qualifier.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceLocation getEndLoc() const
Get the end source location.
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
bool isIncompleteArrayType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
bool isScalarType() const
bool isObjCQualifiedIdType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
bool isObjCIdType() const
bool isObjCObjectType() const
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isObjCObjectPointerType() const
bool isVectorType() const
bool isObjCQualifiedClassType() const
bool isObjCClassType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
bool isObjCIndependentClassType() const
Base class for declarations which introduce a typedef-name.
TypeSourceInfo * getTypeSourceInfo() const
QualType getUnderlyingType() const
Simple class containing the result of Sema::CorrectTypo.
DeclClass * getCorrectionDeclAs() const
void setType(QualType newType)
Represents a variable declaration or definition.
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
void setExceptionVariable(bool EV)
bool ObjCIsDesignatedInit
True when this is a method marked as a designated initializer.
bool ObjCShouldCallSuper
A flag that is set when parsing a method that must call super's implementation, such as -dealloc,...
bool ObjCWarnForNoInitDelegation
This starts true for a secondary initializer method and will be set to false if there is an invocatio...
bool ObjCIsSecondaryInit
True when this is an initializer method not marked as a designated initializer within a class that ha...
bool ObjCWarnForNoDesignatedInitChain
This starts true for a method marked as designated initializer and will be set to false if there is a...
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
ObjCKeywordKind
Provides a namespace for Objective-C keywords which start with an '@'.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
The JSON file list parser is used to communicate input to InstallAPI.
ThreadStorageClassSpecifier
Thread storage-class-specifier.
ObjCMethodFamily
A family of Objective-C methods.
@ OMF_None
No particular method family.
@ Property
The type of a property.
Selector GetNullarySelector(StringRef name, ASTContext &Ctx)
Utility function for constructing a nullary selector.
@ Class
The "class" keyword.
AvailabilityResult
Captures the result of checking the availability of a declaration.
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
ObjCTypeParamVariance
Describes the variance of a given generic parameter.
@ Invariant
The parameter is invariant: must match exactly.
@ Contravariant
The parameter is contravariant, e.g., X<T> is a subtype of X when the type parameter is covariant and...
@ Covariant
The parameter is covariant, e.g., X<T> is a subtype of X when the type parameter is covariant and T i...
std::pair< IdentifierInfo *, SourceLocation > IdentifierLocPair
A simple pair of identifier info and location.
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed.
static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc, SourceLocation ConstQualLoc, SourceLocation VolatileQualLoc, SourceLocation RestrictQualLoc, SourceLocation AtomicQualLoc, SourceLocation UnalignedQualLoc)
Return a DeclaratorChunk for a pointer.
a linked list of methods with the same selector name but different signatures.
ObjCMethodDecl * getMethod() const
void setMethod(ObjCMethodDecl *M)
void setNext(ObjCMethodList *L)
bool hasMoreThanOneDecl() const
ObjCMethodList * getNext() const