Update "non-concurrent-value" diagnostics to say "non-sendable"

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4404,24 +4404,24 @@ ERROR(global_actor_isolated_requirement_witness_conflict,none,
       (DescriptiveDeclKind, DeclName, Type, Identifier, Type))
 
 WARNING(non_concurrent_param_type,none,
-        "cannot pass argument of non-concurrent-value type %0 across actors",
+        "cannot pass argument of non-sendable type %0 across actors",
         (Type))
 WARNING(non_concurrent_result_type,none,
-        "cannot call function returning non-concurrent-value type %0 across "
+        "cannot call function returning non-sendable type %0 across "
         "actors", (Type))
 WARNING(non_concurrent_property_type,none,
-        "cannot use %0 %1 with a non-concurrent-value type %2 "
+        "cannot use %0 %1 with a non-sendable type %2 "
         "%select{across actors|from concurrently-executed code}3",
         (DescriptiveDeclKind, DeclName, Type, bool))
 WARNING(non_concurrent_keypath_capture,none,
-        "cannot form key path that captures non-concurrent-value type %0",
+        "cannot form key path that captures non-sendable type %0",
         (Type))
 WARNING(non_concurrent_keypath_access,none,
-        "cannot form key path that accesses non-concurrent-value type %0",
+        "cannot form key path that accesses non-sendable type %0",
         (Type))
 ERROR(non_concurrent_type_member,none,
       "%select{stored property %1|associated value %1}0 of "
-      "'Sendable'-conforming %2 %3 has non-concurrent-value type %4",
+      "'Sendable'-conforming %2 %3 has non-sendable type %4",
       (bool, DeclName, DescriptiveDeclKind, DeclName, Type))
 ERROR(concurrent_value_class_mutable_property,none,
       "stored property %0 of 'Sendable'-conforming %1 %2 is mutable",

include/swift/Option/FrontendOptions.td

@@ -193,10 +193,10 @@ def enable_copy_propagation : Flag<["-"], "enable-copy-propagation">,
 def disable_copy_propagation : Flag<["-"], "disable-copy-propagation">,
   HelpText<"Don't run SIL copy propagation to preserve object lifetime.">;
 
-def enable_infer_public_concurrent_value : Flag<["-"], "enable-infer-public-concurrent-value">,
+def enable_infer_public_concurrent_value : Flag<["-"], "enable-infer-public-sendable">,
     HelpText<"Enable inference of Sendable conformances for public structs and enums">;
 
-def disable_infer_public_concurrent_value : Flag<["-"], "disable-infer-public-concurrent-value">,
+def disable_infer_public_concurrent_value : Flag<["-"], "disable-infer-public-sendable">,
     HelpText<"Disable inference of Sendable conformances for public structs and enums">;
 
 } // end let Flags = [FrontendOption, NoDriverOption]

test/Concurrency/actor_call_implicitly_async.swift

