remove instances of redundant nonisolated on actor initializers

these appearances are considered errors, because it's already
implied by a convenience init. For a synchronous initializer,
we can't really describe _what_ it's isolation is right now,
but it is not just "nonisolated". So, we leave it ambiguous
and say that "nonisolated" is invalid.

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -4607,6 +4607,12 @@ ERROR(nonisolated_mutable_storage,none,
 ERROR(nonisolated_local_var,none,
       "'nonisolated' can not be applied to local variables",
       ())
+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

@@ -5535,6 +5535,26 @@ void AttributeChecker::visitNonisolatedAttr(NonisolatedAttr *attr) {
       return;
     }
   }
+  
+  // `nonisolated` on most actor initializers is invalid or redundant.
+  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()) {
+          // the isolation for a synchronous init cannot be `nonisolated`.
+          diagnoseAndRemoveAttr(attr, diag::nonisolated_actor_sync_init)
+            .warnUntilSwiftVersion(6);
+          return;
+        }
+      }
+    }
+  }
 
   if (auto VD = dyn_cast<ValueDecl>(D)) {
     (void)getActorIsolation(VD);

test/Concurrency/actor_definite_init.swift

@@ -409,11 +409,11 @@ actor EscapeArtist {
 actor Ahmad {
   func f() {}
 
-  nonisolated init(v1: Void) {
-    Task.detached { await self.f() } // expected-warning {{actor 'self' cannot be captured by a closure from a non-isolated, designated initializer}}
+  init(v1: Void) {
+    Task.detached { await self.f() } // 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}}
 
-    f()   // expected-warning {{this use of actor 'self' cannot appear in a non-isolated, designated initializer}}
+    f()   // expected-warning {{this use of actor 'self' can only appear in an async initializer}}
           // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
   }
 

test/Concurrency/actor_definite_init_swift6.swift

@@ -406,19 +406,19 @@ actor EscapeArtist {
 @available(SwiftStdlib 5.5, *)
 actor Ahmad {
   func f() {}
-  
-  nonisolated init(v1: Void) {
-    Task.detached { await self.f() } // expected-error {{actor 'self' cannot be captured by a closure from a non-isolated, designated initializer}}
-    // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-    
-    f()   // expected-error {{this use of actor 'self' cannot appear in a non-isolated, designated initializer}}
-    // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
+
+  init(v1: Void) {
+    Task.detached { await self.f() } // 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}}
+
+    f()   // expected-error {{this use of actor 'self' can only appear in an async initializer}}
+          // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
   }
-  
+
   nonisolated init(v2: Void) async {
     Task.detached { await self.f() } // expected-error {{actor 'self' cannot be captured by a closure from a non-isolated, designated initializer}} {{3-15=}}
     // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
-    
+
     f()   // expected-error {{this use of actor 'self' cannot appear in a non-isolated, designated initializer}}
     // expected-note@-1 {{convenience initializers allow non-isolated use of 'self' once initialized}}
   }

test/Concurrency/actor_isolation.swift

@@ -991,3 +991,18 @@ class GenericSub1<T>: GenericSuper<[T]> { }
 
 @GenericGlobalActor<T>
 class GenericSub2<T>: GenericSuper<[T]> { } // expected-error{{global actor 'GenericGlobalActor<T>'-isolated class 'GenericSub2' has different actor isolation from global actor 'GenericGlobalActor<U>'-isolated superclass 'GenericSuper'}}
+
+/// Diagnostics for `nonisolated` on an actor initializer.
+actor Butterfly {
+  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=}}
+    self.init()
+  }
+
+  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=}}
+    self.init()
+  }
+}

test/Distributed/distributed_actor_isolation.swift

@@ -175,10 +175,16 @@ func test_params(
 
 // Actor initializer isolation (through typechecking only!)
 distributed actor DijonMustard {
+  nonisolated init(transport: ActorTransport) {} // expected-warning {{'nonisolated' on an actor's synchronous initializer is invalid; this is an error in Swift 6}} {{3-15=}}
+
   convenience init(conv: ActorTransport) {
     self.init(transport: conv)
     self.f() // expected-error {{actor-isolated instance method 'f()' can not be referenced from a non-isolated context}}
   }
 
   func f() {} // expected-note {{distributed actor-isolated instance method 'f()' declared here}}
+
+  nonisolated convenience init(conv2: ActorTransport) { // expected-warning {{'nonisolated' on an actor's convenience initializer is redundant; this is an error in Swift 6}} {{3-15=}}
+    self.init(transport: conv2)
+  }
 }