Merge pull request #72756 from simanerush/globally-isolated-closures-inference

[Concurrency] Infer `@Sendable` for globally isolated function types and allow globally isolated closures to capture non-`Sendable` values.

Author: hborla

include/swift/AST/Types.h

@@ -3634,9 +3634,7 @@ class AnyFunctionType : public TypeBase {
     return getExtInfo().isNoEscape();
   }
 
-  bool isSendable() const {
-    return getExtInfo().isSendable();
-  }
+  bool isSendable() const;
 
   bool isAsync() const { return getExtInfo().isAsync(); }
 

lib/AST/Type.cpp

@@ -3895,6 +3895,15 @@ Type AnyFunctionType::getThrownError() const {
   }
 }
 
+bool AnyFunctionType::isSendable() const {
+  auto &ctx = getASTContext();
+  if (ctx.LangOpts.hasFeature(Feature::GlobalActorIsolatedTypesUsability)) {
+    // Global-actor-isolated function types are implicitly Sendable.
+    return getExtInfo().isSendable() || getIsolation().isGlobalActor();
+  }
+  return getExtInfo().isSendable();
+}
+
 Type AnyFunctionType::getGlobalActor() const {
   switch (getKind()) {
   case TypeKind::Function:

lib/Sema/TypeCheckConcurrency.cpp

@@ -4181,15 +4181,21 @@ bool ActorIsolationChecker::mayExecuteConcurrentlyWith(
     if (useIsolation == defIsolation)
       return false;
 
+    auto &ctx = useContext->getASTContext();
+    bool regionIsolationEnabled =
+        ctx.LangOpts.hasFeature(Feature::RegionBasedIsolation);
+    
+    // Globally-isolated closures may never be executed concurrently.
+    if (ctx.LangOpts.hasFeature(Feature::GlobalActorIsolatedTypesUsability) &&
+        regionIsolationEnabled && useIsolation.isGlobalActor())
+      return false;
+
     // If the local function is not Sendable, its isolation differs
     // from that of the context, and both contexts are actor isolated,
     // then capturing non-Sendable values allows the closure to stash
     // those values into actor isolated state. The original context
     // may also stash those values into isolated state, enabling concurrent
     // access later on.
-    auto &ctx = useContext->getASTContext();
-    bool regionIsolationEnabled =
-        ctx.LangOpts.hasFeature(Feature::RegionBasedIsolation);
     isolatedStateMayEscape =
         (!regionIsolationEnabled &&
         useIsolation.isActorIsolated() && defIsolation.isActorIsolated());

test/Concurrency/actor_isolation.swift

@@ -559,7 +559,7 @@ extension MyActor {
 
 func testBadImplicitGlobalActorClosureCall() async {
   { @MainActor in  }() // expected-error{{expression is 'async' but is not marked with 'await'}}
-  // expected-note@-1{{calls function of type '@MainActor () -> ()' from outside of its actor context are implicitly asynchronous}}
+  // expected-note@-1{{calls function of type '@MainActor @Sendable () -> ()' from outside of its actor context are implicitly asynchronous}}
 }
 
 

test/Concurrency/global_actor_sendable_fn_type_inference.swift

@@ -0,0 +1,21 @@
+// RUN: %target-typecheck-verify-swift -strict-concurrency=complete -disable-availability-checking -enable-upcoming-feature RegionBasedIsolation -enable-experimental-feature GlobalActorIsolatedTypesUsability
+
+// REQUIRES: concurrency
+// REQUIRES: asserts
+
+func inferSendableFunctionType() {
+  let closure: @MainActor () -> Void = {}
+
+  Task {
+    await closure() // okay
+  }
+}
+
+class NonSendable {}
+
+func allowNonSendableCaptures() {
+  let nonSendable = NonSendable()
+  let _: @MainActor () -> Void = {
+    let _ = nonSendable // okay
+  }
+}