[Concurrency] Extend @execution(...) attribute support to closures

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/CSGen.cpp

@@ -2542,6 +2542,16 @@ namespace {
             return FunctionTypeIsolation::forGlobalActor(actorType);
         }
 
+        if (auto *execution =
+                closure->getAttrs().getAttribute<ExecutionAttr>()) {
+          switch (execution->getBehavior()) {
+          case ExecutionKind::Caller:
+            return FunctionTypeIsolation::forNonIsolatedCaller();
+          case ExecutionKind::Concurrent:
+            return FunctionTypeIsolation::forNonIsolated();
+          }
+        }
+
         return FunctionTypeIsolation::forNonIsolated();
       }();
       extInfo = extInfo.withIsolation(isolation);

lib/Sema/ConstraintSystem.cpp

@@ -1400,6 +1400,12 @@ FunctionType::ExtInfo ClosureEffectsRequest::evaluate(
   bool throws = expr->getThrowsLoc().isValid();
   bool async = expr->getAsyncLoc().isValid();
   bool sendable = expr->getAttrs().hasAttribute<SendableAttr>();
+
+  // `@execution(...)` attribute is only valid on asynchronous function types.
+  if (expr->getAttrs().hasAttribute<ExecutionAttr>()) {
+    async = true;
+  }
+
   if (throws || async) {
     return ASTExtInfoBuilder()
       .withThrows(throws, /*FIXME:*/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/Concurrency/attr_execution_conversions.swift

@@ -82,6 +82,17 @@ do {
   // expected-error@-1 {{cannot convert value of type '(@execution(caller) () async -> ()).Type' to expected argument type '(@isolated(any) () async -> Void).Type'}}
 }
 
+do {
+  let _: () -> Void = { @execution(concurrent) in
+    // expected-error@-1 {{invalid conversion from 'async' function of type '() async -> Void' to synchronous function type '() -> Void'}}
+  }
+
+  func test(_: () -> Void) {}
+
+  test { @execution(caller) in
+    // expected-error@-1 {{cannot pass function of type '@execution(caller) () async -> ()' to parameter expecting synchronous function type}}
+  }
+}
 
 // Converting to `@execution(caller)` function
 class NonSendable {}

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}}
+}