allow nonisolated + async + delegating actor inits.

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -4706,9 +4706,6 @@ ERROR(nonisolated_local_var,none,
 ERROR(nonisolated_actor_sync_init,none,
       "'nonisolated' on an actor's synchronous initializer is invalid",
       ())
-ERROR(nonisolated_actor_convenience_init,none,
-      "'nonisolated' on an actor's convenience initializer is redundant",
-      ())
 
 ERROR(actor_instance_property_wrapper,none,
       "%0 property in property wrapper type %1 cannot be isolated to "

lib/Sema/TypeCheckAttr.cpp

@@ -5643,17 +5643,13 @@ void AttributeChecker::visitNonisolatedAttr(NonisolatedAttr *attr) {
     }
   }
 
-  // `nonisolated` on most actor initializers is invalid or redundant.
+  // `nonisolated` on non-async actor initializers is invalid
+  // the reasoning is that there is a "little bit" of isolation,
+  // as afforded by flow-isolation.
   if (auto ctor = dyn_cast<ConstructorDecl>(D)) {
     if (auto nominal = dyn_cast<NominalTypeDecl>(dc)) {
       if (nominal->isAnyActor()) {
-        if (ctor->isConvenienceInit()) {
-          // all convenience inits are `nonisolated` by default
-          diagnoseAndRemoveAttr(attr, diag::nonisolated_actor_convenience_init)
-            .warnUntilSwiftVersion(6);
-          return;
-          
-        } else if (!ctor->hasAsync()) {
+        if (!ctor->hasAsync()) {
           // the isolation for a synchronous init cannot be `nonisolated`.
           diagnoseAndRemoveAttr(attr, diag::nonisolated_actor_sync_init)
             .warnUntilSwiftVersion(6);

test/Concurrency/actor_isolation.swift

@@ -1160,16 +1160,25 @@ class GenericSub2<T>: GenericSuper<[T]> { } // expected-error{{global actor 'Gen
 
 /// Diagnostics for `nonisolated` on an actor initializer.
 actor Butterfly {
+  var flapsPerSec = 0 // expected-note 3{{mutation of this property is only permitted within the actor}}
+
   nonisolated init() {} // expected-warning {{'nonisolated' on an actor's synchronous initializer is invalid; this is an error in Swift 6}} {{3-15=}}
 
   nonisolated init(async: Void) async {}
 
-  nonisolated convenience init(icecream: Void) { // expected-warning {{'nonisolated' on an actor's convenience initializer is redundant; this is an error in Swift 6}} {{3-15=}}
+  nonisolated convenience init(icecream: Void) { // expected-warning {{'nonisolated' on an actor's synchronous initializer is invalid; this is an error in Swift 6}} {{3-15=}}
+    self.init()
+    self.flapsPerSec += 1 // expected-error {{actor-isolated property 'flapsPerSec' can not be mutated from a non-isolated context}}
+  }
+
+  nonisolated convenience init(cookies: Void) async {
     self.init()
+    self.flapsPerSec += 1 // expected-error {{actor-isolated property 'flapsPerSec' can not be mutated from a non-isolated context}}
   }
 
-  nonisolated convenience init(cookies: Void) async { // expected-warning {{'nonisolated' on an actor's convenience initializer is redundant; this is an error in Swift 6}} {{3-15=}}
+  convenience init(brownies: Void) {
     self.init()
+    self.flapsPerSec = 0 // expected-error {{actor-isolated property 'flapsPerSec' can not be mutated from a non-isolated context}}
   }
 }
 

test/Concurrency/concurrent_value_checking.swift

@@ -1,7 +1,7 @@
 // RUN: %target-typecheck-verify-swift  -disable-availability-checking -warn-concurrency
 // REQUIRES: concurrency
 
-class NotConcurrent { } // expected-note 26{{class 'NotConcurrent' does not conform to the 'Sendable' protocol}}
+class NotConcurrent { } // expected-note 27{{class 'NotConcurrent' does not conform to the 'Sendable' protocol}}
 
 // ----------------------------------------------------------------------
 // Sendable restriction on actor operations
@@ -37,6 +37,14 @@ actor A2 {
     await self.init(valueAsync: value)
   }
 
+  nonisolated convenience init(nonisoAsync value: NotConcurrent, _ c: Int) async {
+    if c == 0 {
+      await self.init(valueAsync: value)
+    } else {
+      self.init(value: value)
+    }
+  }
+
   convenience init(delegatingAsync value: NotConcurrent, _ c: Int) async {
     if c == 0 {
       await self.init(valueAsync: value)
@@ -58,6 +66,8 @@ func testActorCreation(value: NotConcurrent) async {
   _ = A2(delegatingSync: value) // expected-warning{{non-sendable type 'NotConcurrent' passed in call to nonisolated initializer 'init(delegatingSync:)' cannot cross actor boundary}}
 
   _ = await A2(delegatingAsync: value, 9) // expected-warning{{non-sendable type 'NotConcurrent' passed in call to actor-isolated initializer 'init(delegatingAsync:_:)' cannot cross actor boundary}}
+
+  _ = await A2(nonisoAsync: value, 3) // expected-warning{{non-sendable type 'NotConcurrent' passed in call to nonisolated initializer 'init(nonisoAsync:_:)' cannot cross actor boundary}}
 }
 
 extension A1 {

test/Concurrency/flow_isolation.swift

@@ -392,6 +392,13 @@ actor MyActor {
         callMethod(self)
     }
 
+    convenience init(ci2 c: Bool) async {
+      self.init(i1: c)
+      self.x = 1
+      callMethod(self)
+      self.x = 0
+    }
+
     init(i1 c:  Bool) {
         self.x = 0
         _ = self.x

test/Distributed/distributed_actor_isolation.swift

@@ -197,7 +197,7 @@ distributed actor DijonMustard {
 
   func f() {} // expected-note {{distributed actor-isolated instance method 'f()' declared here}}
 
-  nonisolated convenience init(conv2: FakeActorSystem) { // expected-warning {{'nonisolated' on an actor's convenience initializer is redundant; this is an error in Swift 6}} {{3-15=}}
+  nonisolated convenience init(conv2: FakeActorSystem) { // expected-warning {{'nonisolated' on an actor's synchronous initializer is invalid; this is an error in Swift 6}} {{3-15=}}
     self.init(system: conv2)
   }
 }