[region-isolation] Do not allow for a disconnected value passed as an explicitly sent parameter to be reused.

This only occurs specifically for async nonisolated functions with an isolated
parameter that passes a disconnected value in its body off to a nonisolated
async function as a sending parameter.

rdar://134409359

Author: gottesmm

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -1226,9 +1226,12 @@ struct PartitionOpEvaluator {
       }
 
       // Next see if we are disconnected and have the same isolation. In such a
-      // case, we do not transfer since the disconnected value is allowed to be
-      // resued after we return.
-      if (transferredRegionIsolation.isDisconnected() && calleeIsolationInfo &&
+      // case, if we are not marked explicitly as sending, we do not transfer
+      // since the disconnected value is allowed to be resued after we
+      // return. If we are passed as a sending parameter, we cannot do this.
+      if (auto fas = FullApplySite::isa(op.getSourceInst());
+          (!fas || !fas.isSending(*op.getSourceOp())) &&
+          transferredRegionIsolation.isDisconnected() && calleeIsolationInfo &&
           transferredRegionIsolation.hasSameIsolation(calleeIsolationInfo))
         return;
 

test/Concurrency/transfernonsendable_sending_params.swift

@@ -7,7 +7,9 @@
 // MARK: Declarations //
 ////////////////////////
 
-class NonSendableKlass {}
+class NonSendableKlass {
+  func use() {}
+}
 
 struct NonSendableStruct {
   var first = NonSendableKlass()
@@ -55,6 +57,9 @@ func throwingFunction() throws { fatalError() }
 func transferArg(_ x: sending NonSendableKlass) {
 }
 
+func transferArgAsync(_ x: sending NonSendableKlass) async {
+}
+
 func transferArgWithOtherParam(_ x: sending NonSendableKlass, _ y: NonSendableKlass) {
 }
 
@@ -559,3 +564,56 @@ extension MyActor {
     }
   }
 }
+
+// We would normally not error here since transferArg is nonisolated and c is
+// disconnected. Since c is passed as sending, we shouldn't squelch this.
+func disconnectedPassedSendingToNonIsolatedCallee(
+) async -> Void {
+    let c = NonSendableKlass()
+    transferArg(c) // expected-warning {{sending 'c' risks causing data races}}
+    // expected-note @-1 {{'c' used after being passed as a 'sending' parameter}}
+    c.use() // expected-note {{access can happen concurrently}}
+}
+
+// We would normally not error here since transferArg is nonisolated and c is
+// disconnected. Since c is passed as sending, we shouldn't squelch this.
+func disconnectedPassedSendingToAsyncNonIsolatedCallee(
+) async -> Void {
+    let c = NonSendableKlass()
+    await transferArgAsync(c) // expected-warning {{sending 'c' risks causing data races}}
+    // expected-note @-1 {{'c' used after being passed as a 'sending' parameter}}
+    c.use()  // expected-note {{access can happen concurrently}}
+}
+
+// We would normally not error here since transferArg is nonisolated and c is
+// disconnected. Since c is passed as sending, we shouldn't squelch this.
+func disconnectedPassedSendingToNonIsolatedCalleeIsolatedParam2(
+    isolation: isolated (any Actor)? = nil
+) async -> Void {
+    let c = NonSendableKlass()
+    transferArg(c) // expected-warning {{sending 'c' risks causing data races}}
+    // expected-note @-1 {{'c' used after being passed as a 'sending' parameter}}
+    c.use() // expected-note {{access can happen concurrently}}
+}
+
+// We would normally not error here since transferArg is nonisolated and c is
+// disconnected. Since c is passed as sending, we shouldn't squelch this.
+func disconnectedPassedSendingToAsyncNonIsolatedCalleeIsolatedParam2(
+  isolation: isolated (any Actor)? = nil
+) async -> Void {
+    let c = NonSendableKlass()
+    await transferArgAsync(c) // expected-warning {{sending 'c' risks causing data races}}
+    // expected-note @-1 {{'c' used after being passed as a 'sending' parameter}}
+    c.use() // expected-note {{access can happen concurrently}}
+}
+
+// We would normally not error here since transferArg is nonisolated and c is
+// disconnected. Since c is passed as sending, we shouldn't squelch this.
+func disconnectedPassedSendingToNonIsolatedCalleeIsolatedParam3(
+    isolation: isolated (any Actor)? = nil
+) -> Void {
+    let c = NonSendableKlass()
+    transferArg(c) // expected-warning {{sending 'c' risks causing data races}}
+    // expected-note @-1 {{'c' used after being passed as a 'sending' parameter}}
+    c.use() // expected-note {{access can happen concurrently}}
+}