[Concurrency] Diagnose @GlobalActor(unsafe) attributes with a fix-it to use

`@preconcurrency` instead.

This diagnosic is a warning until Swift 6, and it's ignored in swiftinterfaces.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -5743,8 +5743,13 @@ ERROR(global_actor_on_local_variable,none,
 ERROR(global_actor_on_storage_of_value_type,none,
       "stored property %0 within struct cannot have a global actor",
       (DeclName))
-ERROR(global_actor_non_unsafe_init,none,
-      "global actor attribute %0 argument can only be '(unsafe)'", (Type))
+ERROR(unsafe_global_actor,none,
+      "'(unsafe)' global actors are deprecated; "
+      "use '@preconcurrency' instead",
+      ())
+ERROR(global_actor_arg,none,
+      "global actor attribute %0 cannot have arguments",
+      (Type))
 ERROR(global_actor_non_final_class,none,
       "non-final class %0 cannot be a global actor", (DeclName))
 ERROR(global_actor_top_level_var,none,

lib/Sema/TypeCheckConcurrency.cpp

@@ -4110,17 +4110,28 @@ getIsolationFromAttributes(const Decl *decl, bool shouldDiagnose = true,
       return ActorIsolation::forUnspecified();
 
     // Handle @<global attribute type>(unsafe).
-    bool isUnsafe = globalActorAttr->first->isArgUnsafe();
-    if (globalActorAttr->first->hasArgs() && !isUnsafe) {
-      ctx.Diags.diagnose(
-          globalActorAttr->first->getLocation(),
-          diag::global_actor_non_unsafe_init, globalActorType);
+    auto *attr = globalActorAttr->first;
+    bool isUnsafe = attr->isArgUnsafe();
+    if (attr->hasArgs()) {
+      if (isUnsafe) {
+        SourceFile *file = decl->getDeclContext()->getParentSourceFile();
+        bool inSwiftinterface =
+            file && file->Kind == SourceFileKind::Interface;
+        ctx.Diags.diagnose(
+            attr->getLocation(),
+            diag::unsafe_global_actor)
+          .fixItRemove(attr->getArgs()->getSourceRange())
+          .fixItInsert(attr->getLocation(), "@preconcurrency ")
+          .warnUntilSwiftVersion(6)
+          .limitBehaviorIf(inSwiftinterface, DiagnosticBehavior::Ignore);
+      } else {
+        ctx.Diags.diagnose(
+            attr->getLocation(),
+            diag::global_actor_arg, globalActorType)
+          .fixItRemove(attr->getArgs()->getSourceRange());
+      }
     }
 
-    // If the declaration predates concurrency, it has unsafe actor isolation.
-    if (decl->preconcurrency())
-      isUnsafe = true;
-
     return ActorIsolation::forGlobalActor(
         globalActorType->mapTypeOutOfContext())
         .withPreconcurrency(decl->preconcurrency() || isUnsafe);

test/Concurrency/actor_isolation_unsafe.swift

@@ -11,15 +11,18 @@ actor SomeGlobalActor {
   static let shared = SomeGlobalActor()
 }
 
+// expected-warning@+1 {{'(unsafe)' global actors are deprecated; use '@preconcurrency' instead}}
 @MainActor(unsafe) func globalMain() { } // expected-note {{calls to global function 'globalMain()' from outside of its actor context are implicitly asynchronous}}
 
+// expected-warning@+1 {{'(unsafe)' global actors are deprecated; use '@preconcurrency' instead}}
 @SomeGlobalActor(unsafe) func globalSome() { } // expected-note 2{{calls to global function 'globalSome()' from outside of its actor context are implicitly asynchronous}}
 // expected-complete-tns-note @-1 {{calls to global function 'globalSome()' from outside of its actor context are implicitly asynchronous}}
 
 // ----------------------------------------------------------------------
 // Witnessing and unsafe global actor
 // ----------------------------------------------------------------------
 protocol P1 {
+  // expected-warning@+1 {{'(unsafe)' global actors are deprecated; use '@preconcurrency' instead}}
   @MainActor(unsafe) func onMainActor() // expected-note 2{{mark the protocol requirement 'onMainActor()' 'async' to allow actor-isolated conformances}}
 }
 
@@ -45,7 +48,7 @@ struct S4_P1: P1 {
   @SomeGlobalActor func onMainActor() { } // expected-warning{{global actor 'SomeGlobalActor'-isolated instance method 'onMainActor()' cannot be used to satisfy main actor-isolated protocol requirement}}
 }
 
-
+// expected-warning@+1 {{'(unsafe)' global actors are deprecated; use '@preconcurrency' instead}}
 @MainActor(unsafe)
 protocol P2 {
   func f() // expected-note{{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
@@ -80,6 +83,7 @@ func testP2_noconcurrency(x: S5_P2, p2: P2) {
 // Overriding and unsafe global actor
 // ----------------------------------------------------------------------
 class C1 {
+  // expected-warning@+1 {{'(unsafe)' global actors are deprecated; use '@preconcurrency' instead}}
   @MainActor(unsafe) func method() { } // expected-note{{overridden declaration is here}}
 }
 
@@ -114,12 +118,14 @@ class C6: C2 {
 }
 
 class C7: C2 {
+  // expected-warning@+1 {{'(unsafe)' global actors are deprecated; use '@preconcurrency' instead}}
   @SomeGlobalActor(unsafe) override func method() { // expected-error{{global actor 'SomeGlobalActor'-isolated instance method 'method()' has different actor isolation from main actor-isolated overridden declaration}}
     globalMain() // expected-warning{{call to main actor-isolated global function 'globalMain()' in a synchronous global actor 'SomeGlobalActor'-isolated context}}
     globalSome() // okay
   }
 }
 
+// expected-warning@+1 {{'(unsafe)' global actors are deprecated; use '@preconcurrency' instead}}
 @MainActor(unsafe) // expected-note {{'GloballyIsolatedProto' is isolated to global actor 'MainActor' here}}
 protocol GloballyIsolatedProto {
 }

test/Concurrency/actor_keypath_isolation.swift

@@ -26,8 +26,8 @@ actor Door {
     @MainActor var globActor_mutable : Int = 0
     @MainActor let globActor_immutable : Int = 0
 
-    @MainActor(unsafe) var unsafeGlobActor_mutable : Int = 0
-    @MainActor(unsafe) let unsafeGlobActor_immutable : Int = 0
+    @preconcurrency @MainActor var unsafeGlobActor_mutable : Int = 0
+    @preconcurrency @MainActor let unsafeGlobActor_immutable : Int = 0
 
     subscript(byIndex: Int) -> Int { 0 }
 

test/Concurrency/actor_keypath_isolation_swift6.swift

@@ -25,8 +25,8 @@ actor Door {
     @MainActor var globActor_mutable : Int = 0
     @MainActor let globActor_immutable : Int = 0
 
-    @MainActor(unsafe) var unsafeGlobActor_mutable : Int = 0
-    @MainActor(unsafe) let unsafeGlobActor_immutable : Int = 0
+    @preconcurrency @MainActor var unsafeGlobActor_mutable : Int = 0
+    @preconcurrency @MainActor let unsafeGlobActor_immutable : Int = 0
 
     subscript(byIndex: Int) -> Int { 0 }
 

test/Concurrency/async_initializer.swift

@@ -112,8 +112,13 @@ enum E {
 struct SomeStruct {
   @MainActor init(asyncMainActor: Int) async {}
   @MainActor init(mainActor: Int) {} // expected-note {{calls to initializer 'init(mainActor:)' from outside of its actor context are implicitly asynchronous}}
+
+  // expected-warning@+1 {{'(unsafe)' global actors are deprecated; use '@preconcurrency' instead}}
   @MainActor(unsafe) init(asyncMainActorUnsafe: Int) async {}
-  @MainActor(unsafe) init(mainActorUnsafe: Int) {} // expected-complete-and-tns-note {{calls to initializer 'init(mainActorUnsafe:)' from outside of its actor context are implicitly asynchronous}}
+
+  // expected-warning@+2 {{'(unsafe)' global actors are deprecated; use '@preconcurrency' instead}}
+  // expected-complete-and-tns-note@+1 {{calls to initializer 'init(mainActorUnsafe:)' from outside of its actor context are implicitly asynchronous}}
+  @MainActor(unsafe) init(mainActorUnsafe: Int) {}
 }
 
 // expected-complete-and-tns-note @+3 {{add '@MainActor' to make global function 'globActorTest1()' part of global actor 'MainActor'}}

test/Concurrency/global_actor_function_types.swift

@@ -28,10 +28,10 @@ func testConversions(f: @escaping @SomeGlobalActor (Int) -> Void, g: @escaping (
 }
 
 @SomeGlobalActor func onSomeGlobalActor() -> Int { 5 }
-@SomeGlobalActor(unsafe) func onSomeGlobalActorUnsafe() -> Int { 5 }
+@preconcurrency @SomeGlobalActor func onSomeGlobalActorUnsafe() -> Int { 5 }
 
 @OtherGlobalActor func onOtherGlobalActor() -> Int { 5 } // expected-note{{calls to global function 'onOtherGlobalActor()' from outside of its actor context are implicitly asynchronous}}
-@OtherGlobalActor(unsafe) func onOtherGlobalActorUnsafe() -> Int { 5 }  // expected-note 2{{calls to global function 'onOtherGlobalActorUnsafe()' from outside of its actor context are implicitly asynchronous}}
+@preconcurrency @OtherGlobalActor func onOtherGlobalActorUnsafe() -> Int { 5 }  // expected-note 2{{calls to global function 'onOtherGlobalActorUnsafe()' from outside of its actor context are implicitly asynchronous}}
 // expected-complete-tns-note @-1 {{calls to global function 'onOtherGlobalActorUnsafe()' from outside of its actor context are implicitly asynchronous}}
 
 func someSlowOperation() async -> Int { 5 }

test/Concurrency/global_actor_inference.swift

@@ -49,7 +49,7 @@ struct Carbon {
 // ----------------------------------------------------------------------
 // Check that @MainActor(blah) doesn't work
 // ----------------------------------------------------------------------
-// expected-error@+1{{global actor attribute 'MainActor' argument can only be '(unsafe)'}}
+// expected-error@+1{{global actor attribute 'MainActor' cannot have arguments}}
 @MainActor(blah) func brokenMainActorAttr() { }
 
 // ----------------------------------------------------------------------
@@ -504,7 +504,7 @@ class WrappedContainsNonisolatedAttr {
 // Unsafe global actors
 // ----------------------------------------------------------------------
 protocol UGA {
-  @SomeGlobalActor(unsafe) func req() // expected-note{{calls to instance method 'req()' from outside of its actor context are implicitly asynchronous}}
+  @preconcurrency @SomeGlobalActor func req() // expected-note{{calls to instance method 'req()' from outside of its actor context are implicitly asynchronous}}
 }
 
 struct StructUGA1: UGA {
@@ -528,7 +528,7 @@ func testUGA<T: UGA>(_ value: T) {
 }
 
 class UGAClass {
-  @SomeGlobalActor(unsafe) func method() { }
+  @preconcurrency @SomeGlobalActor func method() { }
 }
 
 class UGASubclass1: UGAClass {
@@ -540,20 +540,20 @@ class UGASubclass2: UGAClass {
 }
 
 @propertyWrapper
-@OtherGlobalActor(unsafe)
+@preconcurrency @OtherGlobalActor
 struct WrapperOnUnsafeActor<Wrapped> {
   private var stored: Wrapped
 
   init(wrappedValue: Wrapped) {
     stored = wrappedValue
   }
 
-  @MainActor(unsafe) var wrappedValue: Wrapped {
+  @preconcurrency @MainActor var wrappedValue: Wrapped {
     get { }
     set { }
   }
 
-  @SomeGlobalActor(unsafe) var projectedValue: Wrapped {
+  @preconcurrency @SomeGlobalActor var projectedValue: Wrapped {
     get { }
     set { }
   }

test/Concurrency/require-explicit-sendable.swift

@@ -112,7 +112,7 @@ open class TestThing {}
 open class TestSubThing : TestThing {}
 
 @available(SwiftStdlib 5.1, *)
-@MainActor(unsafe)
+@MainActor(unsafe) // expected-warning {{'(unsafe)' global actors are deprecated; use '@preconcurrency' instead}}
 open class TestThing2 {}
 
 @available(SwiftStdlib 5.1, *)

test/Sema/availability_main_actor.swift

@@ -8,13 +8,13 @@
 @MainActor
 struct AlwaysAvailable {}
 
-@MainActor(unsafe)
+@preconcurrency @MainActor
 struct AlwaysAvailableUnsafe {}
 
 @available(SwiftStdlib 5.1, *)
 @MainActor
 struct AvailableSwift5_1 {}
 
 @available(SwiftStdlib 5.1, *)
-@MainActor(unsafe)
+@preconcurrency @MainActor
 struct AvailableSwift5_1Unsafe {}

test/decl/class/actor/global_actor_conformance.swift

@@ -58,7 +58,7 @@ extension OnMain: NonIsolatedRequirement {
 }
 
 // expected-note@+1 {{calls to global function 'downgrade()' from outside of its actor context are implicitly asynchronous}}
-@MainActor(unsafe) func downgrade() {}
+@preconcurrency @MainActor func downgrade() {}
 
 extension OnMain {
   struct Nested {