Only traverse closures once

So closures are in a PatternBindingDecl. Since we have an entry-point
into PatternBindingDecl that gets hit for every one of them, we used to
traverse the PBD's that are declared inside of the FunctionDecls twice.

This patch stops us from actually traversing into the PBD from the
checker, and instead pulling out the initializers of interest and
walking each expression separately.

Author: etcwilde

lib/Sema/TypeCheckConcurrency.cpp

@@ -3095,13 +3095,11 @@ class CompletionHandlerUsageChecker final : public ASTWalker {
 public:
   CompletionHandlerUsageChecker(ASTContext &ctx) : ctx(ctx) {}
 
+  bool walkToDeclPre(Decl *D) override { return !isa<PatternBindingDecl>(D); }
+
   std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
-    if (ClosureExpr *closure = dyn_cast<ClosureExpr>(expr)) {
-      if (closure->isBodyAsync())
-        return {true, closure};
-      else
-        return {true, nullptr};
-    }
+    if (ClosureExpr *closure = dyn_cast<ClosureExpr>(expr))
+      return {closure->isBodyAsync(), closure};
 
     if (ApplyExpr *call = dyn_cast<ApplyExpr>(expr)) {
       if (DeclRefExpr *fnDeclExpr = dyn_cast<DeclRefExpr>(call->getFn())) {
@@ -3116,8 +3114,7 @@ class CompletionHandlerUsageChecker final : public ASTWalker {
                   TypeCheckCompletionHandlerAsyncAttrRequest{
                       cast<AbstractFunctionDecl>(fnDecl), asyncAltAttr},
                   false)) {
-            return {true,
-                    nullptr}; // This didn't typecheck, don't traverse down
+            return {false, call};
           }
           ctx.Diags.diagnose(call->getLoc(), diag::warn_use_async_alternative);
           ctx.Diags.diagnose(asyncAltAttr->AsyncFunctionDecl->getLoc(),
@@ -3142,5 +3139,8 @@ void swift::checkFunctionAsyncUsage(AbstractFunctionDecl *decl) {
 
 void swift::checkPatternBindingDeclAsyncUsage(PatternBindingDecl *decl) {
   CompletionHandlerUsageChecker checker(decl->getASTContext());
-  decl->walk(checker);
+  for (Expr *init : decl->initializers()) {
+    if (auto closure = dyn_cast_or_null<ClosureExpr>(init))
+      closure->walk(checker);
+  }
 }

test/attr/attr_completionhandlerasync.swift

@@ -7,7 +7,7 @@
 // Parsing
 // ===================
 
-// expected-note@+1 3 {{'asyncFunc' declared here}}
+// expected-note@+1 4 {{'asyncFunc' declared here}}
 func asyncFunc(_ text: String) async -> Int { }
 
 @completionHandlerAsync("asyncFunc(_:)", completionHandlerIndex: 1)
@@ -176,3 +176,28 @@ let asyncGlobalClosure = { () async -> () in
   // expected-warning@+1:3{{consider using asynchronous alternative function}}
   goodFunc1(value: "neat") { _ in }
 }
+
+class ClassCallingAsyncStuff {
+  // expected-note@+1 3 {{'asyncFunc()' declared here}}
+  func asyncFunc() async {}
+
+  @completionHandlerAsync("asyncFunc()")
+  func compHandlerFunc(handler: @escaping () -> ()) {}
+
+  @completionHandlerAsync("asyncFunc()")
+  func compAsyncHandlerFunc(handler: @escaping () async -> ()) {}
+
+  func async1() async {
+    // expected-warning@+1{{consider using asynchronous alternative function}}
+    goodFunc1(value: "hi") { _ in }
+
+    // expected-warning@+1{{consider using asynchronous alternative function}}
+    compAsyncHandlerFunc() { [self] () async -> () in
+      // expected-warning@+1{{consider using asynchronous alternative function}}
+      compAsyncHandlerFunc() { [self] () async -> () in
+        // expected-warning@+1{{consider using asynchronous alternative function}}
+        compHandlerFunc() { print("foo") }
+      }
+    }
+  }
+}