[CanonicalizeBorrowScope] Look through moves.

When encountering inside a borrow scope a non-lexical move_value or a
move_value [lexical] where the borrowed value is itself already lexical,
delete the move_value and regard its uses as uses of the moved-from
value.

Author: nate-chandler

lib/SILOptimizer/UtilityPasses/UnitTestRunner.cpp

@@ -393,6 +393,23 @@ struct CanonicalizeOSSALifetimeTest : UnitTest {
   }
 };
 
+// Arguments:
+// - SILValue: value to canonicalize
+// Dumps:
+// - function after value canonicalization
+struct CanonicalizeBorrowScopeTest : UnitTest {
+  CanonicalizeBorrowScopeTest(UnitTestRunner *pass) : UnitTest(pass) {}
+  void invoke(Arguments &arguments) override {
+    auto value = arguments.takeValue();
+    auto borrowedValue = BorrowedValue(value);
+    assert(borrowedValue && "specified value isn't a BorrowedValue!?");
+    InstructionDeleter deleter;
+    CanonicalizeBorrowScope canonicalizer(deleter);
+    canonicalizer.canonicalizeBorrowScope(borrowedValue);
+    getFunction()->dump();
+  }
+};
+
 // Arguments:
 // - instruction
 // Dumps:
@@ -616,6 +633,8 @@ void UnitTestRunner::withTest(StringRef name, Doit doit) {
 
     // Alphabetical mapping from string to unit test subclass.
     ADD_UNIT_TEST_SUBCLASS("canonicalize-ossa-lifetime", CanonicalizeOSSALifetimeTest)
+    ADD_UNIT_TEST_SUBCLASS("canonicalize-borrow-scope",
+                           CanonicalizeBorrowScopeTest)
     ADD_UNIT_TEST_SUBCLASS("dump-function", DumpFunction)
     ADD_UNIT_TEST_SUBCLASS("find-borrow-introducers", FindBorrowIntroducers)
     ADD_UNIT_TEST_SUBCLASS("find-enclosing-defs", FindEnclosingDefsTest)

lib/SILOptimizer/Utils/CanonicalizeBorrowScope.cpp

@@ -224,21 +224,32 @@ bool CanonicalizeBorrowScope::visitBorrowScopeUses(SILValue innerValue,
     // Gather the uses before updating any of them.
     // 'value' may be deleted in this loop after rewriting its last use.
     // 'use' may become invalid after processing its user.
+
     SmallVector<Operand *, 4> uses(value->getUses());
-    for (Operand *use : uses) {
+    for (auto index = 0; index < uses.size(); ++index) {
+      auto *use = uses[index];
       auto *user = use->getUser();
       // Incidental uses, such as debug_value may be deleted before they can be
       // processed. Their user will now be nullptr. This means that value
       // is dead, so just bail.
       if (!user)
         break;
 
-      // Recurse through copies.
+      // Recurse through copies and moves.
       if (auto *copy = dyn_cast<CopyValueInst>(user)) {
         if (!isPersistentCopy(copy)) {
           defUseWorklist.insert(copy);
           continue;
         }
+      } else if (auto *move = dyn_cast<MoveValueInst>(user)) {
+        if (!move->isLexical() || innerValue->isLexical()) {
+          for (auto *moveUse : move->getUses()) {
+            uses.push_back(moveUse);
+          }
+          move->replaceAllUsesWith(move->getOperand());
+          deleter.forceDelete(move);
+          continue;
+        }
       }
       // Note: debug_value uses are handled like normal uses here. If they are
       // inner uses, they remain. If they are outer uses, then they will be

test/SILOptimizer/canonicalize_borrow_scope_unit.sil

@@ -0,0 +1,59 @@
+// RUN: %target-sil-opt -unit-test-runner %s -o /dev/null 2>&1 | %FileCheck %s
+
+import Builtin
+
+typealias AnyObject = Builtin.AnyObject
+
+struct Unmanaged<Instance> where Instance : AnyObject {
+  unowned(unsafe) var _value: @sil_unmanaged Instance
+}
+
+// CHECK-LABEL: begin {{.*}} on copy_and_move_argument: canonicalize-borrow-scope
+// CHECK-LABEL: sil [ossa] @copy_and_move_argument : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[INSTANCE:%[^,]+]] :
+// CHECK:         [[UNMANAGED:%[^,]+]] = ref_to_unmanaged [[INSTANCE]]
+// CHECK:         [[RETVAL:%[^,]+]] = struct $Unmanaged<Instance> ([[UNMANAGED]] : $@sil_unmanaged Instance) 
+// CHECK:         return [[RETVAL]]
+// CHECK-LABEL: } // end sil function 'copy_and_move_argument'
+// CHECK-LABEL: end {{.*}} on copy_and_move_argument: canonicalize-borrow-scope
+sil [ossa] @copy_and_move_argument : $@convention(thin) <Instance where Instance : AnyObject> (@guaranteed Instance) -> Unmanaged<Instance> {
+bb0(%instance : @guaranteed $Instance):
+  test_specification "canonicalize-borrow-scope @argument"
+  %copy_1 = copy_value %instance : $Instance
+  %copy_2 = copy_value %copy_1 : $Instance
+  %move = move_value %copy_2 : $Instance
+  %copy_3 = copy_value %move : $Instance
+  %copy_4 = copy_value %copy_3 : $Instance
+  %unmanaged = ref_to_unmanaged %copy_4 : $Instance to $@sil_unmanaged Instance
+  destroy_value %copy_4 : $Instance
+  destroy_value %copy_3 : $Instance
+  destroy_value %move : $Instance
+  destroy_value %copy_1 : $Instance
+  %retval = struct $Unmanaged<Instance> (%unmanaged : $@sil_unmanaged Instance)
+  return %retval : $Unmanaged<Instance>
+}
+
+// CHECK-LABEL: begin {{.*}} on copy_and_move_lexical_argument: canonicalize-borrow-scope
+// CHECK-LABEL: sil [ossa] @copy_and_move_lexical_argument : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[INSTANCE:%[^,]+]] :
+// CHECK:         [[UNMANAGED:%[^,]+]] = ref_to_unmanaged [[INSTANCE]]
+// CHECK:         [[RETVAL:%[^,]+]] = struct $Unmanaged<Instance> ([[UNMANAGED]] : $@sil_unmanaged Instance) 
+// CHECK:         return [[RETVAL]]
+// CHECK-LABEL: } // end sil function 'copy_and_move_lexical_argument'
+// CHECK-LABEL: end {{.*}} on copy_and_move_lexical_argument: canonicalize-borrow-scope
+sil [ossa] @copy_and_move_lexical_argument : $@convention(thin) <Instance where Instance : AnyObject> (@guaranteed Instance) -> Unmanaged<Instance> {
+bb0(%instance : @guaranteed $Instance):
+  test_specification "canonicalize-borrow-scope @argument"
+  %copy_1 = copy_value %instance : $Instance
+  %copy_2 = copy_value %copy_1 : $Instance
+  %move = move_value [lexical] %copy_2 : $Instance
+  %copy_3 = copy_value %move : $Instance
+  %copy_4 = copy_value %copy_3 : $Instance
+  %unmanaged = ref_to_unmanaged %copy_4 : $Instance to $@sil_unmanaged Instance
+  destroy_value %copy_4 : $Instance
+  destroy_value %copy_3 : $Instance
+  destroy_value %move : $Instance
+  destroy_value %copy_1 : $Instance
+  %retval = struct $Unmanaged<Instance> (%unmanaged : $@sil_unmanaged Instance)
+  return %retval : $Unmanaged<Instance>
+}