[analyzer] Update GCDAsyncSemaphoreChecker to match messages send to ObjC objects

[NoQ]

lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp

127–130

forEachDescendant(anyOf(...)) sounds more correct to me. We should find both when both are present.

[george.karpenkov]

lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp

127–130

...except it does not work. Type matchers types are weird like that.

[NoQ]

lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp

127–130

Yeah, you might need to add some auxiliary stmt() thingies.

[NoQ]

Yeah, looks good!

lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp

void GCDAsyncSemaphoreChecker::checkASTCodeBody(const Decl *D,
   auto SemaphoreWaitM = forEachDescendant(
     callExpr(
       allOf(
         callsName("dispatch_semaphore_wait"),
         equalsBoundArgDecl(0, SemaphoreBinding)
       )
     ).bind(WarningBinding));
 
-  auto AcceptsBlockM =
-    forEachDescendant(callExpr(hasAnyArgument(hasType(
+  auto HasBlockArgumentM = hasAnyArgument(hasType(
             hasCanonicalType(blockPointerType())
-            ))));
+            ));
 
-  auto BlockSignallingM =
-    forEachDescendant(callExpr(hasAnyArgument(hasDescendant(callExpr(
+  auto ArgCallsSignalM = hasArgument(0, hasDescendant(callExpr(
           allOf(
               callsName("dispatch_semaphore_signal"),
               equalsBoundArgDecl(0, SemaphoreBinding)
-              ))))));
+              ))));
+
+  auto HasBlockAndCallsSignalM = allOf(HasBlockArgumentM, ArgCallsSignalM);
+
+  auto AcceptsBlockM =
+    forEachDescendant(
+      stmt(anyOf(
+        callExpr(HasBlockAndCallsSignalM),
+        objcMessageExpr(HasBlockAndCallsSignalM)
+           )));
 
-  auto FinalM = compoundStmt(
-      SemaphoreBindingM,
-      SemaphoreWaitM,
-      AcceptsBlockM,
-      BlockSignallingM);
+  auto FinalM = compoundStmt(SemaphoreBindingM, SemaphoreWaitM, AcceptsBlockM);
 
   MatchFinder F;
   Callback CB(BR, AM.getAnalysisDeclContext(D), this);
 
   F.addMatcher(FinalM, &CB);
   F.match(*D->getBody(), AM.getASTContext());
 }
 

test/Analysis/gcdasyncsemaphorechecker_test.m

void warn_with_cast() {
   func(^{
       dispatch_semaphore_signal((int)sema);
   });
   dispatch_semaphore_wait((int)sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
 }
 
 @interface Test1 : NSObject
 -(void)use_method_warn;
+-(void)use_objc_callback_warn;
 -(void)testNoWarn;
+-(void)acceptBlock:(block_t)callback;
 @end
 
 @implementation Test1
 
 -(void)use_method_warn {
   dispatch_semaphore_t sema = dispatch_semaphore_create(0);
 
   func(^{
       dispatch_semaphore_signal(sema);
   });
   dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
 }
 
 -(void)testNoWarn {
   dispatch_semaphore_t sema = dispatch_semaphore_create(0);
 
   func(^{
       dispatch_semaphore_signal(sema);
   });
   dispatch_semaphore_wait(sema, 100);
 }
 
+-(void)acceptBlock:(block_t) callback {
+  callback();
+}
+
+-(void)use_objc_callback_warn {
+  dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+
+  [self acceptBlock:^{
+      dispatch_semaphore_signal(sema);
+  }];
+  dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+}
+
+void use_objc_and_c_callback(Test1 *t) {
+  dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+
+  func(^{
+      dispatch_semaphore_signal(sema);
+  });
+  dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+
+  dispatch_semaphore_t sema1 = dispatch_semaphore_create(0);
+
+  [t acceptBlock:^{
+      dispatch_semaphore_signal(sema1);
+  }];
+  dispatch_semaphore_wait(sema1, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+}
+
 @end