Merge pull request #71028 from gottesmm/pr-524e0ec6510c6afb2182d3f5538e7c333a323871

[region-isolation] Fix support for GlobalActor guarded variables and wordsmith some diagnostics.

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -893,16 +893,16 @@ NOTE(sil_referencebinding_inout_binding_here, none,
 WARNING(regionbasedisolation_selforargtransferred, none,
         "call site passes `self` or a non-sendable argument of this function to another thread, potentially yielding a race with the caller", ())
 WARNING(regionbasedisolation_transfer_yields_race_no_isolation, none,
-        "transferred value of non-Sendable type %0 that could race with later accesses",
+        "transferring value of non-Sendable type %0; later accesses could race",
         (Type))
 WARNING(regionbasedisolation_transfer_yields_race_with_isolation, none,
-        "passing argument of non-sendable type %0 from %1 context to %2 context at this call site could yield a race with accesses later in this function",
+        "transferring value of non-Sendable type %0 from %1 context to %2 context; later accesses could race",
         (Type, ActorIsolation, ActorIsolation))
 WARNING(regionbasedisolation_transfer_yields_race_transferring_parameter, none,
-        "transferred value of non-Sendable type %0 into transferring parameter; later accesses could result in races",
+        "transferring value of non-Sendable type %0 into transferring parameter; later accesses could race",
         (Type))
 WARNING(regionbasedisolation_transfer_yields_race_stronglytransferred_binding, none,
-        "binding of non-Sendable type %0 accessed after being transferred; later accesses could result in races",
+        "binding of non-Sendable type %0 accessed after being transferred; later accesses could race",
         (Type))
 NOTE(regionbasedisolation_maybe_race, none,
      "access here could race", ())

lib/SILOptimizer/Analysis/RegionAnalysis.cpp

@@ -2924,6 +2924,17 @@ TrackableValue RegionAnalysisValueMap::getTrackableValue(
           iter.first->getSecond().addFlag(TrackableValueFlag::isActorDerived);
         }
       }
+
+      // See if the memory base is a global_addr from a global actor protected global.
+      if (auto *ga = dyn_cast<GlobalAddrInst>(storage.base)) {
+        if (auto *global = ga->getReferencedGlobal()) {
+          if (auto *globalDecl = global->getDecl()) {
+            if (getActorIsolation(globalDecl).isGlobalActor()) {
+              iter.first->getSecond().addFlag(TrackableValueFlag::isActorDerived);
+            }
+          }
+        }
+      }
     }
   }
 

test/Concurrency/experimental_feature_strictconcurrency.swift

