[Concurrency] Add @asyncHandler attribute.

An asynchronous handler behaves externally like a synchronous function,
but internally it is handled like an asynchronous function, meaning
that it can execute operations with suspension points such as calling
other async functions.  The body of the function is executed just as if
it and its caller were async functions, except that the caller is
resumed when the callee reaches its first suspension point rather than
only when the callee exits.

Author: DougGregor

include/swift/AST/Attr.def

@@ -560,6 +560,11 @@ SIMPLE_DECL_ATTR(noDerivative, NoDerivative,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   100)
 
+SIMPLE_DECL_ATTR(asyncHandler, AsyncHandler,
+  OnFunc | UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove |
+  NotSerialized, 101)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsSema.def

@@ -4074,6 +4074,28 @@ NOTE(protocol_witness_async_conflict,none,
 ERROR(async_autoclosure_nonasync_function,none,
       "'async' autoclosure parameter in a non-'async' function", ())
 
+ERROR(asynchandler_attr_requires_concurrency,none,
+      "'@asyncHandler' is only valid when experimental concurrency is enabled",
+      ())
+ERROR(asynchandler_non_func,none,
+      "'@asyncHandler' can only be applied to functions",
+      ())
+ERROR(asynchandler_returns_value,none,
+      "'@asyncHandler' function can only return 'Void'",
+      ())
+ERROR(asynchandler_throws,none,
+      "'@asyncHandler' function cannot throw",
+      ())
+ERROR(asynchandler_async,none,
+      "'@asyncHandler' function cannot be 'async' itself",
+      ())
+ERROR(asynchandler_inout_parameter,none,
+      "'inout' parameter is not allowed in '@asyncHandler' function",
+      ())
+ERROR(asynchandler_mutating,none,
+      "'@asyncHandler' function cannot be 'mutating'",
+      ())
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Types
 //------------------------------------------------------------------------------

lib/Sema/TypeCheckAttr.cpp

@@ -257,6 +257,59 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   void visitDifferentiableAttr(DifferentiableAttr *attr);
   void visitDerivativeAttr(DerivativeAttr *attr);
   void visitTransposeAttr(TransposeAttr *attr);
+
+  void visitAsyncHandlerAttr(AsyncHandlerAttr *attr) {
+    if (!Ctx.LangOpts.EnableExperimentalConcurrency) {
+      diagnoseAndRemoveAttr(attr, diag::asynchandler_attr_requires_concurrency);
+      return;
+    }
+
+    auto func = dyn_cast<FuncDecl>(D);
+    if (!func) {
+      diagnoseAndRemoveAttr(attr, diag::asynchandler_non_func);
+      return;
+    }
+
+    if (!func->getResultInterfaceType()->isVoid()) {
+      func->diagnose(diag::asynchandler_returns_value)
+          .highlight(func->getBodyResultTypeLoc().getSourceRange());
+      attr->setInvalid();
+      return;
+    }
+
+    if (func->hasThrows()) {
+      func->diagnose(diag::asynchandler_throws)
+          .fixItRemove(func->getThrowsLoc());
+      attr->setInvalid();
+      return;
+    }
+
+    if (func->hasAsync()) {
+      func->diagnose(diag::asynchandler_async)
+          .fixItRemove(func->getAsyncLoc());
+      attr->setInvalid();
+      return;
+    }
+
+    for (auto param : *func->getParameters()) {
+      if (param->isInOut()) {
+        param->diagnose(diag::asynchandler_inout_parameter)
+            .fixItRemove(param->getSpecifierLoc());
+        attr->setInvalid();
+        return;
+      }
+    }
+
+    if (func->isMutating()) {
+      auto diag = Ctx.Diags.diagnose(func, diag::asynchandler_mutating);
+      diag.highlight(attr->getRangeWithAt());
+      if (auto mutatingAttr = func->getAttrs().getAttribute<MutatingAttr>()) {
+        diag.fixItRemove(mutatingAttr->getRange());
+      }
+      attr->setInvalid();
+      return;
+    }
+  }
 };
 } // end anonymous namespace
 

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1416,6 +1416,7 @@ namespace  {
     UNINTERESTING_ATTR(AccessControl)
     UNINTERESTING_ATTR(Alignment)
     UNINTERESTING_ATTR(AlwaysEmitIntoClient)
+    UNINTERESTING_ATTR(AsyncHandler)
     UNINTERESTING_ATTR(Borrowed)
     UNINTERESTING_ATTR(CDecl)
     UNINTERESTING_ATTR(Consuming)

test/attr/asynchandler.swift

@@ -0,0 +1,30 @@
+// RUN: %target-swift-frontend -typecheck -verify %s -enable-experimental-concurrency
+
+@asyncHandler func asyncHandler1() { }
+
+@asyncHandler
+func asyncHandlerBad1() -> Int { 0 }
+// expected-error@-1{{'@asyncHandler' function can only return 'Void'}}
+
+@asyncHandler
+func asyncHandlerBad2() async { }
+// expected-error@-1{{'@asyncHandler' function cannot be 'async' itself}}{{25-31=}}
+
+@asyncHandler
+func asyncHandlerBad3() throws { }
+// expected-error@-1{{'@asyncHandler' function cannot throw}}{{25-32=}}
+
+@asyncHandler
+func asyncHandlerBad4(result: inout Int) { }
+// expected-error@-1{{'inout' parameter is not allowed in '@asyncHandler' function}}
+
+struct X {
+  @asyncHandler func asyncHandlerMethod() { }
+
+  @asyncHandler
+  mutating func asyncHandlerMethodBad1() { }
+  // expected-error@-1{{'@asyncHandler' function cannot be 'mutating'}}{{3-12=}}
+
+  @asyncHandler init() { }
+  // expected-error@-1{{@asyncHandler may only be used on 'func' declarations}}
+}

test/attr/asynchandler_noconcurrency.swift

@@ -0,0 +1,4 @@
+// RUN: %target-swift-frontend -typecheck -verify %s
+
+@asyncHandler func asyncHandler1() { }
+// expected-error@-1{{'@asyncHandler' is only valid when experimental concurrency is enabled}}