Redeclare Objective-C property accessors inside the ObjCImplDecl in which they are synthesized.

[aprantl]

Summary

This patch is motivated by (and factored out from) https://reviews.llvm.org/D66121 which is a debug info bugfix. Starting with DWARF 5 all Objective-C methods are nested inside their containing type, and that patch implements this for synthesized Objective-C properties.

This patch became much longer than I hoped it would be but most of the changes are mechanical in nature.

1. SemaObjCProperty populates a list of synthesized accessors that may need to inserted into an ObjCImplDecl.
2. SemaDeclObjC::ActOnEnd inserts forward-declarations for all accessors for which no override was provided into their ObjCImplDecl. This patch does *not* synthesize AST function *bodies*. Moving that code from the static analyzer into Sema may be a good idea though.
3. Places that expect all methods to have bodies have been updated.

Most of the updates are very straightforward, the most irritating part was updating the static analyzer, there may be a more elegant way to do this.
I'm somewhat concerned that I didn't have to update the GNU Objective-C runtime for the testsuite to pass. I did not update the static analyzer's inliner for synthesized properties to point back to the property declaration (see test/Analysis/Inputs/expected-plists/nullability-notes.m.plist), which I believed to be more bug than a feature.

[aprantl]

Remove #if 0 from test I used during debugging. (It still passes!)

[theraven]

The changes for the GNU runtimes look correct to me. We're missing a bunch of tests there, unfortunately.

[rjmccall]

clang/include/clang/AST/DeclObjC.h

2787 ↗

