[Sema] Allow use of @execution(...) attribute on closures

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -8343,6 +8343,10 @@ ERROR(attr_execution_only_on_async,none,
       "cannot use '@execution' on non-async %kind0",
       (ValueDecl *))
 
+ERROR(attr_execution_only_on_async_closure,none,
+      "cannot use '@execution' on non-async closure",
+      ())
+
 ERROR(attr_execution_type_attr_only_on_async,none,
       "cannot use '@execution' on non-async function type",
       ())

lib/Sema/TypeCheckAttr.cpp

@@ -8222,6 +8222,44 @@ class ClosureAttributeChecker
     // Nothing else to check.
   }
 
+  void visitExecutionAttr(ExecutionAttr *attr) {
+    if (!ctx.LangOpts.hasFeature(Feature::ExecutionAttribute)) {
+      visitDeclAttribute(attr);
+      return;
+    }
+
+    // `@execution(...)` implies `async`.
+    if (closure->hasExplicitResultType() &&
+        closure->getAsyncLoc().isInvalid()) {
+      ctx.Diags
+          .diagnose(attr->getLocation(),
+                    diag::attr_execution_only_on_async_closure)
+          .fixItRemove(attr->getRangeWithAt());
+      attr->setInvalid();
+    }
+
+    if (auto actorType = getExplicitGlobalActor(closure)) {
+      ctx.Diags
+          .diagnose(
+              attr->getLocation(),
+              diag::attr_execution_type_attr_incompatible_with_global_isolation,
+              actorType)
+          .fixItRemove(attr->getRangeWithAt());
+      attr->setInvalid();
+    }
+
+    if (auto *paramList = closure->getParameters()) {
+      if (llvm::any_of(*paramList, [](auto *P) { return P->isIsolated(); })) {
+        ctx.Diags
+            .diagnose(
+                attr->getLocation(),
+                diag::attr_execution_type_attr_incompatible_with_isolated_param)
+            .fixItRemove(attr->getRangeWithAt());
+        attr->setInvalid();
+      }
+    }
+  }
+
   void visitNonisolatedAttr(NonisolatedAttr *attr) {
     if (attr->isUnsafe() ||
         !ctx.LangOpts.hasFeature(Feature::ClosureIsolation)) {

test/attr/attr_execution.swift

@@ -75,3 +75,21 @@ struct InfersMainActor : P {
 struct IsolatedType {
   @execution(concurrent) func test() async {}
 }
+
+_ = { @execution(caller) in // Ok
+}
+
+_ = { @execution(concurrent) in // Ok
+}
+
+_ = { @MainActor @execution(concurrent) in
+  // expected-error@-1 {{cannot use '@execution' because function type is isolated to a global actor 'MainActor'}}
+}
+
+_ = { @execution(concurrent) () -> Int in
+  // expected-error@-1 {{'@execution' on non-async closure}}
+}
+
+_ = { @execution(caller) (x: isolated (any Actor)?) in
+  // expected-error@-1 {{cannot use '@execution' together with an isolated parameter}}
+}