31#include "llvm/ADT/DenseMap.h"
32#include "llvm/ADT/DenseSet.h"
65 assert(resultClass &&
"unexpected object type!");
70 if (receiverTypeIfCall.
isNull() &&
80 if (receiverTypeIfCall.
isNull())
87 if (!receiverClass)
return false;
90 assert(receiverClass &&
"method not associated with a class!");
104 if (receiverTypeIfCall.
isNull() &&
106 method->
addAttr(UnavailableAttr::CreateImplicit(Context,
"",
107 UnavailableAttr::IR_ARCInitReturnsUnrelated, loc));
112 Diag(loc, diag::err_arc_init_method_unrelated_result_type);
121 if (OldD->
hasAttr<NoEscapeAttr>() && !NewD->
hasAttr<NoEscapeAttr>()) {
122 S.
Diag(NewD->
getLocation(), diag::warn_overriding_method_missing_noescape);
159 CurrentClass = Cat->getClassInterface();
160 else if (
ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(DC))
161 CurrentClass = Impl->getClassInterface();
163 = dyn_cast<ObjCCategoryImplDecl>(DC))
164 CurrentClass = CatImpl->getClassInterface();
169 diag::warn_related_result_type_compatibility_class)
175 diag::warn_related_result_type_compatibility_protocol)
182 diag::note_related_result_type_family)
187 diag::note_related_result_type_overridden);
190 if ((NewMethod->
hasAttr<NSReturnsRetainedAttr>() !=
191 Overridden->
hasAttr<NSReturnsRetainedAttr>())) {
194 ? diag::err_nsreturns_retained_attribute_mismatch
195 : diag::warn_nsreturns_retained_attribute_mismatch)
199 if ((NewMethod->
hasAttr<NSReturnsNotRetainedAttr>() !=
200 Overridden->
hasAttr<NSReturnsNotRetainedAttr>())) {
203 ? diag::err_nsreturns_retained_attribute_mismatch
204 : diag::warn_nsreturns_retained_attribute_mismatch)
213 ni != ne && oi != oe; ++ni, ++oi) {
216 if (newDecl->
hasAttr<NSConsumedAttr>() !=
217 oldDecl->
hasAttr<NSConsumedAttr>()) {
220 ? diag::err_nsconsumed_attribute_mismatch
221 : diag::warn_nsconsumed_attribute_mismatch);
266 method->
addAttr(NSConsumesSelfAttr::CreateImplicit(Context));
270 if (method->
hasAttr<NSReturnsRetainedAttr>())
278 if (method->
hasAttr<NSReturnsRetainedAttr>() ||
279 method->
hasAttr<NSReturnsNotRetainedAttr>() ||
280 method->
hasAttr<NSReturnsAutoreleasedAttr>())
285 method->
addAttr(NSReturnsRetainedAttr::CreateImplicit(Context));
293 bool IsCategory =
false;
294 StringRef RealizedPlatform;
296 nullptr, VersionTuple(),
299 if (isa<ObjCMethodDecl>(ND)) {
302 if (RealizedPlatform.empty())
306 if (RealizedPlatform.ends_with(
"_app_extension"))
308 S.
Diag(ImplLoc, diag::warn_unavailable_def);
313 if (
const auto *CD = dyn_cast<ObjCCategoryDecl>(ND)) {
314 if (!CD->getClassInterface()->isDeprecated())
316 ND = CD->getClassInterface();
321 S.
Diag(ImplLoc, diag::warn_deprecated_def)
322 << (isa<ObjCMethodDecl>(ND)
324 : isa<ObjCCategoryDecl>(ND) || IsCategory ? 2
326 if (isa<ObjCMethodDecl>(ND))
331 << (isa<ObjCCategoryDecl>(ND) ?
"category" :
"class");
364 return !
T.getLocalQualifiers().hasObjCLifetime();
386 diag::err_func_def_incomplete_result))
408 if (!Param->isInvalidDecl() &&
getLangOpts().ObjCAutoRefCount &&
410 Diag(Param->getLocation(), diag::warn_arc_strong_pointer_objc_pointer) <<
413 if (Param->getIdentifier())
456 ImplDeclOfMethodDecl = OID->getImplementation();
457 else if (
ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ContDeclOfMethodDecl)) {
458 if (CD->IsClassExtension()) {
460 ImplDeclOfMethodDecl = OID->getImplementation();
462 ImplDeclOfMethodDecl = CD->getImplementation();
466 if (!ImplDeclOfMethodDecl || ImplDeclOfMethodDecl != ImplDeclOfMethodDef)
474 IC->getSuperClass() !=
nullptr;
475 }
else if (IC->hasDesignatedInitializers()) {
501 (SuperMethod && SuperMethod->
hasAttr<ObjCRequiresSuperAttr>());
518 ObjCInterfaceValidatorCCC() : CurrentIDecl(nullptr) {}
520 : CurrentIDecl(IDecl) {}
522 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
527 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
528 return std::make_unique<ObjCInterfaceValidatorCCC>(*
this);
540 unsigned NumProtoRefs,
545 for (
unsigned i = 0; i < NumProtoRefs; ++i) {
566 ObjCInterfaceValidatorCCC CCC(IDecl);
572 << SuperName << ClassName);
578 Diag(SuperLoc, diag::err_recursive_superclass)
579 << SuperName << ClassName <<
SourceRange(AtInterfaceLoc, ClassLoc);
583 dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
587 if (SuperClassDecl) {
592 if (PrevDecl && !SuperClassDecl) {
596 dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
600 SuperClassDecl = dyn_cast<ObjCInterfaceDecl>(IDecl);
618 if (!SuperClassDecl) {
619 Diag(SuperLoc, diag::err_redefinition_different_kind) << SuperName;
624 if (!isa_and_nonnull<TypedefNameDecl>(PrevDecl)) {
626 Diag(SuperLoc, diag::err_undef_superclass)
627 << SuperName << ClassName <<
SourceRange(AtInterfaceLoc, ClassLoc);
629 SuperLoc, SuperClassType, diag::err_forward_superclass,
632 SuperClassDecl =
nullptr;
637 if (SuperClassType.
isNull()) {
638 assert(!SuperClassDecl &&
"Failed to set SuperClassType?");
644 if (!SuperTypeArgs.empty()) {
647 SuperTypeArgsRange.
getBegin(), SuperTypeArgs,
657 if (!SuperClassTInfo) {
674 if (parsedTypeBound) {
686 diag::err_objc_type_param_bound_missing_pointer)
687 << typeBound << paramName
706 diag::err_objc_type_param_bound_nonobject)
707 << typeBound << paramName;
710 typeBoundInfo =
nullptr;
719 bool diagnosed =
false;
723 rangeToRemove =
attr.getLocalSourceRange();
724 if (
attr.getTypePtr()->getImmediateNullability()) {
726 diag::err_objc_type_param_bound_explicit_nullability)
727 << paramName << typeBound
737 diag::err_objc_type_param_bound_qualified)
738 << paramName << typeBound
748 if (!quals.
empty()) {
758 if (!typeBoundInfo) {
765 varianceLoc, index, paramLoc, paramName,
766 colonLoc, typeBoundInfo);
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));
807 for (
auto *typeParam : *typeParamList) {
808 if (!typeParam->isInvalidDecl()) {
809 S->RemoveDecl(typeParam);
818 enum class TypeParamListContext {
832 TypeParamListContext newContext) {
834 if (prevTypeParams->
size() != newTypeParams->
size()) {
836 if (newTypeParams->
size() > prevTypeParams->
size()) {
842 S.
Diag(diagLoc, diag::err_objc_type_param_arity_mismatch)
843 <<
static_cast<unsigned>(newContext)
844 << (newTypeParams->
size() > prevTypeParams->
size())
845 << prevTypeParams->
size()
846 << newTypeParams->
size();
852 for (
unsigned i = 0, n = prevTypeParams->
size(); i != n; ++i) {
859 newContext != TypeParamListContext::Definition) {
878 auto diag = S.
Diag(diagLoc,
879 diag::err_objc_type_param_variance_conflict)
880 <<
static_cast<unsigned>(newTypeParam->
getVariance())
882 <<
static_cast<unsigned>(prevTypeParam->
getVariance())
891 StringRef newVarianceStr
898 (newVarianceStr +
" ").str());
925 S.
Diag(newBoundRange.
getBegin(), diag::err_objc_type_param_bound_conflict)
949 if (newContext == TypeParamListContext::ForwardDeclaration ||
950 newContext == TypeParamListContext::Definition) {
958 diag::err_objc_type_param_bound_missing)
961 << (newContext == TypeParamListContext::ForwardDeclaration)
980 Decl *
const *ProtoRefs,
unsigned NumProtoRefs,
983 assert(ClassName &&
"Missing class identifier");
991 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
992 Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
1019 if (typeParamList) {
1023 TypeParamListContext::Definition)) {
1024 typeParamList =
nullptr;
1027 Diag(ClassLoc, diag::err_objc_parameterized_forward_class_first)
1029 Diag(prevTypeParamList->getLAngleLoc(), diag::note_previous_decl)
1034 for (
auto *typeParam : *prevTypeParamList) {
1040 typeParam->getUnderlyingType())));
1053 ClassName, typeParamList, PrevIDecl, ClassLoc);
1059 SkipBody->
New = IDecl;
1062 Diag(AtInterfaceLoc, diag::err_duplicate_class_def)
1064 Diag(Def->getLocation(), diag::note_previous_definition);
1092 ClassName, ClassLoc,
1093 SuperName, SuperLoc, SuperTypeArgs,
1094 SuperTypeArgsRange);
1102 NumProtoRefs, ProtoLocs);
1104 ProtoLocs, Context);
1127 if (
const TypedefNameDecl *TDecl = dyn_cast_or_null<TypedefNameDecl>(IDecl)) {
1128 QualType T = TDecl->getUnderlyingType();
1131 ProtocolRefs.append(OPT->qual_begin(), OPT->qual_end());
1136 ProtocolLocs.append(OPT->getNumProtocols(), SuperLoc);
1154 Diag(AliasLocation, diag::err_conflicting_aliasing_type) << AliasName;
1163 dyn_cast_or_null<TypedefNameDecl>(CDeclU)) {
1164 QualType T = TDecl->getUnderlyingType();
1167 ClassName = IDecl->getIdentifier();
1176 Diag(ClassLocation, diag::warn_undef_interface) << ClassName;
1198 E = PList.
end(); I != E; ++I) {
1200 if (PDecl->getIdentifier() == PName) {
1201 Diag(Ploc, diag::err_protocol_has_circular_dependency);
1202 Diag(PrevLoc, diag::note_previous_definition);
1206 if (!PDecl->hasDefinition())
1210 PDecl->getLocation(), PDecl->getReferencedProtocols()))
1225 assert(ProtocolName &&
"Missing protocol identifier");
1235 ProtocolLoc, AtProtoInterfaceLoc,
1240 SkipBody->
New = PDecl;
1244 Diag(ProtocolLoc, diag::warn_duplicate_protocol_def) << ProtocolName;
1245 Diag(Def->getLocation(), diag::note_previous_definition);
1260 ProtocolName, ProtocolLoc, PrevDecl->
getLocation(), PList);
1265 ProtocolLoc, AtProtoInterfaceLoc,
1280 if (!err && NumProtoRefs ) {
1283 NumProtoRefs, ProtoLocs);
1285 ProtoLocs, Context);
1297 UndefinedProtocol = PDecl;
1303 UndefinedProtocol = PI;
1313 bool ForObjCContainer,
1326 Corrected,
SemaRef.
PDiag(diag::err_undeclared_protocol_suggest)
1331 Diag(Pair.second, diag::err_undeclared_protocol) << Pair.first;
1340 if (!ForObjCContainer) {
1349 if (WarnOnDeclarations &&
1351 Diag(Pair.second, diag::warn_undef_protocolref) << Pair.first;
1352 Diag(UndefinedProtocol->
getLocation(), diag::note_protocol_decl_undefined)
1353 << UndefinedProtocol;
1355 Protocols.push_back(PDecl);
1362class ObjCTypeArgOrProtocolValidatorCCC final
1367 ObjCTypeArgOrProtocolValidatorCCC(
ASTContext &context,
1369 : Context(context), LookupKind(lookupKind) { }
1371 bool ValidateCandidate(
const TypoCorrection &candidate)
override {
1385 if (isa<RecordDecl>(typeDecl) && !Context.
getLangOpts().CPlusPlus)
1391 if (
type->isObjCObjectPointerType() ||
1392 type->isBlockPointerType() ||
1393 type->isDependentType() ||
1394 type->isObjCObjectType())
1411 std::unique_ptr<CorrectionCandidateCallback> clone()
override {
1412 return std::make_unique<ObjCTypeArgOrProtocolValidatorCCC>(*
this);
1421 bool SelectProtocolFirst) {
1422 Diag(TypeArgLoc, diag::err_objc_type_args_and_protocols)
1423 << SelectProtocolFirst << TypeArgId << ProtocolId
1434 bool warnOnIncompleteProtocols) {
1438 unsigned numProtocolsResolved = 0;
1439 auto resolvedAsProtocols = [&] {
1440 assert(numProtocolsResolved == identifiers.size() &&
"Unresolved protocols");
1447 bool allAreTypeNames =
false;
1451 baseClass = objcObjectType->getInterface();
1454 if (typeParams->size() == numProtocolsResolved) {
1456 allAreTypeNames =
true;
1463 for (
unsigned i = 0, n = protocols.size(); i != n; ++i) {
1468 if (!warnOnIncompleteProtocols) {
1480 if (warnOnIncompleteProtocols &&
1482 Diag(identifierLocs[i], diag::warn_undef_protocolref)
1491 if (allAreTypeNames) {
1495 if (isa<ObjCInterfaceDecl>(
decl)) {
1497 firstClassNameLoc = identifierLocs[i];
1498 }
else if (!isa<TypeDecl>(
decl)) {
1500 allAreTypeNames =
false;
1503 allAreTypeNames =
false;
1512 if (allAreTypeNames && firstClassNameLoc.
isValid()) {
1515 bool allProtocolsDeclared =
true;
1516 for (
auto *proto : protocols) {
1518 allProtocolsDeclared =
false;
1523 if (allProtocolsDeclared) {
1524 Diag(firstClassNameLoc, diag::warn_objc_redundant_qualified_class_type)
1531 protocolLAngleLoc = lAngleLoc;
1532 protocolRAngleLoc = rAngleLoc;
1533 assert(protocols.size() == identifierLocs.size());
1537 for (
unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1539 protocols.push_back(proto);
1541 ++numProtocolsResolved;
1545 if (numProtocolsResolved == identifiers.size())
1546 return resolvedAsProtocols();
1552 typedef llvm::PointerUnion<TypeDecl *, ObjCInterfaceDecl *> TypeOrClassDecl;
1554 unsigned numTypeDeclsResolved = 0;
1555 for (
unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1559 typeDecls.push_back(TypeOrClassDecl());
1563 if (
auto typeDecl = dyn_cast<TypeDecl>(
decl)) {
1564 typeDecls.push_back(typeDecl);
1565 ++numTypeDeclsResolved;
1569 if (
auto objcClass = dyn_cast<ObjCInterfaceDecl>(
decl)) {
1570 typeDecls.push_back(objcClass);
1571 ++numTypeDeclsResolved;
1575 typeDecls.push_back(TypeOrClassDecl());
1582 auto resolveTypeReference = [&](TypeOrClassDecl typeDecl,
SourceLocation loc)
1586 const char* prevSpec;
1589 if (
auto *actualTypeDecl = typeDecl.dyn_cast<
TypeDecl *>())
1617 Diag(loc, diag::err_objc_type_arg_missing_star)
1628 auto resolvedAsTypeDecls = [&] {
1632 assert(numTypeDeclsResolved == identifiers.size() &&
"Unresolved type decl");
1634 for (
unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1636 TypeResult type = resolveTypeReference(typeDecls[i], identifierLocs[i]);
1637 if (!
type.isUsable()) {
1642 typeArgs.push_back(
type.get());
1645 typeArgsLAngleLoc = lAngleLoc;
1646 typeArgsRAngleLoc = rAngleLoc;
1651 if (numTypeDeclsResolved == identifiers.size())
1652 return resolvedAsTypeDecls();
1658 for (
unsigned i = 0, n = identifiers.size(); i != n; ++i) {
1661 if (protocols[i] || typeDecls[i]) {
1667 if (protocols[i] && typeDecls[i])
1690 identifiers[i], identifierLocs[i],
1691 protocols[i] !=
nullptr);
1699 ObjCTypeArgOrProtocolValidatorCCC CCC(Context, lookupKind);
1707 corrected,
SemaRef.
PDiag(diag::err_undeclared_protocol_suggest)
1710 protocols[i] = proto;
1711 ++numProtocolsResolved;
1721 typeDecls[i] = typeDecl;
1722 ++numTypeDeclsResolved;
1730 SemaRef.
PDiag(diag::err_unknown_type_or_class_name_suggest)
1731 << identifiers[i] <<
true);
1733 typeDecls[i] = objcClass;
1734 ++numTypeDeclsResolved;
1740 Diag(identifierLocs[i],
1743 ? diag::err_undeclared_protocol
1744 : diag::err_unknown_typename))
1753 if (numProtocolsResolved == identifiers.size())
1754 return resolvedAsProtocols();
1757 assert(numTypeDeclsResolved == identifiers.size() &&
"Not all types?");
1758 return resolvedAsTypeDecls();
1769 llvm::DenseMap<Selector, const ObjCMethodDecl*> MethodMap;
1770 for (
auto *MD : ID->methods())
1771 MethodMap[MD->getSelector()] = MD;
1773 if (MethodMap.empty())
1775 for (
const auto *Method : CAT->
methods()) {
1776 const ObjCMethodDecl *&PrevMethod = MethodMap[Method->getSelector()];
1780 Diag(Method->getLocation(), diag::err_duplicate_method_decl)
1781 << Method->getDeclName();
1799 IdentPair.second, AtProtocolLoc, PrevDecl);
1810 DeclsInGroup.push_back(PDecl);
1820 Decl *
const *ProtoRefs,
unsigned NumProtoRefs,
1831 diag::err_category_forward_interface,
1832 CategoryName ==
nullptr)) {
1837 AtInterfaceLoc, ClassLoc, CategoryLoc,
1838 CategoryName, IDecl, typeParamList);
1843 Diag(ClassLoc, diag::err_undef_interface) << ClassName;
1849 Diag(ClassLoc, diag::err_class_extension_after_impl) << ClassName;
1851 diag::note_implementation_declared);
1859 Diag(CategoryLoc, diag::warn_dup_category_def)
1860 << ClassName << CategoryName;
1861 Diag(
Previous->getLocation(), diag::note_previous_definition);
1866 if (typeParamList) {
1869 SemaRef, prevTypeParamList, typeParamList,
1870 CategoryName ? TypeParamListContext::Category
1871 : TypeParamListContext::Extension))
1872 typeParamList =
nullptr;
1875 diag::err_objc_parameterized_category_nonclass)
1876 << (CategoryName !=
nullptr)
1880 typeParamList =
nullptr;
1885 ClassLoc, CategoryLoc, CategoryName, IDecl,
1898 NumProtoRefs, ProtoLocs);
1900 ProtoLocs, Context);
1904 NumProtoRefs, Context);
1929 ClassLoc, CatLoc, CatName, IDecl,
1937 ClassLoc, AtCatImplLoc, CatLoc);
1940 Diag(ClassLoc, diag::err_undef_interface) << ClassName;
1944 diag::err_undef_interface)) {
1956 if (IDecl && IDecl->
hasAttr<ObjCRuntimeVisibleAttr>()) {
1957 Diag(ClassLoc, diag::err_objc_runtime_visible_category)
1964 Diag(ClassLoc, diag::err_dup_implementation_category) << ClassName
1967 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{};
2017 Diag(ClassLoc, diag::warn_undef_interface) << ClassName;
2023 if (SuperClassname) {
2028 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
2029 Diag(SuperClassLoc, diag::err_redefinition_different_kind)
2033 SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
2037 Diag(SuperClassLoc, diag::err_undef_superclass)
2038 << SuperClassname << ClassName;
2042 Diag(SuperClassLoc, diag::err_conflicting_super_class)
2058 nullptr, ClassLoc,
true);
2081 ClassLoc, AtClassImplLoc, SuperClassLoc);
2094 Diag(ClassLoc, diag::err_dup_implementation_class) << ClassName;
2096 diag::note_previous_definition);
2110 Diag(ClassLoc, diag::err_objc_runtime_visible_subclass)
2123 DeclsInGroup.reserve(Decls.size() + 1);
2125 for (
unsigned i = 0, e = Decls.size(); i != e; ++i) {
2126 Decl *Dcl = Decls[i];
2131 DeclsInGroup.push_back(Dcl);
2134 DeclsInGroup.push_back(ObjCImpDecl);
2142 assert(ImpDecl &&
"missing implementation decl");
2153 for (
unsigned i = 0, e = numIvars; i != e; ++i) {
2170 assert(ivars &&
"missing @implementation ivars");
2174 for (
unsigned i = 0; i < numIvars; i++) {
2179 Diag(ClsIvar->getLocation(), diag::note_previous_definition);
2187 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
2204 for (; numIvars > 0 && IVI != IVE; ++IVI) {
2207 assert (ImplIvar &&
"missing implementation ivar");
2208 assert (ClsIvar &&
"missing class ivar");
2220 diag::err_conflicting_ivar_bitwidth)
2223 diag::note_previous_definition);
2235 Diag(ivars[j]->getLocation(), diag::err_inconsistent_ivar_count);
2236 else if (IVI != IVE)
2237 Diag(IVI->getLocation(), diag::err_inconsistent_ivar_count);
2265 std::string FixItStr;
2266 llvm::raw_string_ostream Out(FixItStr);
2277 S.
Diag(MethodLoc, diag::note_method_declared_at) << method;
2353 (y &
~Decl::OBJC_TQ_CSNullability);
2359 bool IsProtocolMethodDecl,
2360 bool IsOverridingMode,
2362 if (IsProtocolMethodDecl &&
2368 ? diag::warn_conflicting_overriding_ret_type_modifiers
2369 : diag::warn_conflicting_ret_type_modifiers))
2378 if (Warn && IsOverridingMode &&
2386 diag::warn_conflicting_nullability_attr_overriding_ret_types)
2403 IsOverridingMode ? diag::warn_conflicting_overriding_ret_types
2404 : diag::warn_conflicting_ret_types;
2420 IsOverridingMode ? diag::warn_non_covariant_overriding_ret_types
2421 : diag::warn_non_covariant_ret_types;
2430 ? diag::note_previous_declaration
2431 : diag::note_previous_definition)
2441 bool IsProtocolMethodDecl,
2442 bool IsOverridingMode,
2444 if (IsProtocolMethodDecl &&
2448 if (IsOverridingMode)
2450 diag::warn_conflicting_overriding_param_modifiers)
2454 diag::warn_conflicting_param_modifiers)
2466 if (Warn && IsOverridingMode &&
2470 diag::warn_conflicting_nullability_attr_overriding_param_types)
2485 IsOverridingMode ? diag::warn_conflicting_overriding_param_types
2486 : diag::warn_conflicting_param_types;
2502 IsOverridingMode ? diag::warn_non_contravariant_overriding_param_types
2503 : diag::warn_non_contravariant_param_types;
2509 << MethodImpl->
getDeclName() << IfaceTy << ImplTy;
2511 (IsOverridingMode ? diag::note_previous_declaration
2512 : diag::note_previous_definition))
2523 if (implFamily == declFamily)
return false;
2535 unsigned errorID = diag::err_arc_lost_method_convention;
2536 unsigned noteID = diag::note_arc_lost_method_convention;
2539 family = implFamily;
2540 errorID = diag::err_arc_gained_method_convention;
2541 noteID = diag::note_arc_gained_method_convention;
2545 enum FamilySelector {
2546 F_alloc, F_copy, F_mutableCopy = F_copy, F_init, F_new
2548 FamilySelector familySelector = FamilySelector();
2551 case OMF_None: llvm_unreachable(
"logic error, no method convention");
2565 case OMF_init: familySelector = F_init;
break;
2566 case OMF_alloc: familySelector = F_alloc;
break;
2567 case OMF_copy: familySelector = F_copy;
break;
2569 case OMF_new: familySelector = F_new;
break;
2572 enum ReasonSelector { R_NonObjectReturn, R_UnrelatedReturn };
2573 ReasonSelector reasonSelector;
2578 reasonSelector = R_UnrelatedReturn;
2580 reasonSelector = R_NonObjectReturn;
2584 S.
Diag(
decl->getLocation(), noteID) <<
int(familySelector) <<
int(reasonSelector);
2591 bool IsProtocolMethodDecl) {
2597 IsProtocolMethodDecl,
false,
true);
2602 IM != EM && IF != EF; ++IM, ++IF) {
2604 IsProtocolMethodDecl,
false,
true);
2609 diag::warn_conflicting_variadic);
2616 bool IsProtocolMethodDecl) {
2624 IM != EM && IF != EF; ++IM, ++IF) {
2626 IsProtocolMethodDecl,
true,
true);
2631 diag::warn_conflicting_overriding_variadic);
2640 bool IsProtocolMethodDecl) {
2650 if (MethodDecl->
hasAttr<UnavailableAttr>() ||
2651 MethodDecl->
hasAttr<DeprecatedAttr>())
2655 IsProtocolMethodDecl,
false,
false);
2660 IM != EM && IF != EF; ++IM, ++IF) {
2662 *IF, IsProtocolMethodDecl,
false,
false);
2674 diag::warn_category_method_impl_match);
2691 if (PDecl->
hasAttr<ObjCExplicitProtocolImplAttr>())
2693 for (
const auto *PI : PDecl->
protocols())
2719 : dyn_cast<ObjCInterfaceDecl>(CDecl);
2720 assert (IDecl &&
"CheckProtocolMethodDefs - IDecl is null");
2736 if (PDecl->
hasAttr<ObjCExplicitProtocolImplAttr>()) {
2737 if (!ProtocolsExplictImpl) {
2759 if (InsMap.count(fISelector))
2778 if (method->getImplementationControl() !=
2780 !method->isPropertyAccessor() &&
2781 !InsMap.count(method->getSelector()) &&
2783 method->getSelector(),
true ,
2796 method->getSelector(),
true ,
2798 if (
C || MethodInClass->isPropertyAccessor())
2800 unsigned DIAG = diag::warn_unimplemented_protocol_method;
2808 if (method->getImplementationControl() !=
2810 !ClsMap.count(method->getSelector()) &&
2812 method->getSelector(),
false ,
2814 true ,
nullptr ))) {
2822 unsigned DIAG = diag::warn_unimplemented_protocol_method;
2831 ProtocolsExplictImpl);
2841 bool WarnCategoryMethodImpl) {
2845 if (!InsMapSeen.insert(I->getSelector()).second)
2847 if (!I->isPropertyAccessor() &&
2848 !InsMap.count(I->getSelector())) {
2851 diag::warn_undef_method_impl);
2857 "Expected to find the method through lookup as well");
2859 if (ImpMethodDecl) {
2863 if (!WarnCategoryMethodImpl)
2865 isa<ObjCProtocolDecl>(CDecl));
2866 else if (!I->isPropertyAccessor())
2875 if (!ClsMapSeen.insert(I->getSelector()).second)
2877 if (!I->isPropertyAccessor() &&
2878 !ClsMap.count(I->getSelector())) {
2881 diag::warn_undef_method_impl);
2886 "Expected to find the method through lookup as well");
2888 if (ImpMethodDecl) {
2892 if (!WarnCategoryMethodImpl)
2894 isa<ObjCProtocolDecl>(CDecl));
2895 else if (!I->isPropertyAccessor())
2904 for (
auto *PI : PD->protocols())
2906 IMPDecl, PI, IncompleteImpl,
false,
2907 WarnCategoryMethodImpl);
2914 if (!WarnCategoryMethodImpl) {
2915 for (
auto *Cat : I->visible_categories())
2917 IMPDecl, Cat, IncompleteImpl,
2918 ImmediateClass && Cat->IsClassExtension(),
2919 WarnCategoryMethodImpl);
2922 for (
auto *Ext : I->visible_extensions())
2924 IMPDecl, Ext, IncompleteImpl,
false,
2925 WarnCategoryMethodImpl);
2929 for (
auto *PI : I->all_referenced_protocols())
2931 IMPDecl, PI, IncompleteImpl,
false,
2932 WarnCategoryMethodImpl);
2936 if (!WarnCategoryMethodImpl && I->getSuperClass())
2939 I->getSuperClass(), IncompleteImpl,
false);
2970 if (SuperIDecl && SuperIDecl->
lookupMethod(Sel,
false))
2974 if (InsMap.empty() && ClsMap.empty())
2978 bool IncompleteImpl =
false;
2981 IncompleteImpl,
false,
2987 bool IncompleteImpl) {
2992 InsMap.insert(I->getSelector());
3000 const auto *
P = PImpl->getPropertyDecl();
3003 InsMap.insert(
P->getGetterName());
3004 if (!
P->getSetterName().isNull())
3005 InsMap.insert(
P->getSetterName());
3012 bool SynthesizeProperties =
getLangOpts().ObjCDefaultSynthProperties &&
3014 !IDecl->isObjCRequiresPropertyDefs();
3023 ClsMap.insert(I->getSelector());
3030 IncompleteImpl,
true);
3035 dyn_cast<ObjCCategoryImplDecl>(IMPDecl))
3046 for (
auto *PI : I->all_referenced_protocols())
3048 ClsMap, I, ExplicitImplProtocols);
3052 if (!
C->IsClassExtension()) {
3053 for (
auto *
P :
C->protocols())
3055 ClsMap, CDecl, ExplicitImplProtocols);
3060 llvm_unreachable(
"invalid ObjCContainerDecl type.");
3069 for (
unsigned i = 0; i != NumElts; ++i) {
3074 if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
3084 Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i];
3092 Diag(AtClassLoc, diag::warn_forward_class_redefinition)
3102 = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
3124 if (PrevIDecl && TypeParams) {
3128 SemaRef, PrevTypeParams, TypeParams,
3129 TypeParamListContext::ForwardDeclaration)) {
3130 TypeParams =
nullptr;
3134 Diag(IdentLocs[i], diag::err_objc_parameterized_forward_class)
3137 Diag(Def->getLocation(), diag::note_defined_here)
3140 TypeParams =
nullptr;
3146 PrevIDecl, IdentLocs[i]);
3154 DeclsInGroup.push_back(IDecl);
3162 const Type *left,
const Type *right);
3172 if (left == right)
return true;
3196 if (isa<VectorType>(left))
return isa<VectorType>(right);
3197 if (isa<VectorType>(right))
return false;
3220 return (leftSK == rightSK);
3226 assert(lt && rt && lt != rt);
3228 if (!isa<RecordType>(lt) || !isa<RecordType>(rt))
return false;
3229 RecordDecl *left = cast<RecordType>(lt)->getDecl();
3230 RecordDecl *right = cast<RecordType>(rt)->getDecl();
3236 if ((isa<CXXRecordDecl>(left) && !cast<CXXRecordDecl>(left)->isPOD()) ||
3237 (isa<CXXRecordDecl>(right) && !cast<CXXRecordDecl>(right)->isPOD()))
3252 for (; li != le && ri != re; ++li, ++ri) {
3253 if (!
matchTypes(Context, strategy, li->getType(), ri->getType()))
3256 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 SemaObjC::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,
const ObjCObjectType *TypeBound) {
3531 if (M->getMethod() && M->getMethod()->isUnconditionallyVisible()) {
3533 Methods.push_back(M->getMethod());
3537 if (!Methods.empty())
3538 return Methods.size() > 1;
3547 if (M->getMethod() && M->getMethod()->isUnconditionallyVisible()) {
3549 Methods.push_back(M->getMethod());
3552 return Methods.size() > 1;
3560 FilteredMethods.push_back(BestMethod);
3562 for (
auto *M : Methods)
3563 if (M != BestMethod && !M->
hasAttr<UnavailableAttr>())
3564 FilteredMethods.push_back(M);
3566 if (FilteredMethods.size() > 1)
3581 bool receiverIdOrClass,
3591 ObjCMethodList &MethList = instance ? Pos->second.first : Pos->second.second;
3594 if (M->getMethod() && M->getMethod()->isUnconditionallyVisible())
3595 return M->getMethod();
3602 bool receiverIdOrClass) {
3604 bool issueDiagnostic =
false, issueError =
false;
3608 bool strictSelectorMatch =
3609 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 &&
3743 SemaRef, M->getMethod()->getSelector(), ObjectType))
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 &&
3755 SemaRef, M->getMethod()->getSelector(), ObjectType))
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:
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);
3993 assert(AtEnd.
isValid() &&
"Invalid location for '@end'");
3996 Decl *ClassDecl = OCD;
3998 bool isInterfaceDeclKind =
3999 isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl)
4000 || isa<ObjCProtocolDecl>(ClassDecl);
4001 bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl);
4008 for (
auto *PropImpl : OID->property_impls()) {
4009 if (
auto *Getter = PropImpl->getGetterMethodDecl())
4010 if (Getter->isSynthesizedAccessorStub())
4011 OID->addDecl(Getter);
4012 if (
auto *Setter = PropImpl->getSetterMethodDecl())
4013 if (Setter->isSynthesizedAccessorStub())
4014 OID->addDecl(Setter);
4019 llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
4020 llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;
4022 for (
unsigned i = 0, e = allMethods.size(); i != e; i++ ) {
4024 cast_or_null<ObjCMethodDecl>(allMethods[i]);
4026 if (!Method)
continue;
4032 if ((isInterfaceDeclKind && PrevMethod && !
match)
4033 || (checkIdenticalMethods &&
match)) {
4056 if ((isInterfaceDeclKind && PrevMethod && !
match)
4057 || (checkIdenticalMethods &&
match)) {
4076 if (isa<ObjCInterfaceDecl>(ClassDecl)) {
4083 if (
C->IsClassExtension()) {
4092 if (CDecl->getIdentifier())
4096 for (
auto *I : CDecl->properties())
4098 CDecl->setAtEndRange(AtEnd);
4101 IC->setAtEndRange(AtEnd);
4108 for (
const auto *Ext : IDecl->visible_extensions()) {
4109 for (
const auto *
Property : Ext->instance_properties()) {
4112 = IC->FindPropertyImplDecl(
Property->getIdentifier(),
4114 if (PIDecl->getPropertyImplementation()
4118 for (
const auto *Ext : IDecl->visible_extensions()) {
4120 Ext->getInstanceMethod(
Property->getGetterName()))
4121 GetterMethod->setPropertyAccessor(
true);
4124 = Ext->getInstanceMethod(
Property->getSetterName()))
4125 SetterMethod->setPropertyAccessor(
true);
4133 if (IDecl->hasDesignatedInitializers())
4138 bool HasRootClassAttr = IDecl->hasAttr<ObjCRootClassAttr>();
4139 if (IDecl->getSuperClass() ==
nullptr) {
4142 if (!HasRootClassAttr) {
4145 Diag(DeclLoc, diag::warn_objc_root_class_missing)
4146 << IDecl->getIdentifier();
4154 Diag(SuperClassLoc, diag::note_objc_needs_superclass)
4157 Diag(SuperClassLoc, diag::note_objc_needs_superclass);
4160 }
else if (HasRootClassAttr) {
4162 Diag(IDecl->getLocation(), diag::err_objc_root_class_subclass);
4170 if (IDecl->hasAttr<ObjCSubclassingRestrictedAttr>() &&
4171 Super->hasAttr<ObjCSubclassingRestrictedAttr>()) {
4172 Diag(IC->getLocation(), diag::err_restricted_superclass_mismatch);
4173 Diag(Super->getLocation(), diag::note_class_declared);
4177 if (IDecl->hasAttr<ObjCClassStubAttr>())
4178 Diag(IC->getLocation(), diag::err_implementation_of_class_stub);
4181 while (IDecl->getSuperClass()) {
4183 IDecl = IDecl->getSuperClass();
4189 dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {
4190 CatImplClass->setAtEndRange(AtEnd);
4196 = IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier())) {
4200 }
else if (
const auto *IntfDecl = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
4202 if (!IntfDecl->hasAttr<ObjCSubclassingRestrictedAttr>() &&
4203 Super->hasAttr<ObjCSubclassingRestrictedAttr>()) {
4204 Diag(IntfDecl->getLocation(), diag::err_restricted_superclass_mismatch);
4205 Diag(Super->getLocation(), diag::note_class_declared);
4209 if (IntfDecl->hasAttr<ObjCClassStubAttr>() &&
4210 !IntfDecl->hasAttr<ObjCSubclassingRestrictedAttr>())
4211 Diag(IntfDecl->getLocation(), diag::err_class_stub_subclassing_mismatch);
4214 if (isInterfaceDeclKind) {
4216 for (
unsigned i = 0, e = allTUVars.size(); i != e; i++) {
4219 if (
VarDecl *VDecl = dyn_cast<VarDecl>(*I)) {
4220 if (!VDecl->hasExternalStorage())
4221 Diag(VDecl->getLocation(), diag::err_objc_var_decl_inclass);
4227 for (
unsigned i = 0, e = allTUVars.size(); i != e; i++) {
4230 (*I)->setTopLevelDeclInObjCContainer();
4259 if (ResultObjectType->isObjCIdType() ||
4260 ResultObjectType->isObjCQualifiedIdType())
4265 = ResultObjectType->getInterfaceDecl()) {
4271 if (ResultClass->isSuperClassOf(CurrentClass))
4287class OverrideSearch {
4320 dyn_cast<ObjCCategoryDecl>(container)) {
4321 searchFromContainer(container);
4325 searchFromContainer(container);
4329 typedef decltype(Overridden)::iterator iterator;
4330 iterator begin()
const {
return Overridden.begin(); }
4331 iterator end()
const {
return Overridden.end(); }
4338#define OBJCCONTAINER(type, base) \
4340 searchFrom(cast<type##Decl>(container)); \
4342#define ABSTRACT_DECL(expansion)
4343#define DECL(type, base) \
4345#include "clang/AST/DeclNodes.inc"
4346 llvm_unreachable(
"not an ObjC container!");
4406 for (
const auto *Proto : protocols)
4418 Overridden.insert(meth);
4428 searchFromContainer(container);
4436 const auto *
attr = overridden->
getAttr<ObjCDirectAttr>();
4438 Diag(
attr->getLocation(), diag::note_previous_declaration);
4440 const auto *
attr = method->
getAttr<ObjCDirectAttr>();
4441 Diag(
attr->getLocation(), diag::err_objc_direct_on_override)
4453 auto IsMethodInCurrentClass = [CurrentClass](
const ObjCMethodDecl *M) {
4455 return M->getClassInterface()->getCanonicalDecl() ==
4459 OverrideSearch overrides(
SemaRef, ObjCMethod);
4465 bool hasOverriddenMethodsInBaseOrProtocol =
false;
4467 if (!hasOverriddenMethodsInBaseOrProtocol) {
4468 if (isa<ObjCProtocolDecl>(overridden->getDeclContext()) ||
4469 !IsMethodInCurrentClass(overridden) || overridden->isOverriding()) {
4471 hasOverriddenMethodsInBaseOrProtocol =
true;
4485 unsigned CategCount = List.getBits();
4486 if (CategCount > 0) {
4489 if (CategCount > 1 ||
4490 !isa<ObjCCategoryImplDecl>(overridden->getDeclContext())) {
4491 OverrideSearch overrides(
SemaRef, overridden);
4493 if (isa<ObjCProtocolDecl>(SuperOverridden->getDeclContext()) ||
4494 !IsMethodInCurrentClass(SuperOverridden)) {
4496 hasOverriddenMethodsInBaseOrProtocol =
true;
4497 overridden->setOverriding(
true);
4514 if (ObjCMethod->
isImplicit() && overridden->isImplicit())
4521 isa<ObjCProtocolDecl>(overridden->getDeclContext()));
4523 if (CurrentClass && overridden->
getDeclContext() != CurrentClass &&
4524 isa<ObjCInterfaceDecl>(overridden->getDeclContext()) &&
4529 PrevE = overridden->param_end();
4530 for (; ParamI != E && PrevI != PrevE; ++ParamI, ++PrevI) {
4531 assert(PrevI != overridden->param_end() &&
"Param mismatch");
4537 Diag((*ParamI)->getLocation(), diag::ext_typecheck_base_super)
4539 Diag(overridden->getLocation(), diag::note_previous_declaration);
4546 ObjCMethod->
setOverriding(hasOverriddenMethodsInBaseOrProtocol);
4556 bool prevUsesCSKeyword) {
4558 auto nullability =
type->getNullability();
4562 if (nullability.has_value() == prevNullability.has_value()) {
4568 if (*nullability == *prevNullability)
4572 S.
Diag(loc, diag::err_nullability_conflicting)
4595 if (prevMethod->
hasAttr<ObjCRequiresSuperAttr>() &&
4596 !method->
hasAttr<ObjCRequiresSuperAttr>()) {
4599 ObjCRequiresSuperAttr::CreateImplicit(S.
Context,
4616 unsigned numPrevParams = prevMethod->
param_size();
4617 for (
unsigned i = 0, n = std::min(numParams, numPrevParams); i != n; ++i) {
4637 llvm::Triple::x86 &&
4638 "x86-specific check invoked for a different target");
4642 if (
P->getType()->isVectorType()) {
4643 Loc =
P->getBeginLoc();
4659 VersionTuple AcceptedInVersion;
4660 if (Triple.getOS() == llvm::Triple::IOS)
4661 AcceptedInVersion = VersionTuple(9);
4662 else if (Triple.isMacOSX())
4663 AcceptedInVersion = VersionTuple(10, 11);
4669 SemaRef.
Diag(
Loc, diag::err_objc_method_unsupported_param_ret_type)
4672 << (Triple.isMacOSX() ?
"macOS 10.11" :
"iOS 9");
4677 CD->
hasAttr<ObjCDirectMembersAttr>()) {
4688 bool diagnosed =
false;
4691 if (diagnosed || IMD->isImplicit())
4697 S.
Diag(IMD->getLocation(), diag::note_previous_declaration);
4715 if (
auto *IMD = IDecl->
getMethod(Sel, isInstance))
4718 if (Impl != ImpDecl)
4723 if (
auto *IMD = Cat->getMethod(Sel, isInstance))
4725 else if (
auto CatImpl = Cat->getImplementation())
4726 if (CatImpl != ImpDecl)
4727 if (
auto *IMD = Cat->getMethod(Sel, isInstance))
4740 bool isVariadic,
bool MethodDefinition) {
4744 Diag(MethodLoc, diag::err_missing_method_context);
4751 bool HasRelatedResultType =
false;
4759 QualType bareResultType = resultDeclType;
4764 Diag(MethodLoc, diag::warn_missing_method_return_type)
4769 Context, MethodLoc, EndLoc, Sel, resultDeclType, ReturnTInfo,
4773 MethodDeclKind == tok::objc_optional
4776 HasRelatedResultType);
4780 for (
unsigned i = 0, e = Sel.
getNumArgs(); i != e; ++i) {
4784 if (!ArgInfo[i].
Type) {
4797 if (S->isDeclScope(PrevDecl)) {
4798 Diag(ArgInfo[i].NameLoc,
4799 (MethodDefinition ? diag::warn_method_param_redefinition
4800 : diag::warn_method_param_declaration))
4803 diag::note_previous_declaration);
4813 ArgInfo[i].Name, ArgType, DI,
SC_None);
4826 if (Param->
hasAttr<BlocksAttr>()) {
4833 Params.push_back(Param);
4836 for (
unsigned i = 0, e = CNumArgs; i != e; ++i) {
4837 ParmVarDecl *Param = cast<ParmVarDecl>(CParamInfo[i].Param);
4846 Params.push_back(Param);
4859 if (
ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(ClassDecl)) {
4860 if (MethodType == tok::minus) {
4861 PrevMethod = ImpDecl->getInstanceMethod(Sel);
4862 ImpDecl->addInstanceMethod(ObjCMethod);
4864 PrevMethod = ImpDecl->getClassMethod(Sel);
4865 ImpDecl->addClassMethod(ObjCMethod);
4874 if (
auto *Setter = PropertyImpl->getSetterMethodDecl())
4875 if (Setter->getSelector() == Sel &&
4877 assert(Setter->isSynthesizedAccessorStub() &&
"autosynth stub expected");
4878 PropertyImpl->setSetterMethodDecl(ObjCMethod);
4880 if (
auto *Getter = PropertyImpl->getGetterMethodDecl())
4881 if (Getter->getSelector() == Sel &&
4883 assert(Getter->isSynthesizedAccessorStub() &&
"autosynth stub expected");
4884 PropertyImpl->setGetterMethodDecl(ObjCMethod);
4898 const auto *
attr = CanonicalMD->
getAttr<ObjCDirectAttr>();
4900 ObjCDirectAttr::CreateImplicit(Context,
attr->getLocation()));
4907 if (
auto *IMD = IDecl->lookupMethod(ObjCMethod->
getSelector(),
4927 if (IDecl == IMD->getClassInterface()) {
4928 auto diagContainerMismatch = [&] {
4929 int decl = 0, impl = 0;
4931 if (
auto *Cat = dyn_cast<ObjCCategoryDecl>(IMD->getDeclContext()))
4932 decl = Cat->IsClassExtension() ? 1 : 2;
4934 if (isa<ObjCCategoryImplDecl>(ImpDecl))
4935 impl = 1 + (
decl != 0);
4938 diag::err_objc_direct_impl_decl_mismatch)
4940 Diag(IMD->getLocation(), diag::note_previous_declaration);
4944 const auto *
attr = ObjCMethod->
getAttr<ObjCDirectAttr>();
4946 diagContainerMismatch();
4947 }
else if (!IMD->isDirectMethod()) {
4948 Diag(
attr->getLocation(), diag::err_objc_direct_missing_on_decl);
4949 Diag(IMD->getLocation(), diag::note_previous_declaration);
4951 }
else if (IMD->isDirectMethod()) {
4952 const auto *
attr = IMD->getAttr<ObjCDirectAttr>();
4954 diagContainerMismatch();
4957 ObjCDirectAttr::CreateImplicit(Context,
attr->getLocation()));
4963 if (isa<ObjCCategoryImplDecl>(ImpDecl) && IMD->isOverriding() &&
4976 for (
auto *
C : IDecl->visible_categories())
4977 for (
auto &
P :
C->protocols())
4978 if (
auto *IMD =
P->lookupMethod(ObjCMethod->
getSelector(),
4981 IMD->parameters().size() &&
4982 "Methods have different number of parameters");
4983 auto OI = IMD->param_begin(), OE = IMD->param_end();
4985 for (; OI != OE; ++OI, ++NI)
4990 if (!isa<ObjCProtocolDecl>(ClassDecl)) {
4995 IDecl = cast<ObjCCategoryDecl>(ClassDecl)->getClassInterface();
5003 cast<DeclContext>(ClassDecl)->addDecl(ObjCMethod);
5019 if (!CurrentClass) {
5021 CurrentClass = Cat->getClassInterface();
5022 else if (
ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(ClassDecl))
5023 CurrentClass = Impl->getClassInterface();
5025 = dyn_cast<ObjCCategoryImplDecl>(ClassDecl))
5026 CurrentClass = CatImpl->getClassInterface();
5034 bool ARCError =
false;
5042 bool InferRelatedResultType =
false;
5068 if (InferRelatedResultType &&
5073 if (MethodDefinition &&
5079 if (
const auto *
attr = ObjCMethod->
getAttr<AvailabilityAttr>()) {
5082 Diag(
attr->getLocation(), diag::warn_availability_on_static_initializer)
5084 ObjCMethod->
dropAttr<AvailabilityAttr>();
5104 if (isa<TranslationUnitDecl>(
5108 Diag(D->
getLocation(), diag::err_objc_decls_may_only_appear_in_global_scope);
5123 Diag(DeclStart, diag::err_undef_interface) << ClassName;
5127 Diag(DeclStart, diag::err_atdef_nonfragile_interface);
5135 for (
unsigned i = 0; i < Ivars.size(); i++) {
5141 ID->getIdentifier(), ID->getType(),
5143 Decls.push_back(FD);
5148 D != Decls.end(); ++D) {
5169 Diag(IdLoc, diag::err_arg_with_address_space);
5181 Diag(IdLoc, diag::err_illegal_qualifiers_on_catch_parm);
5186 Diag(IdLoc, diag::err_catch_param_not_objc_type);
5189 Diag(IdLoc, diag::err_catch_param_not_objc_type);
5222 diag::err_invalid_thread)
5256 if (New->
hasAttr<BlocksAttr>())
5270 Ivars.push_back(Iv);
5280 for (
unsigned I = 0, N = Sels.size(); I != N; ++I)
5291 Selector Sel = SelectorAndLocation.first;
5294 Diag(
Loc, diag::warn_unimplemented_selector) << Sel;
5317 IV->getIdentifier());
5326class UnusedBackingIvarChecker
5333 bool InvokedSelfMethod;
5337 : S(S), Method(Method), IvarD(IvarD), AccessedIvar(
false),
5338 InvokedSelfMethod(
false) {
5344 AccessedIvar =
true;
5353 InvokedSelfMethod =
true;
5362 if (S->hasUnrecoverableErrorOccurred())
5366 unsigned DIAG = diag::warn_unused_property_backing_ivar;
5376 if (CurMethod->isSynthesizedAccessorStub())
5379 UnusedBackingIvarChecker Checker(
SemaRef, CurMethod, IV);
5380 Checker.TraverseStmt(CurMethod->getBody());
5381 if (Checker.AccessedIvar)
5388 if (!IV->
isReferenced() || !Checker.InvokedSelfMethod) {
5409 if (!
T.isConstQualified()) {
5413 NameLoc, diag::err_arc_array_param_no_ownership,
T,
false));
5415 Diag(NameLoc, diag::err_arc_array_param_no_ownership)
5429 bool DoTypoCorrection) {
5435 if (!IDecl && DoTypoCorrection) {
5461 unsigned kind = -1U;
5463 if (var->hasAttr<BlocksAttr>())
5465 else if (!var->hasLocalStorage())
5467 }
else if (isa<ObjCIvarDecl>(
decl)) {
5469 }
else if (isa<FieldDecl>(
decl)) {
5474 Diag(
decl->getLocation(), diag::err_arc_autoreleasing_var) << kind;
5478 if (!
type->isObjCLifetimeType())
5481 lifetime =
type->getObjCARCImplicitLifetime();
5489 var->getTLSKind()) {
5490 Diag(var->getLocation(), diag::err_arc_thread_ownership)
5513 for (
unsigned i = 0; i < ivars.size(); i++) {
5515 if (Field->isInvalidDecl())
5536 AllToInit.push_back(
Member);
5541 ->getAs<RecordType>()) {
5542 CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
5561 switch (ivarVisibility) {
5563 llvm_unreachable(
"Unknown visitibility kind");
5564 case tok::objc_private:
5566 case tok::objc_public:
5568 case tok::objc_protected:
5570 case tok::objc_package:
5604 Diag(
Loc, diag::err_ivar_reference_type);
5611 TInfo,
T,
Loc, diag::err_typecheck_ivar_variable_size))
5626 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
5630 EnclosingContext = IMPDecl->getClassInterface();
5631 assert(EnclosingContext &&
"Implementation has no class interface!");
5633 EnclosingContext = EnclosingDecl;
5637 Diag(
Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
5641 EnclosingContext = EnclosingDecl;
5647 II,
T, TInfo, ac, BitWidth);
5655 RedeclarationKind::ForVisibleRedeclaration);
5657 !isa<TagDecl>(PrevDecl)) {
5658 Diag(
Loc, diag::err_duplicate_member) << II;
5685 isa<ObjCInterfaceDecl>(EnclosingDecl))
5686 Diag(
Loc, diag::warn_ivars_in_interface);
Defines the clang::ASTContext interface.
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
#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 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, SemaObjC::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 SemaObjC::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 ObjCIvarDecl::AccessControl TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility)
TranslateIvarVisibility - Translate visibility from a token ID to an AST enum value.
static void CheckProtocolMethodDefs(Sema &S, ObjCImplDecl *Impl, ObjCProtocolDecl *PDecl, bool &IncompleteImpl, const SemaObjC::SelectorSet &InsMap, const SemaObjC::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 bool tryMatchRecordTypes(ASTContext &Context, SemaObjC::MethodMatchStrategy strategy, const Type *left, const Type *right)
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)
This file declares semantic analysis for Objective-C.
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
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
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.
Represents a C++ base or member initializer.
Represents a C++ destructor within a class.
Represents a C++ struct/union/class.
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".
bool isModulePrivateSpecified() const
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
void setInvalidType(bool Val=true)
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
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.
const IdentifierInfo * getIdentifier() const
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
This represents one expression.
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.
Describes the kind of initialization being performed, along with location information for tokens rela...
static InitializationKind CreateDefault(SourceLocation InitLoc)
Create a default initialization.
Describes the sequence of initializations required to initialize a given object or reference with a s...
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence.
Describes an entity that is being initialized.
static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent=nullptr, bool Implicit=false)
Create the initialization entity for a member subobject.
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.
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined.
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, const 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.
ObjCCategoryDecl * getCategoryDecl() const
static ObjCCategoryImplDecl * Create(ASTContext &C, DeclContext *DC, const IdentifierInfo *Id, ObjCInterfaceDecl *classInterface, SourceLocation nameLoc, SourceLocation atStartLoc, SourceLocation CategoryNameLoc)
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())
void setIvarInitializers(ASTContext &C, CXXCtorInitializer **initializers, unsigned numInitializers)
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
llvm::iterator_range< specific_decl_iterator< ObjCIvarDecl > > ivar_range
static ObjCInterfaceDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation atLoc, const IdentifierInfo *Id, ObjCTypeParamList *typeParamList, ObjCInterfaceDecl *PrevDecl, SourceLocation ClassLoc=SourceLocation(), bool isInternal=false)
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...
ObjCCategoryDecl * FindCategoryDeclaration(const IdentifierInfo *CategoryId) const
FindCategoryDeclaration - Finds category declaration in the list of categories for this class and ret...
ivar_iterator ivar_begin() const
void setImplementation(ObjCImplementationDecl *ImplD)
known_categories_range known_categories() const
void setSuperClass(TypeSourceInfo *superClass)
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()
static ObjCIvarDecl * Create(ASTContext &C, ObjCContainerDecl *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, AccessControl ac, Expr *BW=nullptr, bool synthesized=false)
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.
The basic abstraction for the target Objective-C runtime.
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.
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)
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_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
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, const 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
A generic diagnostic builder for errors which may or may not be deferred.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
ASTContext & getASTContext() const
const LangOptions & getLangOpts() const
DiagnosticsEngine & getDiagnostics() const
std::pair< iterator, bool > insert(std::pair< Selector, Lists > &&Val)
iterator find(Selector Sel)
llvm::DenseMap< Selector, Lists >::iterator iterator
std::pair< ObjCMethodList, ObjCMethodList > Lists
Decl * ActOnIvar(Scope *S, SourceLocation DeclStart, Declarator &D, Expr *BitWidth, tok::ObjCKeywordKind visibility)
ActOnIvar - Each ivar field of an objective-c class is passed into this in order to create an IvarDec...
void ActOnStartOfObjCMethodDef(Scope *S, Decl *D)
ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible and user declared,...
void ActOnSuperClassOfClassInterface(Scope *S, SourceLocation AtInterfaceLoc, ObjCInterfaceDecl *IDecl, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *SuperName, SourceLocation SuperLoc, ArrayRef< ParsedType > SuperTypeArgs, SourceRange SuperTypeArgsRange)
VarDecl * BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, bool Invalid=false)
Build a type-check a new Objective-C exception variable declaration.
void DiagnoseUnusedBackingIvarInAccessor(Scope *S, const ObjCImplementationDecl *ImplD)
DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which backs the property is n...
void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation)
SetIvarInitializers - This routine builds initialization ASTs for the Objective-C implementation whos...
void WarnExactTypedMethods(ObjCMethodDecl *Method, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl)
WarnExactTypedMethods - This routine issues a warning if method implementation declaration matches ex...
const ObjCMethodDecl * SelectorsForTypoCorrection(Selector Sel, QualType ObjectType=QualType())
void ProcessPropertyDecl(ObjCPropertyDecl *property)
Process the specified property declaration and create decls for the setters and getters as needed.
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.
void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method)
Add the given method to the list of globally-known methods.
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 diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl)
Diagnose any null-resettable synthesized setters.
void updateOutOfDateSelector(Selector Sel)
void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList)
ObjCImplementationDecl * ActOnStartClassImplementation(SourceLocation AtClassImplLoc, const IdentifierInfo *ClassName, SourceLocation ClassLoc, const IdentifierInfo *SuperClassname, SourceLocation SuperClassLoc, const ParsedAttributesView &AttrList)
bool AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod, SourceRange R, bool receiverIdOrClass, SmallVectorImpl< ObjCMethodDecl * > &Methods)
Decl * ActOnObjCExceptionDecl(Scope *S, Declarator &D)
bool CheckObjCDeclScope(Decl *D)
Checks that the Objective-C declaration is declared in the global scope.
DeclResult actOnObjCTypeParam(Scope *S, ObjCTypeParamVariance variance, SourceLocation varianceLoc, unsigned index, IdentifierInfo *paramName, SourceLocation paramLoc, SourceLocation colonLoc, ParsedType typeBound)
ObjCIvarDecl * GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method, const ObjCPropertyDecl *&PDecl) const
GetIvarBackingPropertyAccessor - If method is a property setter/getter and it property has a backing ...
bool CheckARCMethodDecl(ObjCMethodDecl *method)
Check a method declaration for compatibility with the Objective-C ARC conventions.
ObjCContainerKind getObjCContainerKind() const
ObjCInterfaceDecl * getObjCInterfaceDecl(const IdentifierInfo *&Id, SourceLocation IdLoc, bool TypoCorrection=false)
Look for an Objective-C class in the translation unit.
ObjCMethodDecl * LookupMethodInObjectType(Selector Sel, QualType Ty, bool IsInstance)
LookupMethodInType - Look up a method in an ObjCObjectType.
DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl, ArrayRef< Decl * > Decls)
ObjCContainerDecl * getObjCDeclContext() const
void WarnConflictingTypedMethods(ObjCMethodDecl *Method, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl)
bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method, const ObjCMethodDecl *PrevMethod, MethodMatchStrategy strategy=MMS_strict)
MatchTwoMethodDeclarations - Checks if two methods' type match and returns true, or false,...
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)
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...
llvm::MapVector< Selector, SourceLocation > ReferencedSelectors
Method selectors used in a @selector expression.
void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D)
void ActOnObjCContainerFinishDefinition()
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 DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID)
DiagnoseDuplicateIvars - Check for duplicate ivars in the entire class at the start of @implementatio...
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 CheckConflictingOverridingMethod(ObjCMethodDecl *Method, ObjCMethodDecl *Overridden, bool IsProtocolMethodDecl)
ObjCTypeParamList * actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc, ArrayRef< Decl * > typeParams, SourceLocation rAngleLoc)
ObjCCategoryDecl * ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc, const IdentifierInfo *ClassName, SourceLocation ClassLoc, ObjCTypeParamList *typeParamList, const IdentifierInfo *CategoryName, SourceLocation CategoryLoc, Decl *const *ProtoRefs, unsigned NumProtoRefs, const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList)
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...
bool CheckForwardProtocolDeclarationForCircularDependency(IdentifierInfo *PName, SourceLocation &PLoc, SourceLocation PrevLoc, const ObjCList< ObjCProtocolDecl > &PList)
void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCContainerDecl *CDecl, bool SynthesizeProperties)
DiagnoseUnimplementedProperties - This routine warns on those properties which must be implemented by...
void AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl)
AtomicPropertySetterGetterRules - This routine enforces the rule (via warning) when atomic property h...
void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT, ObjCInterfaceDecl *ID)
DiagnoseClassExtensionDupMethods - Check for duplicate declaration of a class method in its extension...
ObjCCategoryImplDecl * ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc, const IdentifierInfo *ClassName, SourceLocation ClassLoc, const IdentifierInfo *CatName, SourceLocation CatLoc, const ParsedAttributesView &AttrList)
ActOnStartCategoryImplementation - Perform semantic checks on the category implementation declaration...
bool inferObjCARCLifetime(ValueDecl *decl)
void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, const ObjCMethodDecl *Overridden)
Check whether the given new method is a valid override of the given overridden method,...
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 DiagnoseMissingDesignatedInitOverrides(const ObjCImplementationDecl *ImplD, const ObjCInterfaceDecl *IFD)
void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI, SmallVectorImpl< ObjCIvarDecl * > &Ivars)
CollectIvarsToConstructOrDestruct - Collect those ivars which require initialization.
DeclGroupPtrTy ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc, ArrayRef< IdentifierLocPair > IdentList, const ParsedAttributesView &attrList)
ActOnForwardProtocolDeclaration - Handle @protocol foo;.
ObjCProtocolDecl * LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Find the protocol with the given name, if any.
QualType AdjustParameterTypeForObjCAutoRefCount(QualType T, SourceLocation NameLoc, TypeSourceInfo *TSInfo)
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
ObjCProtocolDecl * ActOnStartProtocolInterface(SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc, Decl *const *ProtoRefNames, unsigned NumProtoRefs, const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList, SkipBodyInfo *SkipBody)
Decl * ActOnAtEnd(Scope *S, SourceRange AtEnd, ArrayRef< Decl * > allMethods=std::nullopt, ArrayRef< DeclGroupPtrTy > allTUVars=std::nullopt)
ResultTypeCompatibilityKind
Describes the compatibility of a result type with its method.
void DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl< ObjCMethodDecl * > &Methods, Selector Sel, SourceRange R, bool receiverIdOrClass)
DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc, IdentifierInfo **IdentList, SourceLocation *IdentLocs, ArrayRef< ObjCTypeParamList * > TypeParamLists, unsigned NumElts)
void ReadMethodPool(Selector Sel)
Read the contents of the method pool for a given selector from external storage.
void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart, const IdentifierInfo *ClassName, SmallVectorImpl< Decl * > &Decls)
Called whenever @defs(ClassName) is encountered in the source.
void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false)
AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId, SourceLocation ProtocolLoc, IdentifierInfo *TypeArgId, SourceLocation TypeArgLoc, bool SelectProtocolFirst=false)
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.
void CheckObjCMethodDirectOverrides(ObjCMethodDecl *method, ObjCMethodDecl *overridden)
void DiagnoseUseOfUnimplementedSelectors()
void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP)
CheckCategoryVsClassMethodMatches - Checks that methods implemented in category matches with those im...
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...
void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod, ObjCInterfaceDecl *CurrentClass, ResultTypeCompatibilityKind RTC)
void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl, ObjCIvarDecl **Fields, unsigned nIvars, SourceLocation Loc)
CheckImplementationIvars - This routine checks if the instance variables listed in the implelementati...
ObjCMethodDecl * LookupImplementedMethodInGlobalPool(Selector Sel)
LookupImplementedMethodInGlobalPool - Returns the method which has an implementation.
void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false)
AddInstanceMethodToGlobalPool - All instance methods in a translation unit are added to a global pool...
void AddAnyMethodToGlobalPool(Decl *D)
AddAnyMethodToGlobalPool - Add any method, instance or factory to global pool.
@ OCK_CategoryImplementation
bool isSelfExpr(Expr *RExpr)
Private Helper predicate to check for 'self'.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
void ActOnObjCContainerStartDefinition(ObjCContainerDecl *IDecl)
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...
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
Sema - This implements semantic analysis and AST building for C.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S=nullptr, bool AllowInlineNamespace=false) const
isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true if 'D' is in Scope 'S',...
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.
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
@ 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.
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)
class clang::Sema::DelayedDiagnostics DelayedDiagnostics
ExprResult VerifyBitField(SourceLocation FieldLoc, const IdentifierInfo *FieldName, QualType FieldTy, bool IsMsStruct, Expr *BitWidth)
VerifyBitField - verifies that a bit field expression is an ICE and has the correct width,...
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=RedeclarationKind::NotForRedeclaration)
Look up a name, looking for a single declaration.
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
ASTContext & getASTContext() const
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
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)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
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...
bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo, QualType &T, SourceLocation Loc, unsigned FailedFoldDiagID)
Attempt to fold a variable-sized type to a constant-sized type, returning true if we were successful.
void CheckExtraCXXDefaultArguments(Declarator &D)
CheckExtraCXXDefaultArguments - Check for any extra default arguments in the declarator,...
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...
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...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
void ActOnDocumentableDecl(Decl *D)
Should be called on all declarations that might have attached documentation comments.
ParmVarDecl * CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, const IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC)
void applyFunctionAttributesBeforeParsingBody(Decl *FD)
bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, bool OnlyNeedComplete=false)
Determine if D has a visible definition.
SourceManager & getSourceManager() const
TypeResult ActOnTypeName(Declarator &D)
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...
RedeclarationKind forRedeclarationInCurContext() const
void mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK=AMK_Redeclaration)
mergeDeclAttributes - Copy attributes from the Old decl to the New one.
IntrusiveRefCntPtr< ExternalSemaSource > ExternalSource
Source of additional semantic information.
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)
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
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.
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
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
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 MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old)
void ProcessAPINotes(Decl *D)
Map any API notes provided for this declaration to attributes on the declaration.
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)
IdentifierResolver IdResolver
llvm::SmallVector< std::pair< SourceLocation, const BlockDecl * >, 1 > ImplicitlyRetainedSelfLocs
List of SourceLocations where 'self' is implicitly retained inside a block.
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>.
bool isReferenceType() const
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 containsErrors() const
Whether this type is an error type.
bool isObjCIdType() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isObjCObjectType() const
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const
Return the implicit lifetime for this type, which must not be dependent.
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
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
void setExceptionVariable(bool EV)
static DelayedDiagnostic makeForbiddenType(SourceLocation loc, unsigned diagnostic, QualType type, unsigned argument)
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.
const FunctionProtoType * T
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.
Visibility
Describes the different kinds of visibility that a declaration may have.
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
ParsedAttributesView ArgAttrs
ArgAttrs - Attribute list for this argument.