make synchronous inits have a nonisolated self

Author: kavon

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -2043,25 +2043,27 @@ bool LifetimeChecker::isRestrictedActorInitSelf(ActorInitKind *kind) const {
     auto isolation = getActorIsolation(ctor);
     switch (isolation.getKind()) {
       case ActorIsolation::Unspecified:
-        llvm_unreachable("actor decl with unspecified isolation?");
+        assert(ctor->isObjC() && "unexpected kind of actor ctor isolation");
+        break;
 
       case ActorIsolation::Independent:
         if (isExplicitlyNonIsolated(ctor))
           return result(ActorInitKind::NonIsolated, true);
-
-        llvm_unreachable("implicitly nonisolated actor init?");
+        break;
 
       case ActorIsolation::ActorInstance:
       case ActorIsolation::DistributedActorInstance:
-        if (ctor->hasAsync())
-          return result(ActorInitKind::PlainAsync, false);
-        else
-          return result(ActorInitKind::Plain, true);
+        break; // handle these below.
 
       case ActorIsolation::GlobalActor:
       case ActorIsolation::GlobalActorUnsafe:
         return result(ActorInitKind::GlobalActorIsolated, true);
     };
+
+    if (ctor->hasAsync())
+      return result(ActorInitKind::PlainAsync, false);
+    else
+      return result(ActorInitKind::Plain, true);
   }
 
   return result(ActorInitKind::None, false);

lib/Sema/TypeCheckConcurrency.cpp

@@ -3230,11 +3230,12 @@ ActorIsolation ActorIsolationRequest::evaluate(
     }
   }
 
-  // Every actor's convenience init is assumed to be actor-independent.
+  // Every actor's convenience or synchronous init is
+  // assumed to be actor-independent.
   if (auto nominal = value->getDeclContext()->getSelfNominalTypeDecl())
     if (nominal->isAnyActor())
       if (auto ctor = dyn_cast<ConstructorDecl>(value))
-        if (ctor->isConvenienceInit())
+        if (ctor->isConvenienceInit() || !ctor->hasAsync())
           defaultIsolation = ActorIsolation::forIndependent();
 
   // Function used when returning an inferred isolation.
@@ -3448,11 +3449,10 @@ bool HasIsolatedSelfRequest::evaluate(
     }
   }
 
-  // In an actor's convenience init, self is not isolated.
   if (auto ctor = dyn_cast<ConstructorDecl>(value)) {
-    if (ctor->isConvenienceInit()) {
+    // In an actor's convenience or synchronous init, self is not isolated.
+    if (ctor->isConvenienceInit() || !ctor->hasAsync())
       return false;
-    }
   }
 
   return true;

test/Concurrency/actor_definite_init.swift

@@ -141,8 +141,8 @@ actor MyActor {
 
         Task { // expected-warning {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = self.hax
-            self.helloWorld()
+            _ = await self.hax
+            await self.helloWorld()
         }
     }
 
@@ -175,8 +175,8 @@ actor MyActor {
 
         Task { // expected-warning {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = self.hax
-            self.helloWorld()
+            _ = await self.hax
+            await self.helloWorld()
         }
     }
 
@@ -209,8 +209,8 @@ actor MyActor {
 
         Task { // expected-warning {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = self.hax
-            self.helloWorld()
+            _ = await self.hax
+            await self.helloWorld()
         }
     }
 
