[region-isolation] Squelch use after transfer if the use has effectively the same isolation as the transfer inst.

To be more specific this means that either:

1. The use is actually isolated to the same actor. This could mean that the
use is global actor isolated to the same function.

2. The use is nonisolated but is executing within a function that is globally
isolated to the same isolation domain.

rdar://123474616

Author: gottesmm

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -17,6 +17,7 @@
 #include "swift/Basic/FrozenMultiMap.h"
 #include "swift/Basic/ImmutablePointerSet.h"
 #include "swift/Basic/LLVM.h"
+#include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILInstruction.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Debug.h"
@@ -756,8 +757,8 @@ struct PartitionOpEvaluator {
       // value... emit an error.
       if (auto *transferredOperandSet = p.getTransferred(op.getOpArgs()[1])) {
         for (auto transferredOperand : transferredOperandSet->data()) {
-          handleLocalUseAfterTransfer(op, op.getOpArgs()[1],
-                                      transferredOperand);
+          handleLocalUseAfterTransferHelper(op, op.getOpArgs()[1],
+                                            transferredOperand);
         }
       }
       p.assignElement(op.getOpArgs()[0], op.getOpArgs()[1]);
@@ -839,14 +840,14 @@ struct PartitionOpEvaluator {
       // if attempting to merge a transferred region, handle the failure
       if (auto *transferredOperandSet = p.getTransferred(op.getOpArgs()[0])) {
         for (auto transferredOperand : transferredOperandSet->data()) {
-          handleLocalUseAfterTransfer(op, op.getOpArgs()[0],
-                                      transferredOperand);
+          handleLocalUseAfterTransferHelper(op, op.getOpArgs()[0],
+                                            transferredOperand);
         }
       }
       if (auto *transferredOperandSet = p.getTransferred(op.getOpArgs()[1])) {
         for (auto transferredOperand : transferredOperandSet->data()) {
-          handleLocalUseAfterTransfer(op, op.getOpArgs()[1],
-                                      transferredOperand);
+          handleLocalUseAfterTransferHelper(op, op.getOpArgs()[1],
+                                            transferredOperand);
         }
       }
 
@@ -859,8 +860,8 @@ struct PartitionOpEvaluator {
              "Require PartitionOp's argument should already be tracked");
       if (auto *transferredOperandSet = p.getTransferred(op.getOpArgs()[0])) {
         for (auto transferredOperand : transferredOperandSet->data()) {
-          handleLocalUseAfterTransfer(op, op.getOpArgs()[0],
-                                      transferredOperand);
+          handleLocalUseAfterTransferHelper(op, op.getOpArgs()[0],
+                                            transferredOperand);
         }
       }
       return;
@@ -873,6 +874,33 @@ struct PartitionOpEvaluator {
     for (auto &o : ops)
       apply(o);
   }
+
+private:
+  // Private helper that squelches the error if our transfer instruction and our
+  // use have the same isolation.
+  void
+  handleLocalUseAfterTransferHelper(const PartitionOp &op, Element elt,
+                                    TransferringOperand *transferringOp) const {
+    if (auto isolationInfo = SILIsolationInfo::get(op.getSourceInst())) {
+      if (isolationInfo.isActorIsolated() &&
+          isolationInfo == SILIsolationInfo::get(transferringOp->getUser()))
+        return;
+    }
+
+    // If our instruction does not have any isolation info associated with it,
+    // it must be nonisolated. See if our function has a matching isolation to
+    // our transferring operand. If so, we can squelch this.
+    if (auto functionIsolation =
+            transferringOp->getUser()->getFunction()->getActorIsolation()) {
+      if (functionIsolation->isActorIsolated() &&
+          SILIsolationInfo::getActorIsolated(*functionIsolation) ==
+              SILIsolationInfo::get(transferringOp->getUser()))
+        return;
+    }
+
+    // Ok, we actually need to emit a call to the callback.
+    return handleLocalUseAfterTransfer(op, elt, transferringOp);
+  }
 };
 
 /// A base implementation that can be used to default initialize CRTP

test/Concurrency/transfernonsendable.swift

@@ -15,7 +15,7 @@
 ////////////////////////
 
 /// Classes are always non-sendable, so this is non-sendable
-class NonSendableKlass { // expected-complete-note 36{{}}
+class NonSendableKlass { // expected-complete-note 38{{}}
   // expected-typechecker-only-note @-1 4{{}}
   // expected-tns-note @-2 2{{}}
   var field: NonSendableKlass? = nil
@@ -129,16 +129,44 @@ func closureInOut(_ a: Actor) async {
   // expected-tns-warning @-2 {{transferring 'ns0' may cause a race}}
   // expected-tns-note @-3 {{transferring disconnected 'ns0' to actor-isolated callee could cause races in between callee actor-isolated and local nonisolated uses}}
 
+  if await booleanFlag {
+    // This is not an actual use since we are passing values to the same
+    // isolation domain.
+    await a.useKlass(ns1)
+    // expected-complete-warning @-1 {{passing argument of non-sendable type 'NonSendableKlass'}}
+  } else {
+    closure() // expected-tns-note {{use here could race}}
+  }
+}
+
+func closureInOutDifferentActor(_ a: Actor, _ a2: Actor) async {
+  var contents = NonSendableKlass()
+  let ns0 = NonSendableKlass()
+  let ns1 = NonSendableKlass()
+
+  contents = ns0
+  contents = ns1
+
+  var closure = {}
+  closure = { useInOut(&contents) }
+
+  await a.useKlass(ns0)
+  // expected-complete-warning @-1 {{passing argument of non-sendable type 'NonSendableKlass'}}
+  // expected-tns-warning @-2 {{transferring 'ns0' may cause a race}}
+  // expected-tns-note @-3 {{transferring disconnected 'ns0' to actor-isolated callee could cause races in between callee actor-isolated and local nonisolated uses}}
+
   // We only emit a warning on the first use we see, so make sure we do both
-  // klass and the closure.
+  // the print and the closure.
   if await booleanFlag {
-    await a.useKlass(ns1) // expected-tns-note {{use here could race}}
+    // This is an actual use since a2 is a different actor from a1
+    await a2.useKlass(ns1)
     // expected-complete-warning @-1 {{passing argument of non-sendable type 'NonSendableKlass'}}
   } else {
     closure() // expected-tns-note {{use here could race}}
   }
 }
 
+
 func closureInOut2(_ a: Actor) async {
   var contents = NonSendableKlass()
   let ns0 = NonSendableKlass()
@@ -1182,9 +1210,11 @@ func varNonSendableNonTrivialLetStructFieldClosureFlowSensitive4() async {
     // good... that is QoI though.
     await transferToMain(test) // expected-tns-warning {{transferring 'test' may cause a race}}
     // expected-tns-note @-1 {{transferring disconnected 'test' to main actor-isolated callee could cause races in between callee main actor-isolated and local nonisolated uses}}
-    // expected-tns-note @-2 {{use here could race}}
-    // expected-complete-warning @-3 {{passing argument of non-sendable type 'StructFieldTests' into main actor-isolated context may introduce data races}}
-    test = StructFieldTests()
+    // expected-complete-warning @-2 {{passing argument of non-sendable type 'StructFieldTests' into main actor-isolated context may introduce data races}}
+
+    // This is treated as a use since test is in box form and is mutable. So we
+    // treat assignment as a merge.
+    test = StructFieldTests() // expected-tns-note {{use here could race}}
     cls = {
       useInOut(&test.varSendableNonTrivial)
     }
@@ -1215,7 +1245,7 @@ func varNonSendableNonTrivialLetStructFieldClosureFlowSensitive5() async {
   }
 
   test.varSendableNonTrivial = SendableKlass()
-  useValue(test)
+  useValue(test) // expected-tns-note {{use here could race}}
 }
 
 func varNonSendableNonTrivialLetStructFieldClosureFlowSensitive6() async {
@@ -1387,7 +1417,7 @@ func controlFlowTest2() async {
     x = NonSendableKlass()
   }
 
-  useValue(x)
+  useValue(x) // expected-tns-note {{use here could race}}
 }
 
 ////////////////////////

test/Concurrency/transfernonsendable_global_actor.swift

@@ -209,3 +209,15 @@ struct Clock {
 
   useValue(ns)
 }
+
+@MainActor func testGlobalAndDisconnected() {
+  let ns = NonSendableKlass()
+
+  let _ = { @MainActor in
+    print(ns)
+  }
+
+  // Since useValue is running in an actor isolated context, it is ok to use the
+  // transferred value 'ns' here.
+  useValue(ns)
+}

test/Concurrency/transfernonsendable_global_actor_transferring.swift

@@ -27,9 +27,8 @@ func useValue<T>(_ t: T) {}
 
   // Will be resolved once @MainActor is @Sendable
   Task.fakeInit { @MainActor in // expected-error {{main actor-isolated value of type '@MainActor () async -> ()' passed as a strongly transferred parameter}}
-    print(ns) // expected-error {{transferring 'ns' may cause a race}}
-    // expected-note @-1 {{disconnected 'ns' is captured by a main actor-isolated closure. main actor-isolated uses in closure may race against later nonisolated uses}}
+    print(ns)
   }
 
-  useValue(ns) // expected-note {{use here could race}}
+  useValue(ns)
 }

test/Concurrency/transfernonsendable_instruction_matching.sil

@@ -645,12 +645,14 @@ bb0:
 
   fix_lifetime %value : $SendableKlass
 
+  // This is not considered a bad use of the raw pointer since this is
+  // transferring to the same isolation domain.
   apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %transferRawPointer(%rawPointer) : $@convention(thin) @async (Builtin.RawPointer) -> ()
   // expected-warning @-1 {{transferring value of non-Sendable type 'Builtin.RawPointer' from nonisolated context to global actor '<null>'-isolated context; later accesses could race}}
-  // expected-note @-2 {{use here could race}}
 
   fix_lifetime %rawPointer : $Builtin.RawPointer
   // expected-note @-1 {{use here could race}}
+  // expected-note @-2 {{use here could race}}  
 
   destroy_value %value : $SendableKlass
   %9999 = tuple ()
@@ -723,10 +725,10 @@ bb0:
 
   apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %transferRawPointer(%rawPointer) : $@convention(thin) @async (Builtin.RawPointer) -> ()
   // expected-warning @-1 {{transferring value of non-Sendable type 'Builtin.RawPointer' from nonisolated context to global actor '<null>'-isolated context; later accesses could race}}
-  // expected-note @-2 {{use here could race}}
 
   fix_lifetime %rawPointer : $Builtin.RawPointer
   // expected-note @-1 {{use here could race}}
+  // expected-note @-2 {{use here could race}}
 
   destroy_value %value : $SendableKlass
   %9999 = tuple ()
@@ -802,10 +804,10 @@ bb0:
 
   apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %transferRawPointer(%rawPointer) : $@convention(thin) @async (Builtin.RawPointer) -> ()
   // expected-warning @-1 {{transferring value of non-Sendable type 'Builtin.RawPointer' from nonisolated context to global actor '<null>'-isolated context; later accesses could race}}
-  // expected-note @-2 {{use here could race}}
 
   fix_lifetime %rawPointer : $Builtin.RawPointer
   // expected-note @-1 {{use here could race}}
+  // expected-note @-2 {{use here could race}}
 
   end_borrow %valueB : $SendableKlass
   destroy_value %value : $SendableKlass
@@ -1238,7 +1240,8 @@ bb0:
   unchecked_ref_cast_addr NonSendableKlass in %a : $*NonSendableKlass to NonSendableKlass in %b : $*NonSendableKlass // expected-note {{use here could race}}
 
   apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f<NonSendableKlass>(%b) : $@convention(thin) @async <τ_0_0> (@in_guaranteed τ_0_0) -> () // expected-warning {{transferring value of non-Sendable type 'NonSendableKlass' from nonisolated context to global actor '<null>'-isolated context}}
-  apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f<NonSendableKlass>(%b) : $@convention(thin) @async <τ_0_0> (@in_guaranteed τ_0_0) -> () // expected-note {{use here could race}}
+  %use = function_ref @useIndirect : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
+  apply %use<NonSendableKlass>(%b) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> () // expected-note {{use here could race}}
 
   destroy_addr %b : $*NonSendableKlass
   dealloc_stack %b : $*NonSendableKlass
@@ -1264,7 +1267,8 @@ bb0:
   unconditional_checked_cast_addr NonSendableKlass in %a : $*NonSendableKlass to NonSendableKlass in %b : $*NonSendableKlass // expected-note {{use here could race}}
 
   apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f<NonSendableKlass>(%b) : $@convention(thin) @async <τ_0_0> (@in_guaranteed τ_0_0) -> () // expected-warning {{transferring value of non-Sendable type 'NonSendableKlass' from nonisolated context to global actor '<null>'-isolated context}}
-  apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f<NonSendableKlass>(%b) : $@convention(thin) @async <τ_0_0> (@in_guaranteed τ_0_0) -> () // expected-note {{use here could race}}
+  %use = function_ref @useIndirect : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
+  apply %use<NonSendableKlass>(%b) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> () // expected-note {{use here could race}}
 
   destroy_addr %b : $*NonSendableKlass
   dealloc_stack %b : $*NonSendableKlass
@@ -1290,7 +1294,8 @@ bb0:
   destroy_value %aValue : $NonSendableKlass
 
   apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f<@sil_unowned NonSendableKlass>(%b) : $@convention(thin) @async <τ_0_0> (@in_guaranteed τ_0_0) -> () // expected-warning {{transferring value of non-Sendable type 'NonSendableKlass' from nonisolated context to global actor '<null>'-isolated context}}
-  apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f<@sil_unowned NonSendableKlass>(%b) : $@convention(thin) @async <τ_0_0> (@in_guaranteed τ_0_0) -> () // expected-note {{use here could race}}
+    %use = function_ref @useIndirect : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
+  apply %use<@sil_unowned NonSendableKlass>(%b) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> () // expected-note {{use here could race}}
 
   destroy_addr %b : $*@sil_unowned NonSendableKlass
   destroy_addr %a : $*NonSendableKlass