@@ -177,22 +177,22 @@ func blender(_ peeler : () -> Void) {
 
 
   await wisk({})
-  // expected-warning@-1{{cannot pass argument of non-concurrent-value type 'Any' across actors}}
+  // expected-warning@-1{{cannot pass argument of non-sendable type 'Any' across actors}}
   await wisk(1)
-  // expected-warning@-1{{cannot pass argument of non-concurrent-value type 'Any' across actors}}
+  // expected-warning@-1{{cannot pass argument of non-sendable type 'Any' across actors}}
   await (peelBanana)()
   await (((((peelBanana)))))()
   await (((wisk)))((wisk)((wisk)(1)))
-  // expected-warning@-1 3{{cannot pass argument of non-concurrent-value type 'Any' across actors}}
+  // expected-warning@-1 3{{cannot pass argument of non-sendable type 'Any' across actors}}
 
   blender((peelBanana)) // expected-error {{global function 'peelBanana()' isolated to global actor 'BananaActor' can not be referenced from different global actor 'OrangeActor'}}
   await wisk(peelBanana) // expected-error {{global function 'peelBanana()' isolated to global actor 'BananaActor' can not be referenced from different global actor 'OrangeActor'}}
-  // expected-warning@-1{{cannot pass argument of non-concurrent-value type 'Any' across actors}}
+  // expected-warning@-1{{cannot pass argument of non-sendable type 'Any' across actors}}
 
   await wisk(wisk)  // expected-error {{global function 'wisk' isolated to global actor 'BananaActor' can not be referenced from different global actor 'OrangeActor'}}
-  // expected-warning@-1{{cannot pass argument of non-concurrent-value type 'Any' across actors}}
+  // expected-warning@-1{{cannot pass argument of non-sendable type 'Any' across actors}}
   await (((wisk)))(((wisk))) // expected-error {{global function 'wisk' isolated to global actor 'BananaActor' can not be referenced from different global actor 'OrangeActor'}}
-  // expected-warning@-1{{cannot pass argument of non-concurrent-value type 'Any' across actors}}
+  // expected-warning@-1{{cannot pass argument of non-sendable type 'Any' across actors}}
 
   // expected-warning@+2 {{no 'async' operations occur within 'await' expression}}
   // expected-error@+1 {{global function 'wisk' isolated to global actor 'BananaActor' can not be referenced from different global actor 'OrangeActor'}}
@@ -240,18 +240,18 @@ actor Calculator {
 
 @OrangeActor func doSomething() async {
   let _ = (await bananaAdd(1))(2)
-  // expected-warning@-1{{cannot call function returning non-concurrent-value type}}
+  // expected-warning@-1{{cannot call function returning non-sendable type}}
   let _ = await (await bananaAdd(1))(2) // expected-warning{{no 'async' operations occur within 'await' expression}}
-  // expected-warning@-1{{cannot call function returning non-concurrent-value type}}
+  // expected-warning@-1{{cannot call function returning non-sendable type}}
 
   let calc = Calculator()
 
   let _ = (await calc.addCurried(1))(2)
-  // expected-warning@-1{{cannot call function returning non-concurrent-value type}}
+  // expected-warning@-1{{cannot call function returning non-sendable type}}
   let _ = await (await calc.addCurried(1))(2) // expected-warning{{no 'async' operations occur within 'await' expression}}
-  // expected-warning@-1{{cannot call function returning non-concurrent-value type}}
+  // expected-warning@-1{{cannot call function returning non-sendable type}}
 
   let plusOne = await calc.addCurried(await calc.add(0, 1))
-  // expected-warning@-1{{cannot call function returning non-concurrent-value type}}
+  // expected-warning@-1{{cannot call function returning non-sendable type}}
   let _ = plusOne(2)
 }

test/Concurrency/actor_isolation.swift

@@ -90,7 +90,7 @@ func checkAsyncPropertyAccess() async {
 
   act.text[0] += "hello" // expected-error{{actor-isolated property 'text' can only be mutated from inside the actor}}
 
-  _ = act.point // expected-warning{{cannot use property 'point' with a non-concurrent-value type 'Point' across actors}}
+  _ = act.point // expected-warning{{cannot use property 'point' with a non-sendable type 'Point' across actors}}
 }
 
 extension MyActor {
@@ -659,11 +659,11 @@ class SomeClassWithInits {
   func hasDetached() {
     Task.runDetached {
       // okay
-      await self.isolated() // expected-warning{{cannot use parameter 'self' with a non-concurrent-value type 'SomeClassWithInits' from concurrently-executed code}}
-      self.isolated() // expected-warning{{cannot use parameter 'self' with a non-concurrent-value type 'SomeClassWithInits' from concurrently-executed code}}
+      await self.isolated() // expected-warning{{cannot use parameter 'self' with a non-sendable type 'SomeClassWithInits' from concurrently-executed code}}
+      self.isolated() // expected-warning{{cannot use parameter 'self' with a non-sendable type 'SomeClassWithInits' from concurrently-executed code}}
       // expected-error@-1{{call is 'async' but is not marked with 'await'}}
 
-      print(await self.mutableState) // expected-warning{{cannot use parameter 'self' with a non-concurrent-value type 'SomeClassWithInits' from concurrently-executed code}}
+      print(await self.mutableState) // expected-warning{{cannot use parameter 'self' with a non-sendable type 'SomeClassWithInits' from concurrently-executed code}}
     }
   }
 }

test/Concurrency/actor_keypath_isolation.swift

@@ -47,7 +47,7 @@ func tryKeyPathsMisc(d : Door) {
 
     // in combination with other key paths
 
-    _ = (\Door.letBox).appending(path:  // expected-warning {{cannot form key path that accesses non-concurrent-value type 'Box?'}}
+    _ = (\Door.letBox).appending(path:  // expected-warning {{cannot form key path that accesses non-sendable type 'Box?'}}
                                        \Box?.?.size)
 
     _ = (\Door.varBox).appending(path:  // expected-error {{cannot form key path to actor-isolated property 'varBox'}}
@@ -61,9 +61,9 @@ func tryKeyPathsFromAsync() async {
 }
 
 func tryNonSendable() {
-    _ = \Door.letDict[0] // expected-warning {{cannot form key path that accesses non-concurrent-value type '[Int : Box]'}}
+    _ = \Door.letDict[0] // expected-warning {{cannot form key path that accesses non-sendable type '[Int : Box]'}}
     _ = \Door.varDict[0] // expected-error {{cannot form key path to actor-isolated property 'varDict'}}
-    _ = \Door.letBox!.size // expected-warning {{cannot form key path that accesses non-concurrent-value type 'Box?'}}
+    _ = \Door.letBox!.size // expected-warning {{cannot form key path that accesses non-sendable type 'Box?'}}
 }
 
 func tryKeypaths() {

test/Concurrency/concurrent_value_checking.swift

@@ -22,7 +22,7 @@ actor A2 {
 }
 
 func testActorCreation(value: NotConcurrent) {
-  _ = A2(value: value) // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent' across actors}}
+  _ = A2(value: value) // expected-warning{{cannot pass argument of non-sendable type 'NotConcurrent' across actors}}
 }
 
 extension A1 {
@@ -37,9 +37,9 @@ extension A1 {
     _ = await self.asynchronous(nil)
 
     // Across to a different actor, so Sendable restriction is enforced.
-    _ = other.localLet // expected-warning{{cannot use property 'localLet' with a non-concurrent-value type 'NotConcurrent' across actors}}
-    _ = await other.synchronous() // expected-warning{{cannot call function returning non-concurrent-value type 'NotConcurrent?' across actors}}
-    _ = await other.asynchronous(nil) // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent?' across actors}}
+    _ = other.localLet // expected-warning{{cannot use property 'localLet' with a non-sendable type 'NotConcurrent' across actors}}
+    _ = await other.synchronous() // expected-warning{{cannot call function returning non-sendable type 'NotConcurrent?' across actors}}
+    _ = await other.asynchronous(nil) // expected-warning{{cannot pass argument of non-sendable type 'NotConcurrent?' across actors}}
   }
 }
 
@@ -67,9 +67,9 @@ func globalAsync(_: NotConcurrent?) async {
 }
 
 func globalTest() async {
-  let a = globalValue // expected-warning{{cannot use let 'globalValue' with a non-concurrent-value type 'NotConcurrent?' across actors}}
-  await globalAsync(a) // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent?' across actors}}
-  await globalSync(a)  // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent?' across actors}}
+  let a = globalValue // expected-warning{{cannot use let 'globalValue' with a non-sendable type 'NotConcurrent?' across actors}}
+  await globalAsync(a) // expected-warning{{cannot pass argument of non-sendable type 'NotConcurrent?' across actors}}
+  await globalSync(a)  // expected-warning{{cannot pass argument of non-sendable type 'NotConcurrent?' across actors}}
 }
 
 struct HasSubscript {
@@ -88,10 +88,10 @@ class ClassWithGlobalActorInits {
 
 @MainActor
 func globalTestMain(nc: NotConcurrent) async {
-  let a = globalValue // expected-warning{{cannot use let 'globalValue' with a non-concurrent-value type 'NotConcurrent?' across actors}}
-  await globalAsync(a) // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent?' across actors}}
-  await globalSync(a)  // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent?' across actors}}
-  _ = await ClassWithGlobalActorInits(nc) // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent' across actors}}
+  let a = globalValue // expected-warning{{cannot use let 'globalValue' with a non-sendable type 'NotConcurrent?' across actors}}
+  await globalAsync(a) // expected-warning{{cannot pass argument of non-sendable type 'NotConcurrent?' across actors}}
+  await globalSync(a)  // expected-warning{{cannot pass argument of non-sendable type 'NotConcurrent?' across actors}}
+  _ = await ClassWithGlobalActorInits(nc) // expected-warning{{cannot pass argument of non-sendable type 'NotConcurrent' across actors}}
   _ = await ClassWithGlobalActorInits()
 }
 
@@ -117,7 +117,7 @@ func testConcurrency() {
     print(y) // okay
   }
   acceptConcurrent {
-    print(x) // expected-warning{{cannot use let 'x' with a non-concurrent-value type 'NotConcurrent' from concurrently-executed code}}
+    print(x) // expected-warning{{cannot use let 'x' with a non-sendable type 'NotConcurrent' from concurrently-executed code}}
     print(y) // expected-error{{reference to captured var 'y' in concurrently-executing code}}
   }
 }
@@ -135,7 +135,7 @@ class HasNC {
 }
 
 func testKeyPaths(dict: [NC: Int], nc: NC) {
-  _ = \HasNC.dict[nc] // expected-warning{{cannot form key path that captures non-concurrent-value type 'NC'}}
+  _ = \HasNC.dict[nc] // expected-warning{{cannot form key path that captures non-sendable type 'NC'}}
 }
 
 
@@ -148,7 +148,7 @@ protocol AsyncProto {
 
 extension A1: AsyncProto {
   // FIXME: Poor diagnostic.
-  func asyncMethod(_: NotConcurrent) async { } // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent' across actors}}
+  func asyncMethod(_: NotConcurrent) async { } // expected-warning{{cannot pass argument of non-sendable type 'NotConcurrent' across actors}}
 }
 
 protocol MainActorProto {
@@ -157,7 +157,7 @@ protocol MainActorProto {
 
 class SomeClass: MainActorProto {
   @SomeGlobalActor
-  func asyncMainMethod(_: NotConcurrent) async { } // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent' across actors}}
+  func asyncMainMethod(_: NotConcurrent) async { } // expected-warning{{cannot pass argument of non-sendable type 'NotConcurrent' across actors}}
 }
 
 // ----------------------------------------------------------------------
@@ -183,19 +183,19 @@ func acceptConcurrentUnary<T>(_: @concurrent (T) -> T) { }
 func concurrentClosures<T>(_: T) {
   acceptConcurrentUnary { (x: T) in
     _ = x // ok
-    acceptConcurrentUnary { _ in x } // expected-warning{{cannot use parameter 'x' with a non-concurrent-value type 'T' from concurrently-executed code}}
+    acceptConcurrentUnary { _ in x } // expected-warning{{cannot use parameter 'x' with a non-sendable type 'T' from concurrently-executed code}}
   }
 }
 
 // ----------------------------------------------------------------------
 // Sendable checking
 // ----------------------------------------------------------------------
 struct S1: Sendable {
-  var nc: NotConcurrent // expected-error{{stored property 'nc' of 'Sendable'-conforming struct 'S1' has non-concurrent-value type 'NotConcurrent'}}
+  var nc: NotConcurrent // expected-error{{stored property 'nc' of 'Sendable'-conforming struct 'S1' has non-sendable type 'NotConcurrent'}}
 }
 
 struct S2<T>: Sendable {
-  var nc: T // expected-error{{stored property 'nc' of 'Sendable'-conforming generic struct 'S2' has non-concurrent-value type 'T'}}
+  var nc: T // expected-error{{stored property 'nc' of 'Sendable'-conforming generic struct 'S2' has non-sendable type 'T'}}
 }
 
 struct S3<T> {
@@ -206,7 +206,7 @@ struct S3<T> {
 extension S3: Sendable where T: Sendable { }
 
 enum E1: Sendable {
-  case payload(NotConcurrent) // expected-error{{associated value 'payload' of 'Sendable'-conforming enum 'E1' has non-concurrent-value type 'NotConcurrent'}}
+  case payload(NotConcurrent) // expected-error{{associated value 'payload' of 'Sendable'-conforming enum 'E1' has non-sendable type 'NotConcurrent'}}
 }
 
 enum E2<T> {
@@ -216,7 +216,7 @@ enum E2<T> {
 extension E2: Sendable where T: Sendable { }
 
 final class C1: Sendable {
-  let nc: NotConcurrent? = nil // expected-error{{stored property 'nc' of 'Sendable'-conforming class 'C1' has non-concurrent-value type 'NotConcurrent?'}}
+  let nc: NotConcurrent? = nil // expected-error{{stored property 'nc' of 'Sendable'-conforming class 'C1' has non-sendable type 'NotConcurrent?'}}
   var x: Int = 0 // expected-error{{stored property 'x' of 'Sendable'-conforming class 'C1' is mutable}}
   let i: Int = 0
 }
@@ -227,11 +227,11 @@ final class C2: Sendable {
 
 class C3 { }
 
-class C4: C3, UnsafeSendable {
+class C4: C3, UnsafeSendable { // expected-warning{{'UnsafeSendable' is deprecated: Use @unchecked Sendable instead}}
   var y: Int = 0 // okay
 }
 
-class C5: UnsafeSendable {
+class C5: UnsafeSendable { // expected-warning{{'UnsafeSendable' is deprecated: Use @unchecked Sendable instead}}
   var x: Int = 0 // okay
 }
 
@@ -246,15 +246,15 @@ class C9: Sendable { } // expected-error{{non-final class 'C9' cannot conform to
 // ----------------------------------------------------------------------
 // UnsafeSendable disabling checking
 // ----------------------------------------------------------------------
-struct S11: UnsafeSendable {
+struct S11: UnsafeSendable { // expected-warning{{'UnsafeSendable' is deprecated: Use @unchecked Sendable instead}}
   var nc: NotConcurrent // okay
 }
 
-struct S12<T>: UnsafeSendable {
+struct S12<T>: UnsafeSendable { // expected-warning{{'UnsafeSendable' is deprecated: Use @unchecked Sendable instead}}
   var nc: T // okay
 }
 
-enum E11<T>: UnsafeSendable {
+enum E11<T>: UnsafeSendable { // expected-warning{{'UnsafeSendable' is deprecated: Use @unchecked Sendable instead}}
   case payload(NotConcurrent) // okay
   case other(T) // okay
 }

test/Concurrency/concurrent_value_checking_objc.swift

@@ -16,7 +16,7 @@ final class B: NSObject, Sendable {
 class C { }
 
 final class D: NSObject, Sendable {
-  let c: C = C() // expected-error{{stored property 'c' of 'Sendable'-conforming class 'D' has non-concurrent-value type 'C'}}
+  let c: C = C() // expected-error{{stored property 'c' of 'Sendable'-conforming class 'D' has non-sendable type 'C'}}
 }
 
 

test/Concurrency/concurrent_value_inference_public.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -enable-infer-public-concurrent-value
+// RUN: %target-typecheck-verify-swift -enable-infer-public-sendable
 
 func acceptCV<T: Sendable>(_: T) { }
 

test/Concurrency/concurrentfunction_capturediagnostics.swift

@@ -86,7 +86,7 @@ func testCaseTrivialValue4() {
                     // expected-note @-8 {{capturing use}}
 }
 
-class Klass: UnsafeSendable {
+class Klass: UnsafeSendable { // expected-warning{{'UnsafeSendable' is deprecated: Use @unchecked Sendable instead}}
   var next: Klass? = nil
 }
 func inoutUserKlass(_ k: inout Klass) {}

test/Inputs/clang-importer-sdk/swift-modules/Foundation.swift

@@ -221,7 +221,7 @@ public struct URL : _ObjectiveCBridgeable {
  }
 }
 
-extension NSError : Error, UnsafeSendable {
+extension NSError : Error, UnsafeSendable { // expected-warning{{'UnsafeSendable' is deprecated: Use @unchecked Sendable instead}}
   public var _domain: String { return domain }
   public var _code: Int { return code }
 }