[region-isolation] Teach variable_name_inference how to infer through store_borrow initialized variables.

This eliminates a bunch of cases where we couldn't infer the name of a variable
and used the type based diagnostic.

It also eliminates an 'unknown' case for move checking.

Author: gottesmm

lib/SILOptimizer/Utils/VariableNameUtils.cpp

@@ -51,6 +51,11 @@ findRootValueForNonTupleTempAllocation(AllocationInst *allocInst,
       }
     }
 
+    if (auto *sbi = dyn_cast<StoreBorrowInst>(&inst)) {
+      if (sbi->getDest() == allocInst)
+        return sbi->getSrc();
+    }
+
     // If we do not identify the write... return SILValue(). We weren't able
     // to understand the write.
     break;
@@ -183,7 +188,7 @@ static SILValue findRootValueForTupleTempAllocation(AllocationInst *allocInst,
 
 SILValue VariableNameInferrer::getRootValueForTemporaryAllocation(
     AllocationInst *allocInst) {
-  struct AddressWalker : public TransitiveAddressWalker<AddressWalker> {
+  struct AddressWalker final : public TransitiveAddressWalker<AddressWalker> {
     AddressWalkerState &state;
 
     AddressWalker(AddressWalkerState &state) : state(state) {}
@@ -194,6 +199,12 @@ SILValue VariableNameInferrer::getRootValueForTemporaryAllocation(
       return true;
     }
 
+    TransitiveUseVisitation visitTransitiveUseAsEndPointUse(Operand *use) {
+      if (auto *sbi = dyn_cast<StoreBorrowInst>(use->getUser()))
+        return TransitiveUseVisitation::OnlyUser;
+      return TransitiveUseVisitation::OnlyUses;
+    }
+
     void onError(Operand *use) { state.foundError = true; }
   };
 
@@ -288,6 +299,13 @@ SILValue VariableNameInferrer::findDebugInfoProvidingValueHelper(
       return allocInst;
     }
 
+    // If we have a store_borrow, always look at the dest. We are going to see
+    // if we can determine if dest is a temporary alloc_stack.
+    if (auto *sbi = dyn_cast<StoreBorrowInst>(searchValue)) {
+      searchValue = sbi->getDest();
+      continue;
+    }
+
     if (auto *globalAddrInst = dyn_cast<GlobalAddrInst>(searchValue)) {
       variableNamePath.push_back(globalAddrInst);
       return globalAddrInst;
@@ -487,7 +505,9 @@ SILValue VariableNameInferrer::findDebugInfoProvidingValueHelper(
         isa<ConvertFunctionInst>(searchValue) ||
         isa<MarkUninitializedInst>(searchValue) ||
         isa<CopyableToMoveOnlyWrapperAddrInst>(searchValue) ||
-        isa<MoveOnlyWrapperToCopyableAddrInst>(searchValue)) {
+        isa<MoveOnlyWrapperToCopyableAddrInst>(searchValue) ||
+        isa<MoveOnlyWrapperToCopyableValueInst>(searchValue) ||
+        isa<CopyableToMoveOnlyWrapperValueInst>(searchValue)) {
       searchValue = cast<SingleValueInstruction>(searchValue)->getOperand(0);
       continue;
     }

test/Concurrency/transfernonsendable.swift

@@ -290,12 +290,13 @@ func asyncLet_Let_ActorIsolated_CallBuriedInOtherExpr3() async {
 func asyncLet_Let_ActorIsolated_CallBuriedInOtherExpr4() async {
   let x = NonSendableKlass()
 
-  async let y = useValue(transferToMainInt(x) + transferToMainInt(x)) // expected-tns-warning {{transferring value of non-Sendable type 'NonSendableKlass' from nonisolated context to main actor-isolated context; later accesses could race}}
-  // expected-tns-note @-1:67 {{access here could race}}
+  async let y = useValue(transferToMainInt(x) + transferToMainInt(x)) // expected-tns-warning {{transferring 'x' may cause a race}}
+  // expected-tns-note @-1 {{'x' is transferred from nonisolated caller to main actor-isolated callee. Later uses in caller could race with potential uses in callee}}
+  // expected-tns-note @-2:67 {{access here could race}}
 
-  // expected-complete-warning @-3 {{capture of 'x' with non-sendable type 'NonSendableKlass' in 'async let' binding}}
-  // expected-complete-warning @-4 {{passing argument of non-sendable type 'NonSendableKlass' into main actor-isolated context may introduce data races}}
+  // expected-complete-warning @-4 {{capture of 'x' with non-sendable type 'NonSendableKlass' in 'async let' binding}}
   // expected-complete-warning @-5 {{passing argument of non-sendable type 'NonSendableKlass' into main actor-isolated context may introduce data races}}
+  // expected-complete-warning @-6 {{passing argument of non-sendable type 'NonSendableKlass' into main actor-isolated context may introduce data races}}
 
   let _ = await y
 }
@@ -745,7 +746,8 @@ func asyncLetWithoutCapture() async {
   async let x: NonSendableKlass = await returnValueFromMain()
   // expected-warning @-1 {{non-sendable type 'NonSendableKlass' returned by implicitly asynchronous call to main actor-isolated function cannot cross actor boundary}}
   let y = await x
-  await transferToMain(y) // expected-tns-warning {{transferring value of non-Sendable type 'NonSendableKlass' from nonisolated context to main actor-isolated context}}
-  // expected-complete-warning @-1 {{passing argument of non-sendable type 'NonSendableKlass' into main actor-isolated context may introduce data races}}
+  await transferToMain(y) // expected-tns-warning {{transferring 'y' may cause a race}}
+  // expected-tns-note @-1 {{'y' is transferred from nonisolated caller to main actor-isolated callee. Later uses in caller could race with potential uses in callee}}
+  // expected-complete-warning @-2 {{passing argument of non-sendable type 'NonSendableKlass' into main actor-isolated context may introduce data races}}
   useValue(y) // expected-tns-note {{access here could race}}
 }

test/Concurrency/transfernonsendable_asynclet.swift

@@ -48,14 +48,15 @@ private class NonSendableLinkedListNode<T> { // expected-complete-note 3{{}}
 @GlobalActor func useGlobalActor1() async {
   let x = firstList
 
-  // TODO: This should say global actor isolated isolated.
-  await transferToMainActor(x) // expected-tns-warning {{global actor 'GlobalActor'-isolated value of type 'NonSendableLinkedList<Int>' transferred to main actor-isolated context}}
-  // expected-complete-warning @-1 {{passing argument of non-sendable type 'NonSendableLinkedList<Int>' into main actor-isolated context may introduce data races}}
+  await transferToMainActor(x) // expected-tns-warning {{transferring 'x' may cause a race}}
+  // expected-tns-note @-1 {{transferring global actor 'GlobalActor'-isolated 'x' to main actor-isolated callee could cause races between main actor-isolated and global actor 'GlobalActor'-isolated uses}}
+  // expected-complete-warning @-2 {{passing argument of non-sendable type 'NonSendableLinkedList<Int>' into main actor-isolated context may introduce data races}}
 
   let y = secondList.listHead!.next!
 
-  await transferToMainActor(y) // expected-tns-warning {{global actor 'GlobalActor'-isolated value of type 'NonSendableLinkedListNode<Int>' transferred to main actor-isolated context}}
-  // expected-complete-warning @-1 {{passing argument of non-sendable type 'NonSendableLinkedListNode<Int>' into main actor-isolated context may introduce data races}}
+  await transferToMainActor(y) // expected-tns-warning {{transferring 'y' may cause a race}}
+  // expected-tns-note @-1 {{transferring global actor 'GlobalActor'-isolated 'y' to main actor-isolated callee could cause races between main actor-isolated and global actor 'GlobalActor'-isolated uses}}
+  // expected-complete-warning @-2 {{passing argument of non-sendable type 'NonSendableLinkedListNode<Int>' into main actor-isolated context may introduce data races}}
 }
 
 @GlobalActor func useGlobalActor2() async {
@@ -91,8 +92,9 @@ private class NonSendableLinkedListNode<T> { // expected-complete-note 3{{}}
 @GlobalActor func useGlobalActor5() async {
   let x = NonSendableLinkedListNode<Int>()
 
-  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}}
+  await transferToNonIsolated(x) // expected-tns-warning {{transferring 'x' may cause a race}}
+  // expected-tns-note @-1 {{'x' is transferred from global actor 'GlobalActor'-isolated caller to nonisolated callee. Later uses in caller could race with potential uses in callee}}
+  // expected-complete-warning @-2 {{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}}
 }

test/Concurrency/transfernonsendable_global_actor.swift

@@ -93,7 +93,8 @@ func normalFunc_testLocal_2() {
 // diagnostic.
 func transferBeforeCaptureErrors() async {
   let x = NonSendableKlass()
-  await transferToCustom(x) // expected-warning {{transferring value of non-Sendable type 'NonSendableKlass' from nonisolated context to global actor 'CustomActor'-isolated context}}
+  await transferToCustom(x) // expected-warning {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{'x' is transferred from nonisolated caller to global actor 'CustomActor'-isolated callee. Later uses in caller could race with potential uses in callee}}
   let _ = { @MainActor in // expected-note {{access here could race}}
     useValue(x)
   }

test/Concurrency/transfernonsendable_isolationcrossing_partialapply.swift

@@ -67,23 +67,25 @@ func testConsumingUseAfterConsumeError(_ x: consuming Klass) async { // expected
 }
 
 func testBorrowing(_ x: borrowing Klass) async {
-  await transferToMain(x) // expected-warning {{task-isolated value of type 'Klass' transferred to main actor-isolated context}}
+  await transferToMain(x) // expected-warning {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{transferring task-isolated 'x' to main actor-isolated callee could cause races between main actor-isolated and task-isolated uses}}
 }
 
 func testBorrowingError(_ x: borrowing Klass) async { // expected-error {{'x' is borrowed and cannot be consumed}}
-  await transferToMain(x) // expected-warning {{task-isolated value of type 'Klass' transferred to main actor-isolated context}}
+  await transferToMain(x) // expected-warning {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{transferring task-isolated 'x' to main actor-isolated callee could cause races between main actor-isolated and task-isolated uses}}
   print(x) // expected-note {{consumed here}}
 }
 
 @CustomActor func testBorrowingErrorGlobalActor(_ x: borrowing Klass) async { // expected-error {{'x' is borrowed and cannot be consumed}}
-  await transferToMain(x) // expected-warning {{global actor 'CustomActor'-isolated value of type 'Klass' transferred to main actor-isolated context}}
+  await transferToMain(x) // expected-warning {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{transferring global actor 'CustomActor'-isolated 'x' to main actor-isolated callee could cause races between main actor-isolated and global actor 'CustomActor'-isolated uses}}
   print(x) // expected-note {{consumed here}}
 }
 
 func testInOut(_ x: inout Klass) async {
   await transferToMain(x) // expected-warning {{transferring 'x' may cause a race}}
-  // TODO: This is wrong. Should say task isolated!
-  // expected-note @-2 {{transferring task-isolated 'x' to main actor-isolated callee could cause races between main actor-isolated and task-isolated uses}}
+  // expected-note @-1 {{transferring task-isolated 'x' to main actor-isolated callee could cause races between main actor-isolated and task-isolated uses}}
 }
 
 func testInOutError(_ x: inout Klass) async {

test/Concurrency/transfernonsendable_ownership.swift

@@ -107,7 +107,8 @@ func testNonStrongTransferDoesntMerge() async {
 
 func testTransferringParameter_canTransfer(_ x: transferring Klass, _ y: Klass) async {
   await transferToMain(x)
-  await transferToMain(y) // expected-warning {{task-isolated value of type 'Klass' transferred to main actor-isolated context; later accesses to value could race}}
+  await transferToMain(y) // expected-warning {{transferring 'y' may cause a race}}
+  // expected-note @-1 {{transferring task-isolated 'y' to main actor-isolated callee could cause races between main actor-isolated and task-isolated uses}}
 }
 
 func testTransferringParameter_cannotTransferTwice(_ x: transferring Klass, _ y: Klass) async {
@@ -127,7 +128,8 @@ actor MyActor {
 
   func canTransferWithTransferringMethodArg(_ x: transferring Klass, _ y: Klass) async {
     await transferToMain(x)
-    await transferToMain(y) // expected-warning {{actor-isolated value of type 'Klass' transferred to main actor-isolated context; later accesses to value could race}}
+    await transferToMain(y) // expected-warning {{transferring 'y' may cause a race}}
+    // expected-note @-1 {{transferring actor-isolated 'y' to main actor-isolated callee could cause races between main actor-isolated and actor-isolated uses}}
   }
 
   func getNormalErrorIfTransferTwice(_ x: transferring Klass) async {
@@ -206,7 +208,8 @@ func assigningIsAMergeError(_ x: transferring Klass) async {
   x = y
 
   // We can still transfer y since x is disconnected.
-  await transferToMain(y) // expected-warning {{transferring value of non-Sendable type 'Klass' from nonisolated context to main actor-isolated context}}
+  await transferToMain(y) // expected-warning {{transferring 'y' may cause a race}}
+  // expected-note @-1 {{'y' is transferred from nonisolated caller to main actor-isolated callee}}
 
   useValue(x) // expected-note {{access here could race}}
 }
@@ -312,7 +315,8 @@ func doubleArgument() async {
 
 func testTransferSrc(_ x: transferring Klass) async {
   let y = Klass()
-  await transferToMain(y) // expected-warning {{transferring value of non-Sendable type 'Klass' from nonisolated context to main actor-isolated context}}
+  await transferToMain(y) // expected-warning {{transferring 'y' may cause a race}}
+  // expected-note @-1 {{'y' is transferred from nonisolated caller to main actor-isolated callee. Later uses in caller could race with potential uses in callee}}
   x = y // expected-note {{access here could race}}
 }
 

test/Concurrency/transfernonsendable_strong_transferring_params.swift

@@ -20,12 +20,14 @@ func transferValue<T>(_ t: transferring T) {}
 
 func testIsolationError() async {
   let x = NonSendableType()
-  await transferToMain(x) // expected-error {{transferring value of non-Sendable type 'NonSendableType' from nonisolated context to main actor-isolated context; later accesses could race}}
+  await transferToMain(x) // expected-error {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{'x' is transferred from nonisolated caller to main actor-isolated callee. Later uses in caller could race with potential uses in callee}}
   useValue(x) // expected-note {{access here could race}}
 }
 
 func testTransferArgumentError(_ x: NonSendableType) async {
-  await transferToMain(x) // expected-error {{task-isolated value of type 'NonSendableType' transferred to main actor-isolated context; later accesses to value could race}}
+  await transferToMain(x) // expected-error {{transferring 'x' may cause a race}}
+  // expected-note @-1 {{transferring task-isolated 'x' to main actor-isolated callee could cause races between main actor-isolated and task-isolated uses}}
 }
 
 func testPassArgumentAsTransferringParameter(_ x: NonSendableType) async {

test/Concurrency/transfernonsendable_warning_until_swift6.swift

@@ -103,7 +103,7 @@ public func callerConsumeClassLetFieldForArgumentSpillingTestInOutArg(_ x: inout
 
 // TODO: more specific error message path than "unknown"
 public func callerConsumeClassLetFieldForArgumentSpillingTestConsumingArg(_ x: consuming CopyableKlass) {
-    consumeVal(x.letS.e) // expected-error{{cannot partially consume 'unknown'}}
+  consumeVal(x.letS.e) // expected-error{{cannot partially consume 'x.letS'}}
 }
 
 public func callerConsumeClassLetFieldForArgumentSpillingTestLetGlobal() {
@@ -170,7 +170,7 @@ public func callerConsumeClassVarFieldForArgumentSpillingTestInOutArg(_ x: inout
 
 // TODO: more precise error path reporting than 'unknown'
 public func callerConsumeClassVarFieldForArgumentSpillingTestConsumingArg(_ x: consuming CopyableKlass) {
-    consumeVal(x.varS.e) // expected-error{{cannot partially consume 'unknown'}}
+  consumeVal(x.varS.e) // expected-error{{cannot partially consume 'x.varS'}}
 }
 
 public func callerConsumeClassVarFieldForArgumentSpillingTestLetGlobal() {

test/SILOptimizer/moveonly_addresschecker_diagnostics_library_evolution.swift

@@ -597,3 +597,30 @@ bb8:
   debug_value [trace] %4 : $FirstSecondThirdEnum<Klass>
   return %4 : $FirstSecondThirdEnum<Klass>
 }
+
+// Test that we can properly handle code generation from a borrowing loadable parameter
+//
+// CHECK-LABEL: begin running test 1 of 1 on loadable_borrowing_test: variable-name-inference with: @trace[0]
+// CHECK: Input Value:   %8 = store_borrow %6 to %7 : $*Klass            // user: %9
+// CHECK: Name: 'x'
+// CHECK: Root: %3 = mark_unresolved_non_copyable_value [no_consume_or_assign] %2
+// CHECK: end running test 1 of 1 on loadable_borrowing_test: variable-name-inference with: @trace[0]
+sil hidden [ossa] @loadable_borrowing_test : $@convention(thin) @async (@guaranteed Klass) -> () {
+bb0(%0 : @noImplicitCopy @guaranteed $Klass):
+  specify_test "variable-name-inference @trace[0]"
+  %1 = copyable_to_moveonlywrapper [guaranteed] %0 : $Klass
+  %2 = copy_value %1 : $@moveOnly Klass
+  %3 = mark_unresolved_non_copyable_value [no_consume_or_assign] %2 : $@moveOnly Klass
+  debug_value %3 : $@moveOnly Klass, let, name "x", argno 1
+  %7 = begin_borrow %3 : $@moveOnly Klass
+  %8 = moveonlywrapper_to_copyable [guaranteed] %7 : $@moveOnly Klass
+  %9 = alloc_stack $Klass
+  %10 = store_borrow %8 to %9 : $*Klass
+  debug_value [trace] %10 : $*Klass  
+  end_borrow %10 : $*Klass
+  dealloc_stack %9 : $*Klass
+  end_borrow %7 : $@moveOnly Klass
+  destroy_value %3 : $@moveOnly Klass
+  %25 = tuple ()
+  return %25 : $()
+}