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

Remove the heuristic that escaping closures cannot be actor-isolated.
This is in line with the long term plan for actor isolation, but opens
up some holes in the short term because Sendable closures are not enforced
throughout the Swift ecosystem.

One significant effect of this change is that we will now, statically,
fail to detect many cases where actor isolation can be broken.

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

@@ -22,7 +22,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
   }
 
@@ -40,12 +40,12 @@ class Point {
 
 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()
@@ -60,7 +60,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()
@@ -241,15 +241,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
     }
 
@@ -281,7 +281,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") }
+    // CHEC: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") }
 }