Merge pull request swiftlang#33476 from DougGregor/concurrency-asynchandler

[Concurrency] Add @asyncHandler attribute.

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,
+  101)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Decl.h

@@ -5888,6 +5888,13 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// type of the function will be `async` as well.
   bool hasAsync() const { return Bits.AbstractFunctionDecl.Async; }
 
+  /// Returns true if the function is a suitable 'async' context.
+  ///
+  /// Functions that are an 'async' context can make calls to 'async' functions.
+  bool isAsyncContext() const {
+    return hasAsync() || getAttrs().hasAttribute<AsyncHandlerAttr>();
+  }
+
   /// Returns true if the function body throws.
   bool hasThrows() const { return Bits.AbstractFunctionDecl.Throws; }
 

include/swift/AST/DiagnosticsSema.def

@@ -4047,7 +4047,7 @@ WARNING(no_throw_in_do_with_catch,none,
 ERROR(async_call_without_await,none,
       "call is 'async' but is not marked with 'await'", ())
 ERROR(async_call_without_await_in_autoclosure,none,
-      "call is 'async' in an autoclosure argument is not marked with 'await'", ())
+      "call is 'async' in an autoclosure argument that is not marked with 'await'", ())
 WARNING(no_async_in_await,none,
         "no calls to 'async' functions occur within 'await' expression", ())
 ERROR(async_call_in_illegal_context,none,
@@ -4064,6 +4064,8 @@ ERROR(async_in_nonasync_function,none,
       (bool, bool))
 NOTE(note_add_async_to_function,none,
      "add 'async' to function %0 to make it asynchronous", (DeclName))
+NOTE(note_add_asynchandler_to_function,none,
+     "add '@asyncHandler' to function %0 to create an implicit asynchronous context", (DeclName))
 ERROR(not_objc_function_async,none,
       "'async' function cannot be represented in Objective-C", ())
 NOTE(not_objc_function_type_async,none,
@@ -4074,6 +4076,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

@@ -41,6 +41,66 @@
 
 using namespace swift;
 
+/// Check whether the @asyncHandler attribute can be applied to the given
+/// function declaration.
+///
+/// \param diagnose Whether to emit a diagnostic when a problem is encountered.
+///
+/// \returns \c true if there was a problem with adding the attribute, \c false
+/// otherwise.
+static bool checkAsyncHandler(FuncDecl *func, bool diagnose) {
+  if (!func->getResultInterfaceType()->isVoid()) {
+    if (diagnose) {
+      func->diagnose(diag::asynchandler_returns_value)
+          .highlight(func->getBodyResultTypeLoc().getSourceRange());
+    }
+
+    return true;
+  }
+
+  if (func->hasThrows()) {
+    if (diagnose) {
+      func->diagnose(diag::asynchandler_throws)
+          .fixItRemove(func->getThrowsLoc());
+    }
+
+    return true;
+  }
+
+  if (func->hasAsync()) {
+    if (diagnose) {
+      func->diagnose(diag::asynchandler_async)
+          .fixItRemove(func->getAsyncLoc());
+    }
+
+    return true;
+  }
+
+  for (auto param : *func->getParameters()) {
+    if (param->isInOut()) {
+      if (diagnose) {
+        param->diagnose(diag::asynchandler_inout_parameter)
+            .fixItRemove(param->getSpecifierLoc());
+      }
+
+      return true;
+    }
+  }
+
+  if (func->isMutating()) {
+    if (diagnose) {
+      auto diag = func->diagnose(diag::asynchandler_mutating);
+      if (auto mutatingAttr = func->getAttrs().getAttribute<MutatingAttr>()) {
+        diag.fixItRemove(mutatingAttr->getRange());
+      }
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
 namespace {
   /// This emits a diagnostic with a fixit to remove the attribute.
   template<typename ...ArgTypes>
@@ -257,6 +317,24 @@ 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 (checkAsyncHandler(func, /*diagnose=*/true)) {
+      attr->setInvalid();
+      return;
+    }
+  }
 };
 } // end anonymous namespace
 
@@ -5148,3 +5226,13 @@ void AttributeChecker::visitTransposeAttr(TransposeAttr *attr) {
   // Set the resolved linearity parameter indices in the attribute.
   attr->setParameterIndices(linearParamIndices);
 }
+
+void swift::addAsyncNotes(FuncDecl *func) {
+  func->diagnose(diag::note_add_async_to_function, func->getName());
+
+  if (!checkAsyncHandler(func, /*diagnose=*/false)) {
+    func->diagnose(
+            diag::note_add_asynchandler_to_function, func->getName())
+        .fixItInsert(func->getAttributeInsertionLoc(false), "@asyncHandler ");
+  }
+}

lib/Sema/TypeCheckDecl.cpp

@@ -2155,11 +2155,10 @@ static Type validateParameterType(ParamDecl *decl) {
     if (auto fnType = Ty->getAs<FunctionType>()) {
       if (fnType->isAsync() &&
           !(isa<AbstractFunctionDecl>(dc) &&
-            cast<AbstractFunctionDecl>(dc)->hasAsync())) {
+            cast<AbstractFunctionDecl>(dc)->isAsyncContext())) {
         decl->diagnose(diag::async_autoclosure_nonasync_function);
-        if (auto func = dyn_cast<FuncDecl>(dc)) {
-          func->diagnose(diag::note_add_async_to_function, func->getName());
-        }
+        if (auto func = dyn_cast<FuncDecl>(dc))
+          addAsyncNotes(func);
       }
     }
   }

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)

lib/Sema/TypeCheckEffects.cpp

@@ -932,7 +932,7 @@ class Context {
       }
     }
 
-    return Context(D->hasThrows(), D->hasAsync(), AnyFunctionRef(D));
+    return Context(D->hasThrows(), D->isAsyncContext(), AnyFunctionRef(D));
   }
 
   static Context forDeferBody() {
@@ -1254,7 +1254,7 @@ class Context {
     if (!func)
       return;
 
-    func->diagnose(diag::note_add_async_to_function, func->getName());
+    addAsyncNotes(func);
   }
 
   void diagnoseUnhandledAsyncSite(DiagnosticEngine &Diags, ASTNode node) {

lib/Sema/TypeChecker.h

@@ -1391,6 +1391,10 @@ void checkUnknownAttrRestrictions(
 /// it to later stages.
 void bindSwitchCasePatternVars(DeclContext *dc, CaseStmt *stmt);
 
+/// Add notes suggesting the addition of 'async' or '@asyncHandler', as
+/// appropriate, to a diagnostic for a function that isn't an async context.
+void addAsyncNotes(FuncDecl *func);
+
 } // end namespace swift
 
 #endif

test/attr/asynchandler.swift

@@ -0,0 +1,39 @@
+// RUN: %target-swift-frontend -typecheck -verify %s -enable-experimental-concurrency
+
+func globalAsyncFunction() async -> Int { 0 }
+
+@asyncHandler func asyncHandler1() {
+  // okay, it's an async context
+  let _ = await globalAsyncFunction()
+}
+
+@asyncHandler func asyncHandler2(fn: @autoclosure () async -> Int ) {
+  // okay, it's an async context
+}
+
+@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}}