Emit warning suggesting async function

This patch adds a diagnostic to recommend using the async function
instead of using the completion handler version. The diagnostic is only
emitted when the call is made in an async context and the
completion-handler version of the function is attributed with the
@completionHandleyAsync attribute.

Author: etcwilde

include/swift/AST/DiagnosticsSema.def

@@ -3377,6 +3377,9 @@ ERROR(attr_completion_handler_async_ambiguous_function,none,
 ERROR(attr_completion_handler_async_no_suitable_function,none,
       "no corresponding async function named %0", (DeclNameRef))
 
+WARNING(warn_use_async_alternative,none,
+        "consider using asynchronous alternative function",())
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Expressions
 //------------------------------------------------------------------------------

lib/Sema/TypeCheckConcurrency.cpp

@@ -3087,3 +3087,38 @@ NormalProtocolConformance *GetImplicitSendableRequest::evaluate(
 
   return conformance;
 }
+
+namespace {
+class CompletionHandlerUsageChecker final : public ASTWalker {
+  ASTContext &ctx;
+
+public:
+  CompletionHandlerUsageChecker(ASTContext &ctx) : ctx(ctx) {}
+
+  std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
+    if (ApplyExpr *call = dyn_cast<ApplyExpr>(expr)) {
+      if (DeclRefExpr *fnDeclExpr = dyn_cast<DeclRefExpr>(call->getFn())) {
+        ValueDecl *fnDecl = fnDeclExpr->getDecl();
+        CompletionHandlerAsyncAttr *asyncAltAttr =
+            fnDecl->getAttrs().getAttribute<CompletionHandlerAsyncAttr>();
+        if (asyncAltAttr && asyncAltAttr->AsyncFunctionDecl) {
+          ctx.Diags.diagnose(call->getLoc(), diag::warn_use_async_alternative);
+          ctx.Diags.diagnose(asyncAltAttr->AsyncFunctionDecl->getLoc(),
+                             diag::decl_declared_here,
+                             asyncAltAttr->AsyncFunctionDecl->getName());
+        }
+      }
+    }
+    return {true, expr};
+  }
+};
+} // namespace
+
+void swift::checkFunctionAsyncUsage(AbstractFunctionDecl *decl) {
+  if (!decl->isAsyncContext())
+    return;
+  CompletionHandlerUsageChecker checker(decl->getASTContext());
+  BraceStmt *body = decl->getBody();
+  if (body)
+    body->walk(checker);
+}

lib/Sema/TypeCheckConcurrency.h

@@ -239,6 +239,13 @@ Type getExplicitGlobalActor(ClosureExpr *closure);
 bool checkSendableConformance(
     ProtocolConformance *conformance, SendableCheck check);
 
+/// Check that we use the async version of a function where available
+///
+/// If a completion-handler function is called from an async context and it has
+/// a '@completionHandlerAsync' attribute, we emit a diagnostic suggesting the
+/// async call.
+void checkFunctionAsyncUsage(AbstractFunctionDecl *decl);
+
 } // end namespace swift
 
 #endif /* SWIFT_SEMA_TYPECHECKCONCURRENCY_H */

lib/Sema/TypeCheckStmt.cpp

@@ -2038,6 +2038,7 @@ TypeCheckFunctionBodyRequest::evaluate(Evaluator &evaluator,
   TypeChecker::computeCaptures(AFD);
   if (!AFD->getDeclContext()->isLocalContext()) {
     checkFunctionActorIsolation(AFD);
+    checkFunctionAsyncUsage(AFD);
     TypeChecker::checkFunctionEffects(AFD);
   }
 

test/attr/attr_completionhandlerasync.swift

@@ -6,14 +6,19 @@
 // Parsing
 // ===================
 
-func asyncFunc() async -> Int { }
+// expected-note@+1{{'asyncFunc' declared here}}
+func asyncFunc(_ text: String) async -> Int { }
 
-@completionHandlerAsync("asyncFunc()", completionHandlerIndex: 1)
+@completionHandlerAsync("asyncFunc(_:)", completionHandlerIndex: 1)
 func goodFunc1(value: String, completionHandler: @escaping (Int) -> Void) {}
 
-@completionHandlerAsync("asyncFunc()")
+@completionHandlerAsync("asyncFunc(_:)")
 func goodFunc2(value: String, completionHandler: @escaping (Int) -> Void) {}
 
+// expected-error@+1{{no corresponding async function named 'asyncFunc()'}}
+@completionHandlerAsync("asyncFunc()")
+func badFunc(value: String, completionHandler: @escaping (Int) -> Void) {}
+
 // expected-error@+1:24{{expected '(' in 'completionHandlerAsync' attribute}}
 @completionHandlerAsync
 func func1() {}
@@ -137,3 +142,21 @@ func matchingAsyncFunc(value: String) async {} // expected-note{{'matchingAsyncF
 // expected-error@+1:25{{ambiguous '@completionHandlerAsync' async function 'matchingAsyncFunc(value:)'}}
 @completionHandlerAsync("matchingAsyncFunc(value:)")
 func typecheckFunc9(handler: @escaping () -> Void) {}
+
+// Suggest using async alternative function in async context
+
+
+func asyncContext() async {
+  // expected-warning@+1:3{{consider using asynchronous alternative}}
+  goodFunc1(value: "Hello") { _ in }
+
+  let _ = await asyncFunc("World")
+
+  // This doesn't get the warning because the completionHandlerAsync failed to
+  // resolve the decl name
+  badFunc(value: "Hello") { _ in }
+}
+
+func syncContext() {
+  goodFunc1(value: "Hello") { _ in }
+}