(On Diff #222056)

Are these comments right? The DC is the implementation's interface?

Regardless, I think these comments are misleading: the right way to put this is that these are the getter and setter method *definitions* (even if they don't necessarily have a body). And, relatedly, you should mention whether these are set even if the methods are defined explicitly or only if they're synthesized.

clang/include/clang/Sema/Sema.h

8522 ↗

(On Diff #222056)

Property accessors are created in the @implementation if they aren't defined explicitly there.

Does this really need to be global state on Sema? Does it theoretically need to be serialized and restored if e.g. a translation-unit prefix is cut after an @implementation is seen?

clang/lib/AST/DeclObjC.cpp

1386

Can you just do this as a simple check to look through the ObjCImplDecl to the ObjCInterfaceDecl as the first thing, immediately after you initialize Container?

clang/lib/Analysis/BodyFarm.cpp

843 ↗

(On Diff #222056)

Why did this logic need to change?

clang/lib/CodeGen/CGObjCGNU.cpp

1887 ↗

(On Diff #222056)

This is only correct if these methods aren't defined explicitly by the user, right? Or do this methods return null in that case?

Same question goes for the CGObjCMac code.

clang/lib/CodeGen/CGObjCMac.cpp

6698 ↗

(On Diff #222056)

Spurious change.

clang/lib/CodeGen/CodeGenFunction.cpp

639 ↗

(On Diff #222056)

Spurious change.

clang/lib/CodeGen/CodeGenModule.cpp

5124

Is this special treatment still necessary? Won't we encounter the getter and setter on the normal pass over the method definitions in the @implementation?

[rjmccall]

Also, I think it would be good if there was a more explicit method for asking whether a method is a synthesized definition. Basically, there's a tri-state: there are pure declarations, user-provided definitions, and synthetic definitions. IRGen should emit a function when it sees either of the latter two, but it might have to use special code for synthetic definitions.

[aprantl]

clang/lib/Analysis/BodyFarm.cpp

843 ↗

(On Diff #222056)

I don't have a satisfying answer for this.

Without this extra code, the assertion in https://github.com/llvm/llvm-project/blob/b081220cfd46965fa25dbf826cd3f42f4f9e54cd/clang/test/Analysis/properties.m#L1035 (and only that one) turns from UNKNOWN to TRUE.

There is a similar workaround with a similar comment in
https://github.com/llvm/llvm-project/blob/b081220cfd46965fa25dbf826cd3f42f4f9e54cd/clang/lib/StaticAnalyzer/Core/CallEvent.cpp#L1291
that looks like it is related.

clang/lib/CodeGen/CodeGenModule.cpp

5124

We don't know which ObjMethodDecls without bodies are property accessor implementations since there is no pointer from the ObjCMethodDecl back to the ObjCPropertyImplDecl.

[aprantl]

Addressed most of the feedback, explained the rest.

[NoQ]

clang/test/Analysis/Inputs/expected-plists/nullability-notes.m.plist

191 ↗

(On Diff #225729)

It looks like the body farm for the property accessor has stopped working here. The code under analysis (from test/Analysis/nullability-notes.m) is:

 7	void takesNonnull(NSObject *_Nonnull y);
 8
 9	@interface ClassWithProperties: NSObject
10	@property(copy, nullable) NSObject *x; // plist check ensures no control flow piece from here to 'self.x'.
11	-(void) method;
12	@end;
13	@implementation ClassWithProperties
14	-(void) method {
15	  // no-crash
16	  NSObject *x = self.x; // expected-note{{Nullability 'nullable' is inferred}}
17	  takesNonnull(x); // expected-warning{{Nullable pointer is passed to a callee that requires a non-null 1st parameter}}
18	                   // expected-note@-1{{Nullable pointer is passed to a callee that requires a non-null 1st parameter}}
19	}
20	@end

The point of the test is to check how control flow is displayed to the user, and this change in the plist file will not really be visible to the user. However i'm worried that we've lost precision of the analysis on similar examples. I'll double-check.

[rjmccall]

clang/lib/CodeGen/CodeGenModule.cpp

5124

I mean, this doesn't seem like an unreasonable thing to be able to discover given just an ObjCMethodDecl. We can certainly set something on the declaration that says that it represents a synthesized method definition (and is therefore a definition for the purposes of isDefined or anything similar).

[aprantl]

Rebased patch and made it slightly more explicit whether an ObjCMethodDecl is a synthesized accessor stub by reserving a bit for it in ObjCMethodDecl.

[aprantl]

clang/lib/CodeGen/CodeGenModule.cpp

5124

If we were to move this into the loop / function that emits each method decl, we would still somehow need to get back to the ObjCPropertyImplDecl . There is no pointer in that direction, so we'd have to loop over all property impls until we find it. This here is going to be faster. Storing a pointer to a possible ObjCPropertyImplDecl in ObjCMethodDecl seems wasteful. Let me know if I misunderstood what you were suggesting.

[aprantl]

Accidentally sent my diff-upon-previous-diff instead of diff against master.

[rjmccall]

Okay, thanks for patiently working through all this review. I'm happy with this now.

clang/lib/CodeGen/CodeGenModule.cpp

5124

Oh, in order to find the associated ivar? I hadn't considered that. Okay, WFM.

[aprantl]

Thanks for patiently working through this with me.

clang/lib/AST/DeclObjC.cpp

ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const {
   unsigned NumArgs = Sel.getNumArgs();
   if (NumArgs > 1)
     return nullptr;
 
   if (isPropertyAccessor()) {
     const auto *Container = cast<ObjCContainerDecl>(getParent());
     // For accessor stubs, go back to the interface.
     if (auto *ImplDecl = dyn_cast<ObjCImplDecl>(Container))
-      if (!getBody())
+      if (isSynthesizedAccessorStub())
         Container = ImplDecl->getClassInterface();
 
     bool IsGetter = (NumArgs == 0);
     bool IsInstance = isInstanceMethod();
 
     /// Local function that attempts to find a matching property within the
     /// given Objective-C container.
     auto findMatchingProperty =
if (ClassDecl) {
         if (Ext == Container)
           continue;
 
         if (const auto *Found = findMatchingProperty(Ext))
           return Found;
       }
     }
 
-    assert(!getBody() && "expected an accessor stub");
+    assert(isSynthesizedAccessorStub() && "expected an accessor stub");
     for (const auto *Cat : ClassDecl->known_categories()) {
       if (Cat == Container)
         continue;
 
       if (const auto *Found = findMatchingProperty(Cat))
         return Found;
     }
 
     llvm_unreachable("Marked as a property accessor but no property found!");
   }
 
   if (!CheckOverrides)
     return nullptr;
 
   using OverridesTy = SmallVector<const ObjCMethodDecl *, 8>;
 
   OverridesTy Overrides;
   getOverriddenMethods(Overrides);
   for (const auto *Override : Overrides)
     if (const ObjCPropertyDecl *Prop = Override->findPropertyDecl(false))
       return Prop;
 
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // ObjCTypeParamDecl
 //===----------------------------------------------------------------------===//

clang/lib/CodeGen/CodeGenModule.cpp

if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
       ObjCPropertyDecl *PD = PID->getPropertyDecl();
 
       // Determine which methods need to be implemented, some may have
       // been overridden. Note that ::isPropertyAccessor is not the method
       // we want, that just indicates if the decl came from a
       // property. What we want to know is if the method is defined in
       // this implementation.
       auto *Getter = PID->getGetterMethodDecl();
-      if (!Getter || !Getter->getBody())
+      if (!Getter || Getter->isSynthesizedAccessorStub())
         CodeGenFunction(*this).GenerateObjCGetter(
             const_cast<ObjCImplementationDecl *>(D), PID);
       auto *Setter = PID->getSetterMethodDecl();
-      if (!PD->isReadOnly() && (!Setter || !Setter->getBody()))
+      if (!PD->isReadOnly() && (!Setter || Setter->isSynthesizedAccessorStub()))
         CodeGenFunction(*this).GenerateObjCSetter(
                                  const_cast<ObjCImplementationDecl *>(D), PID);
     }
   }
 }
 
 static bool needsDestructMethod(ObjCImplementationDecl *impl) {
   const ObjCInterfaceDecl *iface = impl->getClassInterface();
   for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
        ivar; ivar = ivar->getNextIvar())
     if (ivar->getType().isDestructedType())

clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp

 
 /// mustSynthesizeSetterGetterMethod - returns true if setter or getter has not
 /// been found in the class implementation. In this case, it must be synthesized.
 static bool mustSynthesizeSetterGetterMethod(ObjCImplementationDecl *IMP,
                                              ObjCPropertyDecl *PD,
                                              bool getter) {
   auto *OMD = IMP->getInstanceMethod(getter ? PD->getGetterName()
                                             : PD->getSetterName());
-  return !OMD || !OMD->getBody();
+  return !OMD || OMD->isSynthesizedAccessorStub();
 }
 
 void RewriteModernObjC::RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,
                                           ObjCImplementationDecl *IMD,
                                           ObjCCategoryImplDecl *CID) {
   static bool objcGetPropertyDefined = false;
   static bool objcSetPropertyDefined = false;
   SourceLocation startGetterSetterLoc;

clang/lib/Index/IndexDecl.cpp

case TemplateArgument::TemplateExpansion:
           IndexCtx.handleReference(TTD, TALoc.getTemplateNameLoc(), Parent, DC);
       }
       break;
     default:
       break;
     }
   }
 
+  /// Returns true if the given method has been defined explicitly by the
+  /// user.
+  static bool hasUserDefined(const ObjCMethodDecl *D,
+                             const ObjCImplDecl *Container) {
+    const ObjCMethodDecl *MD = Container->getMethod(D->getSelector(),
+                                                    D->isInstanceMethod());
+    return MD && !MD->isImplicit() && MD->isThisDeclarationADefinition() &&
+           !MD->isSynthesizedAccessorStub();
+  }
+
+  
   void handleDeclarator(const DeclaratorDecl *D,
                         const NamedDecl *Parent = nullptr,
                         bool isIBType = false) {
     if (!Parent) Parent = D;
 
     IndexCtx.indexTypeSourceInfo(D->getTypeSourceInfo(), Parent,
                                  Parent->getLexicalDeclContext(),
                                  /*isBase=*/false, isIBType);
bool VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
 
     if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
       return true;
 
     assert(D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize);
     SymbolRoleSet AccessorMethodRoles =
       SymbolRoleSet(SymbolRole::Dynamic) | SymbolRoleSet(SymbolRole::Implicit);
     if (ObjCMethodDecl *MD = PD->getGetterMethodDecl()) {
-      if (MD->isPropertyAccessor() && !D->getGetterMethodDecl()->hasBody())
+      if (MD->isPropertyAccessor() && !hasUserDefined(MD, Container))
         IndexCtx.handleDecl(MD, Loc, AccessorMethodRoles, {}, Container);
     }
     if (ObjCMethodDecl *MD = PD->getSetterMethodDecl()) {
-      if (MD->isPropertyAccessor() && !D->getSetterMethodDecl()->hasBody())
+      if (MD->isPropertyAccessor() && !hasUserDefined(MD, Container))
         IndexCtx.handleDecl(MD, Loc, AccessorMethodRoles, {}, Container);
     }
     if (ObjCIvarDecl *IvarD = D->getPropertyIvarDecl()) {
       if (IvarD->getSynthesize()) {
-        IvarD->dump();
         // For synthesized ivars, use the location of its name in the
         // corresponding @synthesize. If there isn't one, use the containing
         // @implementation's location, rather than the property's location,
         // otherwise the header file containing the @interface will have different
         // indexing contents based on whether the @implementation was present or
         // not in the translation unit.
         SymbolRoleSet IvarRoles = 0;
         SourceLocation IvarLoc = D->getPropertyIvarDeclLoc();

clang/lib/Sema/SemaDeclObjC.cpp

for (auto *I : CDecl->instance_methods()) {
     } else {
       ObjCMethodDecl *ImpMethodDecl =
         IMPDecl->getInstanceMethod(I->getSelector());
       assert(CDecl->getInstanceMethod(I->getSelector(), true/*AllowHidden*/) &&
              "Expected to find the method through lookup as well");
       // ImpMethodDecl may be null as in a @dynamic property.
       if (ImpMethodDecl) {
         // Skip property accessor function stubs.
-        if (I->isPropertyAccessor() && !ImpMethodDecl->getBody())
+        if (ImpMethodDecl->isSynthesizedAccessorStub())
           continue;
         if (!WarnCategoryMethodImpl)
           WarnConflictingTypedMethods(ImpMethodDecl, I,
                                       isa<ObjCProtocolDecl>(CDecl));
         else if (!I->isPropertyAccessor())
           WarnExactTypedMethods(ImpMethodDecl, I, isa<ObjCProtocolDecl>(CDecl));
       }
     }
for (auto *I : CDecl->class_methods()) {
     } else {
       ObjCMethodDecl *ImpMethodDecl =
         IMPDecl->getClassMethod(I->getSelector());
       assert(CDecl->getClassMethod(I->getSelector(), true/*AllowHidden*/) &&
              "Expected to find the method through lookup as well");
       // ImpMethodDecl may be null as in a @dynamic property.
       if (ImpMethodDecl) {
         // Skip property accessor function stubs.
-        if (I->isPropertyAccessor() && !ImpMethodDecl->getBody())
+        if (ImpMethodDecl->isSynthesizedAccessorStub())
           continue;
         if (!WarnCategoryMethodImpl)
           WarnConflictingTypedMethods(ImpMethodDecl, I,
                                       isa<ObjCProtocolDecl>(CDecl));
         else if (!I->isPropertyAccessor())
           WarnExactTypedMethods(ImpMethodDecl, I, isa<ObjCProtocolDecl>(CDecl));
       }
     }
bool isInterfaceDeclKind =
          || isa<ObjCProtocolDecl>(ClassDecl);
   bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl);
 
   // Make synthesized accessor stub functions visible. This is
   // deferred in case they are overridden by an explicit method.
   if (auto *OID = dyn_cast<ObjCImplementationDecl>(CurContext)) {
     for (auto PropImpl : OID->property_impls()) {
       if (auto *Getter = PropImpl->getGetterMethodDecl())
-        if (Getter->isImplicit() && !Getter->hasBody()) {
+        if (Getter->isSynthesizedAccessorStub()) {
           OID->makeDeclVisibleInContext(Getter);
           OID->addDecl(Getter);
         }
       if (auto *Setter = PropImpl->getSetterMethodDecl())
-        if (Setter->isImplicit() && !Setter->hasBody()) {
+        if (Setter->isSynthesizedAccessorStub()) {
           OID->makeDeclVisibleInContext(Setter);
           OID->addDecl(Setter);
         }
     }
   }
-         
   // FIXME: Remove these and use the ObjCContainerDecl/DeclContext.
   llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
   llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;
 
   for (unsigned i = 0, e = allMethods.size(); i != e; i++ ) {
     ObjCMethodDecl *Method =
       cast_or_null<ObjCMethodDecl>(allMethods[i]);
 
if (ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(ClassDecl)) {
     // register it with the property.  Linear search through all
     // properties here, because the autosynthesized stub hasn't been
     // made visible yet, so it can be overriden by a later
     // user-specified implementation.
     for (ObjCPropertyImplDecl *PropertyImpl : ImpDecl->property_impls()) {
       if (auto *Setter = PropertyImpl->getSetterMethodDecl())
         if (Setter->getSelector() == Sel &&
             Setter->isInstanceMethod() == ObjCMethod->isInstanceMethod()) {
-          assert(!Setter->hasBody() && "autosynth stub expected");
+          assert(Setter->isSynthesizedAccessorStub() && "autosynth stub expected");
           PropertyImpl->setSetterMethodDecl(ObjCMethod);
         }
       if (auto *Getter = PropertyImpl->getGetterMethodDecl())
         if (Getter->getSelector() == Sel &&
             Getter->isInstanceMethod() == ObjCMethod->isInstanceMethod()) {
-          assert(!Getter->hasBody() && "autosynth stub expected");
+          assert(Getter->isSynthesizedAccessorStub() && "autosynth stub expected");
           PropertyImpl->setGetterMethodDecl(ObjCMethod);
           break;
         }
     }
 
     // Merge information from the @interface declaration into the
     // @implementation.
     if (ObjCInterfaceDecl *IDecl = ImpDecl->getClassInterface()) {
for (const auto *CurMethod : ImplD->instance_methods()) {
     if (Diags.isIgnored(DIAG, Loc))
       continue;
 
     const ObjCPropertyDecl *PDecl;
     const ObjCIvarDecl *IV = GetIvarBackingPropertyAccessor(CurMethod, PDecl);
     if (!IV)
       continue;
 
-    if (!CurMethod->getBody())
+    if (CurMethod->isSynthesizedAccessorStub())
       continue;
 
     UnusedBackingIvarChecker Checker(*this, CurMethod, IV);
     Checker.TraverseStmt(CurMethod->getBody());
     if (Checker.AccessedIvar)
       continue;
 
     // Do not issue this warning if backing ivar is used somewhere and accessor

clang/lib/Sema/SemaObjCProperty.cpp

 }
 
 static ObjCMethodDecl *
 RedeclarePropertyAccessor(ASTContext &Context, ObjCImplementationDecl *Impl,
                           ObjCPropertyImplDecl *PropertyImpl,
                           ObjCMethodDecl *AccessorDecl, SourceLocation AtLoc,
                           SourceLocation PropertyLoc) {
   ObjCMethodDecl *Decl = AccessorDecl;
-  //  llvm::errs()<<"redeclare: ";  Decl->dump();
   ObjCMethodDecl *ImplDecl = ObjCMethodDecl::Create(
       Context, AtLoc, PropertyLoc, Decl->getSelector(), Decl->getReturnType(),
       Decl->getReturnTypeSourceInfo(), Impl, Decl->isInstanceMethod(),
       Decl->isVariadic(), Decl->isPropertyAccessor(), /* isSynthesized*/ true,
       Decl->isImplicit(), Decl->isDefined(), Decl->getImplementationControl(),
       Decl->hasRelatedResultType());
   ImplDecl->getMethodFamily();
   if (Decl->hasAttrs())
for (const auto *propertyImpl : impDecl->property_impls()) {
     if (propertyImpl->getPropertyImplementation()
           == ObjCPropertyImplDecl::Synthesize &&
         (property->getPropertyAttributes() &
          ObjCPropertyDecl::OBJC_PR_null_resettable) &&
         property->getGetterMethodDecl() &&
         property->getSetterMethodDecl()) {
       auto *getterImpl = propertyImpl->getGetterMethodDecl();
       auto *setterImpl = propertyImpl->getSetterMethodDecl();
-      if ((!getterImpl || !getterImpl->getBody()) &&
-          (!setterImpl || !setterImpl->getBody())) {
+      if ((!getterImpl || getterImpl->isSynthesizedAccessorStub()) &&
+          (!setterImpl || setterImpl->isSynthesizedAccessorStub())) {
         SourceLocation loc = propertyImpl->getLocation();
         if (loc.isInvalid())
           loc = impDecl->getBeginLoc();
 
         Diag(loc, diag::warn_null_resettable_setter)
           << setterImpl->getSelector() << property->getDeclName();
       }
     }
for (ObjCContainerDecl::PropertyMap::iterator I = PM.begin(), E = PM.end();
     if (!(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_atomic) &&
         !(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_nonatomic)) {
       GetterMethod = Property->isClassProperty() ?
                      IMPDecl->getClassMethod(Property->getGetterName()) :
                      IMPDecl->getInstanceMethod(Property->getGetterName());
       SetterMethod = Property->isClassProperty() ?
                      IMPDecl->getClassMethod(Property->getSetterName()) :
                      IMPDecl->getInstanceMethod(Property->getSetterName());
-      if (GetterMethod && !GetterMethod->getBody())
+      if (GetterMethod && GetterMethod->isSynthesizedAccessorStub())
         GetterMethod = nullptr;
-      if (SetterMethod && !SetterMethod->getBody())
+      if (SetterMethod && SetterMethod->isSynthesizedAccessorStub())
         SetterMethod = nullptr;
       LookedUpGetterSetter = true;
       if (GetterMethod) {
         Diag(GetterMethod->getLocation(),
              diag::warn_default_atomic_custom_getter_setter)
           << Property->getIdentifier() << 0;
         Diag(Property->getLocation(), diag::note_property_declare);
       }
if ((Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic) ||
         !(Attributes & ObjCPropertyDecl::OBJC_PR_readwrite))
       continue;
     if (const ObjCPropertyImplDecl *PIDecl = IMPDecl->FindPropertyImplDecl(
             Property->getIdentifier(), Property->getQueryKind())) {
       if (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
         continue;
       GetterMethod = PIDecl->getGetterMethodDecl();
       SetterMethod = PIDecl->getSetterMethodDecl();
-      if (GetterMethod && !GetterMethod->getBody())
+      if (GetterMethod && !GetterMethod->isSynthesizedAccessorStub())
         GetterMethod = nullptr;
-      if (SetterMethod && !SetterMethod->getBody())
+      if (SetterMethod && !SetterMethod->isSynthesizedAccessorStub())
         SetterMethod = nullptr;
       if ((bool)GetterMethod ^ (bool)SetterMethod) {
         SourceLocation MethodLoc =
           (GetterMethod ? GetterMethod->getLocation()
                         : SetterMethod->getLocation());
         Diag(MethodLoc, diag::warn_atomic_property_rule)
           << Property->getIdentifier() << (GetterMethod != nullptr)
           << (SetterMethod != nullptr);
void Sema::DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D) {
   if (getLangOpts().getGC() == LangOptions::GCOnly)
     return;
 
   for (const auto *PID : D->property_impls()) {
     const ObjCPropertyDecl *PD = PID->getPropertyDecl();
     if (PD && !PD->hasAttr<NSReturnsNotRetainedAttr>() &&
         !PD->isClassProperty()) {
       ObjCMethodDecl *IM = PID->getGetterMethodDecl();
-      if (IM && IM->getBody())
+      if (IM && IM->isSynthesizedAccessorStub())
         continue;
       ObjCMethodDecl *method = PD->getGetterMethodDecl();
       if (!method)
         continue;
       ObjCMethodFamily family = method->getMethodFamily();
       if (family == OMF_alloc || family == OMF_copy ||
           family == OMF_mutableCopy || family == OMF_new) {
         if (getLangOpts().ObjCAutoRefCount)

clang/lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp

void DirectIvarAssignment::checkASTDecl(const ObjCImplementationDecl *D,
 
   for (const auto *M : D->instance_methods()) {
     AnalysisDeclContext *DCtx = Mgr.getAnalysisDeclContext(M);
 
     if ((*ShouldSkipMethod)(M))
       continue;
 
     const Stmt *Body = M->getBody();
-    if (!Body)
+    if (M->isSynthesizedAccessorStub())
       continue;
+    assert(Body);
 
     MethodCrawler MC(IvarToPropMap, M->getCanonicalDecl(), InterD, BR, this,
                      DCtx);
     MC.VisitStmt(Body);
   }
 }
 
 static bool isAnnotatedToAllowDirectAssignment(const Decl *D) {

clang/tools/libclang/CIndex.cpp

bool CursorVisitor::VisitDeclContext(DeclContext *DC) {
 
   for ( ; I != E; ++I) {
     Decl *D = *I;
     if (D->getLexicalDeclContext() != DC)
       continue;
     // Filter out synthesized property accessor redeclarations.
     if (isa<ObjCImplDecl>(DC))
       if (auto *OMD = dyn_cast<ObjCMethodDecl>(D))
-        if (OMD->isImplicit() && !OMD->hasBody())
+        if (OMD->isSynthesizedAccessorStub())
           continue;
     const Optional<bool> V = handleDeclForVisitation(D);
     if (!V.hasValue())
       continue;
     return V.getValue();
   }
   return false;
 }