Merge pull request #36698 from DougGregor/actor-escaping-isolation

[Actors] Permit non-sendable, escaping closures to be actor-isolated.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4394,9 +4394,6 @@ ERROR(actor_isolated_from_concurrent_function,none,
 ERROR(actor_isolated_from_async_let,none,
         "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from 'async let' initializer",
         (DescriptiveDeclKind, DeclName, unsigned))
-ERROR(actor_isolated_from_escaping_closure,none,
-        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from an '@escaping' closure",
-        (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(actor_isolated_keypath_component,none,
       "cannot form key path to actor-isolated %0 %1",
       (DescriptiveDeclKind, DeclName))

lib/Sema/TypeCheckConcurrency.cpp

@@ -760,16 +760,6 @@ static bool isAsyncCall(const ApplyExpr *call) {
 /// features.
 static bool shouldDiagnoseExistingDataRaces(const DeclContext *dc);
 
-/// Determine whether this closure is escaping.
-static bool isEscapingClosure(const AbstractClosureExpr *closure) {
-  if (auto type = closure->getType()) {
-    if (auto fnType = type->getAs<AnyFunctionType>())
-      return !fnType->isNoEscape();
-  }
-
-  return true;
-}
-
 /// Determine whether this closure is escaping.
 static bool isSendableClosure(const AbstractClosureExpr *closure) {
   if (auto type = closure->getType()) {
@@ -2018,10 +2008,6 @@ namespace {
           return diag::actor_isolated_from_concurrent_closure;
         }
 
-        if (isEscapingClosure(closure)) {
-          return diag::actor_isolated_from_escaping_closure;
-        }
-
         return findActorIndependentReason(dc->getParent());
       }
 
@@ -2215,8 +2201,8 @@ namespace {
         }
       }
 
-      // Escaping and concurrent closures are always actor-independent.
-      if (isEscapingClosure(closure) || isSendableClosure(closure))
+      // Sendable closures are always actor-independent.
+      if (isSendableClosure(closure))
         return ClosureActorIsolation::forIndependent();
 
       // A non-escaping closure gets its isolation from its context.

test/Concurrency/actor_isolation.swift

@@ -31,7 +31,7 @@ actor MySuperActor {
   var superState: Int = 25 // expected-note {{mutation of this property is only permitted within the actor}}
 
 
-  func superMethod() { // expected-note 2 {{calls to instance method 'superMethod()' from outside of its actor context are implicitly asynchronous}}
+  func superMethod() { // expected-note {{calls to instance method 'superMethod()' from outside of its actor context are implicitly asynchronous}}
     self.superState += 5
   }
 
@@ -50,12 +50,12 @@ class Point {
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
 actor MyActor: MySuperActor {
   let immutable: Int = 17
-  // expected-note@+2 3{{property declared here}}
-  // expected-note@+1 8{{mutation of this property is only permitted within the actor}}
+  // expected-note@+2 2{{property declared here}}
+  // expected-note@+1 6{{mutation of this property is only permitted within the actor}}
   var mutable: Int = 71
 
   // expected-note@+2 3 {{mutation of this property is only permitted within the actor}}
-  // expected-note@+1 5{{property declared here}}
+  // expected-note@+1 4{{property declared here}}
   var text: [String] = []
 
   let point : Point = Point()
@@ -70,7 +70,7 @@ actor MyActor: MySuperActor {
   class func synchronousClass() { }
   static func synchronousStatic() { }
 
-  func synchronous() -> String { text.first ?? "nothing" } // expected-note 20{{calls to instance method 'synchronous()' from outside of its actor context are implicitly asynchronous}}
+  func synchronous() -> String { text.first ?? "nothing" } // expected-note 19{{calls to instance method 'synchronous()' from outside of its actor context are implicitly asynchronous}}
   func asynchronous() async -> String {
     super.superState += 4
     return synchronous()
@@ -254,15 +254,15 @@ extension MyActor {
       _ = otherLocalVar
     }
 
-    // Escaping closures might run concurrently.
+    // Escaping closures are still actor-isolated
     acceptEscapingClosure {
-      _ = self.text[0] // expected-error{{actor-isolated property 'text' cannot be referenced from an '@escaping' closure}}
-      _ = self.mutable // expected-error{{actor-isolated property 'mutable' cannot be referenced from an '@escaping' closure}}
-      self.mutable = 0 // expected-error{{actor-isolated property 'mutable' cannot be mutated from an '@escaping' closure}}
-      acceptInout(&self.mutable) // expected-error{{actor-isolated property 'mutable' cannot be used 'inout' from an '@escaping' closure}}
+      _ = self.text[0]
+      _ = self.mutable
+      self.mutable = 0
+      acceptInout(&self.mutable)
       _ = self.immutable
-      _ = self.synchronous() // expected-error{{actor-isolated instance method 'synchronous()' cannot be referenced from an '@escaping' closure}}
-      _ = localVar // okay, don't complain about escaping
+      _ = self.synchronous()
+      _ = localVar
       _ = localConstant
     }
 
@@ -294,7 +294,7 @@ extension MyActor {
 
     // Partial application
     _ = synchronous  // expected-error{{actor-isolated instance method 'synchronous()' can not be partially applied}}
-    _ = super.superMethod // expected-error{{actor-isolated instance method 'superMethod()' can not be referenced from a non-isolated context}}
+    _ = super.superMethod
     acceptClosure(synchronous)
     acceptClosure(self.synchronous)
     acceptClosure(otherActor.synchronous) // expected-error{{actor-isolated instance method 'synchronous()' can only be referenced on 'self'}}

test/Concurrency/closure_isolation.swift

@@ -2,18 +2,29 @@
 // REQUIRES: concurrency
 
 func acceptClosure<T>(_: () -> T) { }
-func acceptEscapingClosure<T>(_: @escaping () -> T) { }
+func acceptSendableClosure<T>(_: @Sendable () -> T) { }
 
 func acceptAsyncClosure<T>(_: () async -> T) { }
 func acceptEscapingAsyncClosure<T>(_: @escaping () async -> T) { }
 
 actor MyActor {
   func method() async -> String { "" }
+  func syncMethod() -> String { "" }
 }
 
 extension MyActor {
   // CHECK-LABEL: testClosureIsolation
   func testClosureIsolation() async {
+    // CHECK: acceptClosure
+    // CHECK: closure_expr
+    // CHECK: actor-isolated
+    acceptClosure { self.syncMethod() }
+
+    // CHECK: acceptSendableClosure
+    // CHECK: closure_expr
+    // CHECK-NOT: actor-isolated
+    acceptSendableClosure { print(self) }
+
     // CHECK: acceptAsyncClosure
     // CHECK: closure_expr
     // CHECK-SAME: actor-isolated=closure_isolation.(file).MyActor extension.testClosureIsolation().self
@@ -22,17 +33,17 @@ extension MyActor {
     // CHECK: acceptAsyncClosure
     // CHECK: closure_expr
     // CHECK-NOT: actor-isolated
-    acceptAsyncClosure { () async in print("hello") }
+    acceptAsyncClosure { () async in print() }
 
     // CHECK: acceptEscapingAsyncClosure
     // CHECK: closure_expr
-    // CHECK-NOT: actor-isolated
-    acceptEscapingAsyncClosure { await self.method() }
+    // CHECK: actor-isolated
+    acceptEscapingAsyncClosure { self.syncMethod() }
 
     // CHECK: acceptEscapingAsyncClosure
     // CHECK: closure_expr
-    // CHECK-NOT:actor-isolated
-    acceptEscapingAsyncClosure { () async in print("hello") }
+    // CHECK: actor-isolated
+    acceptEscapingAsyncClosure { () async in print(self) }
   }
 }
 
@@ -61,11 +72,11 @@ func someAsyncFunc() async { }
 
   // CHECK: acceptEscapingAsyncClosure
   // CHECK: closure_expr
-  // CHECK-NOT: actor-isolated
+  // CHECK: actor-isolated
   acceptEscapingAsyncClosure { await someAsyncFunc() }
 
   // CHECK: acceptEscapingAsyncClosure
   // CHECK: closure_expr
-  // CHECK-NOT:actor-isolated
+  // CHECK: actor-isolated
   acceptEscapingAsyncClosure { () async in print("hello") }
 }