[Concurrency] Ban non-escaping closures in @asyncHandler

An asynchronous handler appears to be a synchronous function, but
actually runs its body in a detached task. That means that any
non-escaping closure parameters to the asynchronous handler will
effectively escape. Fixes rdar://70820569.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4135,6 +4135,9 @@ ERROR(asynchandler_async,none,
 ERROR(asynchandler_inout_parameter,none,
       "'inout' parameter is not allowed in '@asyncHandler' function",
       ())
+ERROR(asynchandler_noescape_closure_parameter,none,
+      "non-escaping closure parameter is not allowed in '@asyncHandler' function",
+      ())
 ERROR(asynchandler_mutating,none,
       "'@asyncHandler' function cannot be 'mutating'",
       ())

lib/Sema/TypeCheckConcurrency.cpp

@@ -87,6 +87,16 @@ static bool checkAsyncHandler(FuncDecl *func, bool diagnose) {
 
       return true;
     }
+
+    if (auto fnType = param->getInterfaceType()->getAs<FunctionType>()) {
+      if (fnType->isNoEscape()) {
+        if (diagnose) {
+          param->diagnose(diag::asynchandler_noescape_closure_parameter);
+        }
+
+        return true;
+      }
+    }
   }
 
   if (func->isMutating()) {

lib/Sema/TypeCheckDecl.cpp

@@ -2217,19 +2217,6 @@ static Type validateParameterType(ParamDecl *decl) {
     }
   }
 
-  // async autoclosures can only occur as parameters to async functions.
-  if (decl->isAutoClosure()) {
-    if (auto fnType = Ty->getAs<FunctionType>()) {
-      if (fnType->isAsync() &&
-          !(isa<AbstractFunctionDecl>(dc) &&
-            cast<AbstractFunctionDecl>(dc)->isAsyncContext())) {
-        decl->diagnose(diag::async_autoclosure_nonasync_function);
-        if (auto func = dyn_cast<FuncDecl>(dc))
-          addAsyncNotes(func);
-      }
-    }
-  }
-
   return Ty;
 }
 

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1322,6 +1322,19 @@ void TypeChecker::checkParameterList(ParameterList *params,
                                      DeclContext *owner) {
   for (auto param: *params) {
     checkDeclAttributes(param);
+
+    // async autoclosures can only occur as parameters to async functions.
+    if (param->isAutoClosure()) {
+      if (auto fnType = param->getInterfaceType()->getAs<FunctionType>()) {
+        if (fnType->isAsync() &&
+            !(isa<AbstractFunctionDecl>(owner) &&
+              cast<AbstractFunctionDecl>(owner)->isAsyncContext())) {
+          param->diagnose(diag::async_autoclosure_nonasync_function);
+          if (auto func = dyn_cast<FuncDecl>(owner))
+            addAsyncNotes(func);
+        }
+      }
+    }
   }
 
   // For source compatibilty, allow duplicate internal parameter names

test/attr/asynchandler.swift

@@ -9,7 +9,11 @@ func globalAsyncFunction() async -> Int { 0 }
   let _ = await globalAsyncFunction()
 }
 
-@asyncHandler func asyncHandler2(fn: @autoclosure () async -> Int ) {
+@asyncHandler func asyncHandler2(fn: @autoclosure @escaping () async -> Int ) {
+  // okay, it's an async context
+}
+
+@asyncHandler func asyncHandler3(fn: @escaping () -> Int) {
   // okay, it's an async context
 }
 
@@ -29,6 +33,10 @@ func asyncHandlerBad3() throws { }
 func asyncHandlerBad4(result: inout Int) { }
 // expected-error@-1{{'inout' parameter is not allowed in '@asyncHandler' function}}
 
+@asyncHandler
+func asyncHandlerBad5(result: () -> Int) { }
+// expected-error@-1{{non-escaping closure parameter is not allowed in '@asyncHandler' function}}
+
 actor class X {
   @asyncHandler func asyncHandlerMethod() { }