@@ -31,13 +31,13 @@ func iterate(stream: AsyncStream<Int>) async {
   // FIXME: Region isolation should consider a value from a 'nonisolated(unsafe)'
   // declaration to be in a disconnected region
 
-  // expected-region-isolation-warning@+2 {{passing argument of non-sendable type 'AsyncStream<Int>.Iterator' from main actor-isolated context to nonisolated context at this call site could yield a race with accesses later in this function}}
+  // expected-region-isolation-warning@+2 {{transferring value of non-Sendable type 'AsyncStream<Int>.Iterator' from main actor-isolated context to nonisolated context; later accesses could race}}
   // expected-region-isolation-note@+1 {{access here could race}}
   while let element = await it.next() {
     print(element)
   }
 
-  // expected-region-isolation-warning@+2 {{passing argument of non-sendable type 'AsyncStream<Int>.Iterator' from main actor-isolated context to nonisolated context at this call site could yield a race with accesses later in this function}}
+  // expected-region-isolation-warning@+2 {{transferring value of non-Sendable type 'AsyncStream<Int>.Iterator' from main actor-isolated context to nonisolated context; later accesses could race}}
   // expected-region-isolation-note@+1 {{access here could race}}
   for await x in stream {
     print(x)

test/Concurrency/sendable_checking.swift

@@ -273,7 +273,7 @@ func testNonSendableBaseArg() async {
   let t = NonSendable()
   await t.update()
   // expected-targeted-and-complete-warning @-1 {{passing argument of non-sendable type 'NonSendable' into main actor-isolated context may introduce data races}}
-  // expected-tns-warning@-2 {{passing argument of non-sendable type 'NonSendable' from nonisolated context to main actor-isolated context at this call site could yield a race with accesses later in this function}}
+  // expected-tns-warning@-2 {{transferring value of non-Sendable type 'NonSendable' from nonisolated context to main actor-isolated context; later accesses could race}}
 
   _ = await t.x
   // expected-warning @-1 {{non-sendable type 'NonSendable' passed in implicitly asynchronous call to main actor-isolated property 'x' cannot cross actor boundary}}

test/Concurrency/transfernonsendable.swift

@@ -44,7 +44,7 @@ bb2:
 bb3:
   %transferKlass = function_ref @transferKlass : $@convention(thin) @async (@guaranteed NonSendableKlass) -> ()
   apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %transferKlass(%klass) : $@convention(thin) @async (@guaranteed NonSendableKlass) -> ()
-  // expected-warning @-1 {{passing argument of non-sendable type 'NonSendableKlass' from nonisolated context to global actor '<null>'-isolated context at this call site could yield a race with accesses later in this function}}
+  // expected-warning @-1 {{transferring value of non-Sendable type 'NonSendableKlass' from nonisolated context to global actor '<null>'-isolated context; later accesses could race}}
   %useKlass = function_ref @useKlass : $@convention(thin) (@guaranteed NonSendableKlass) -> ()
   apply %useKlass(%klass) : $@convention(thin) (@guaranteed NonSendableKlass) -> ()
   // expected-note @-1 {{access here could race}}

test/Concurrency/transfernonsendable_asynclet.swift

@@ -89,7 +89,7 @@ private class NonSendableLinkedListNode<T> { // expected-complete-note 3{{}}
 @GlobalActor func useGlobalActor5() async {
   let x = NonSendableLinkedListNode<Int>()
 
-  await transferToNonIsolated(x) // expected-tns-warning {{passing argument of non-sendable type 'NonSendableLinkedListNode<Int>' from global actor 'GlobalActor'-isolated context to nonisolated context at this call site could yield a race with accesses later in this function}}
+  await transferToNonIsolated(x) // expected-tns-warning {{transferring value of non-Sendable type 'NonSendableLinkedListNode<Int>' from global actor 'GlobalActor'-isolated context to nonisolated context; later accesses could race}}
   // expected-complete-warning @-1 {{passing argument of non-sendable type 'NonSendableLinkedListNode<Int>' outside of global actor 'GlobalActor'-isolated context may introduce data races}}
 
   useValue(x) // expected-tns-note {{access here could race}}
@@ -104,7 +104,7 @@ private struct StructContainingValue { // expected-complete-note 2{{}}
   var x = StructContainingValue()
   x = StructContainingValue()
 
-  await transferToNonIsolated(x) // expected-tns-warning {{passing argument of non-sendable type 'StructContainingValue' from global actor 'GlobalActor'-isolated context to nonisolated context at this call site could yield a race with accesses later in this function}}
+  await transferToNonIsolated(x) // expected-tns-warning {{transferring value of non-Sendable type 'StructContainingValue' from global actor 'GlobalActor'-isolated context to nonisolated context; later accesses could race}}
   // expected-complete-warning @-1 {{passing argument of non-sendable type 'StructContainingValue' outside of global actor 'GlobalActor'-isolated context may introduce data races}}
 
   useValue(x) // expected-tns-note {{access here could race}}
@@ -124,7 +124,7 @@ private struct StructContainingValue { // expected-complete-note 2{{}}
   var x = (NonSendableLinkedList<Int>(), NonSendableLinkedList<Int>())
   x = (NonSendableLinkedList<Int>(), NonSendableLinkedList<Int>())
 
-  await transferToNonIsolated(x) // expected-tns-warning {{passing argument of non-sendable type '(NonSendableLinkedList<Int>, NonSendableLinkedList<Int>)' from global actor 'GlobalActor'-isolated context to nonisolated context at this call site could yield a race with accesses later in this function}}
+  await transferToNonIsolated(x) // expected-tns-warning {{transferring value of non-Sendable type '(NonSendableLinkedList<Int>, NonSendableLinkedList<Int>)' from global actor 'GlobalActor'-isolated context to nonisolated context; later accesses could race}}
   // expected-complete-warning @-1 {{passing argument of non-sendable type '(NonSendableLinkedList<Int>, NonSendableLinkedList<Int>)' outside of global actor 'GlobalActor'-isolated context may introduce data races}}
   // expected-complete-warning @-2 {{passing argument of non-sendable type '(NonSendableLinkedList<Int>, NonSendableLinkedList<Int>)' outside of global actor 'GlobalActor'-isolated context may introduce data races}}
 

test/Concurrency/transfernonsendable_cfg.sil

@@ -0,0 +1,53 @@
+// RUN: %target-swift-frontend -emit-sil -strict-concurrency=complete -enable-experimental-feature RegionBasedIsolation -disable-availability-checking -verify -verify-additional-prefix tns-  %s -o /dev/null -parse-as-library
+
+// Tests specific to global actors.
+
+// REQUIRES: concurrency
+// REQUIRES: asserts
+
+////////////////////////
+// MARK: Declarations //
+////////////////////////
+
+class Klass {}
+
+struct NonSendableStruct {
+  var first = Klass()
+  var second = Klass()
+}
+
+func useValue<T>(_ t: T) {}
+func getAny() -> Any { fatalError() }
+
+actor Custom {
+}
+
+@globalActor
+struct CustomActor {
+    static var shared: Custom {
+        return Custom()
+    }
+}
+
+@MainActor func transferToMain<T>(_ t: T) {}
+@CustomActor func transferToCustom<T>(_ t: T) {}
+
+@MainActor var globalKlass = Klass()
+
+/////////////////
+// MARK: Tests //
+/////////////////
+
+@MainActor func testTransferGlobalActorGuardedValue() async {
+  await transferToCustom(globalKlass) // expected-tns-warning {{call site passes `self` or a non-sendable argument of this function to another thread, potentially yielding a race with the caller}}
+}
+
+@MainActor func testTransferGlobalActorGuardedValueWithlet() async {
+  let x = globalKlass
+  await transferToCustom(x) // expected-tns-warning {{call site passes `self` or a non-sendable argument of this function to another thread, potentially yielding a race with the caller}}
+}
+
+@MainActor func testTransferGlobalActorGuardedValueWithlet(_ k: Klass) async {
+  globalKlass = k
+  await transferToCustom(k) // expected-tns-warning {{call site passes `self` or a non-sendable argument of this function to another thread, potentially yielding a race with the caller}}
+}