@@ -315,7 +315,7 @@ actor X {
 
     init(v1 start: Int) {
         self.counter = start
-        Task { self.setCounter(start + 1) } // expected-warning {{actor 'self' can only be captured by a closure from an async initializer}}
+        Task { await self.setCounter(start + 1) } // expected-warning {{actor 'self' can only be captured by a closure from an async initializer}}
                                                   // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
 
         if self.counter != start {

test/Concurrency/actor_definite_init_swift6.swift

@@ -137,8 +137,8 @@ actor MyActor {
 
         Task { // expected-error {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = self.hax
-            self.helloWorld()
+            _ = await self.hax
+            await self.helloWorld()
         }
     }
 
@@ -171,8 +171,8 @@ actor MyActor {
 
         Task { // expected-error {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = self.hax
-            self.helloWorld()
+            _ = await self.hax
+            await self.helloWorld()
         }
     }
 
@@ -205,8 +205,8 @@ actor MyActor {
 
         Task { // expected-error {{actor 'self' can only be captured by a closure from an async initializer}}
                // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-            _ = self.hax
-            self.helloWorld()
+            _ = await self.hax
+            await self.helloWorld()
         }
     }
 
@@ -311,7 +311,7 @@ actor X {
 
     init(v1 start: Int) {
         self.counter = start
-        Task { self.setCounter(start + 1) } // expected-error {{actor 'self' can only be captured by a closure from an async initializer}}
+        Task { await self.setCounter(start + 1) } // expected-error {{actor 'self' can only be captured by a closure from an async initializer}}
                                                   // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
 
         if self.counter != start {

test/Concurrency/actor_isolation.swift

@@ -1007,65 +1007,81 @@ actor Butterfly {
   }
 }
 
-// Test the isolation of `self` in constructors and deinits of an actor.
-// We know that Task.init accepts a special closure that inherits the isolation
-// of the context based on the isolation of values captured in the closure,
-// like `self`.
+// expected-note@+1 2 {{calls to global function 'takeIsolated' from outside of its actor context are implicitly asynchronous}}
+func takeIsolated(_ val: isolated SelfParamIsolationNonMethod) {}
+func take(_ val: SelfParamIsolationNonMethod) {}
+
 actor SelfParamIsolationNonMethod {
   init(s0: Void) {
-    Task { self.f() }
+    // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+    // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+    acceptAsyncSendableClosureInheriting { self.f() }
 
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task.detached { self.f() }
+    acceptAsyncSendableClosure { self.f() }
+
+    // expected-error@+1 {{call to actor-isolated global function 'takeIsolated' in a synchronous nonisolated context}}
+    takeIsolated(self)
+
+    take(self)
   }
 
   @MainActor init(s1: Void) {
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task { self.f() }
+    acceptAsyncSendableClosureInheriting { self.f() }
 
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task.detached { self.f() }
+    acceptAsyncSendableClosure { self.f() }
   }
 
   init(a1: Void) async {
-    Task { self.f() }
+    acceptAsyncSendableClosureInheriting { self.f() }
 
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task.detached { self.f() }
+    acceptAsyncSendableClosure { self.f() }
+
+    takeIsolated(self)
+
+    take(self)
   }
 
   @MainActor init(a2: Void) async {
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task { self.f() }
+    acceptAsyncSendableClosureInheriting { self.f() }
 
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task.detached { self.f() }
+    acceptAsyncSendableClosure { self.f() }
   }
 
   nonisolated init(a3: Void) async {
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task { self.f() }
+    acceptAsyncSendableClosureInheriting { self.f() }
 
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task.detached { self.f() }
+    acceptAsyncSendableClosure { self.f() }
   }
 
   deinit {
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task { self.f() }
+    acceptAsyncSendableClosureInheriting { self.f() }
 
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task.detached { self.f() }
+    acceptAsyncSendableClosure { self.f() }
+
+    // expected-error@+1 {{call to actor-isolated global function 'takeIsolated' in a synchronous nonisolated context}}
+    takeIsolated(self)
+
+    take(self)
   }
 
   func f() {}
@@ -1074,21 +1090,21 @@ actor SelfParamIsolationNonMethod {
 @MainActor
 final class MainActorInit: Sendable {
   init() {
-    Task { self.f() }
+    acceptAsyncSendableClosureInheriting { self.f() }
 
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task.detached { self.f() }
+    acceptAsyncSendableClosure { self.f() }
   }
 
   deinit {
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task { self.f() }
+    acceptAsyncSendableClosureInheriting { self.f() }
 
     // expected-note@+2 {{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
     // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
-    Task.detached { self.f() }
+    acceptAsyncSendableClosure { self.f() }
   }
 
   func f() {}

test/decl/class/actor/basic.swift

@@ -14,10 +14,9 @@ actor MyActorSubclass2: MyActor { } // expected-error{{actor types do not suppor
 // expected-error@+1{{keyword 'class' cannot be used as an identifier here}}
 actor class MyActorClass { }
 
-class NonActor { } // expected-note{{overridden declaration is here}}
+class NonActor { }
 
 actor NonActorSubclass : NonActor { } // expected-error{{actor types do not support inheritance}}
-// expected-error@-1{{actor-isolated initializer 'init()' has different actor isolation from nonisolated overridden declaration}}
 
 // expected-error@+1{{keyword 'class' cannot be used as an identifier here}}
 public actor class BobHope {}