[Test] Unit test lexical destroy folding.

Adapt a preexisting test to be a unit test that runs the utility.

Author: nate-chandler

lib/SILOptimizer/UtilityPasses/UnitTestRunner.cpp

@@ -288,6 +288,23 @@ struct OwnershipUtilsHasPointerEscape : UnitTest {
 // MARK: OSSA Lifetime Unit Tests
 //===----------------------------------------------------------------------===//
 
+// Arguments:
+// - the lexical borrow to fold
+// Dumpts:
+// - the function
+struct LexicalDestroyFoldingTest : UnitTest {
+  LexicalDestroyFoldingTest(UnitTestRunner *pass) : UnitTest(pass) {}
+  void invoke(Arguments &arguments) override {
+    auto *dominanceAnalysis = getAnalysis<DominanceAnalysis>();
+    DominanceInfo *domTree = dominanceAnalysis->get(getFunction());
+    auto value = arguments.takeValue();
+    auto *bbi = cast<BeginBorrowInst>(value);
+    InstructionDeleter deleter;
+    foldDestroysOfCopiedLexicalBorrow(bbi, *domTree, deleter);
+    getFunction()->dump();
+  }
+};
+
 // Arguments:
 // - variadic list of - instruction: a last user
 // Dumps:

test/SILOptimizer/lexical_destroy_folding.sil

@@ -544,55 +544,6 @@ exit:
   return %retval : $()
 }
 
-// Fold apply when guaranteed lexical value used in one but not two branches
-// and the lexical scope ends before the use on the non-lexical branch.
-//
-// CHECK-LABEL: sil [ossa] @nofold_two_parallel_owned_uses_one_lexical___scope_ends_before_use : {{.*}} {
-// CHECK:         [[GET_OWNED:%[^,]+]] = function_ref @get_owned
-// CHECK:         [[INSTANCE:%[^,]+]] = apply [[GET_OWNED]]
-// CHECK:         [[LIFETIME:%[^,]+]] = begin_borrow [lexical] [[INSTANCE]]
-// CHECK:         [[CALLEE_OWNED:%[^,]+]] = function_ref @callee_owned
-// CHECK:         cond_br undef, [[LEFT:bb[0-9]+]], [[RIGHT:bb[0-9]+]]
-// CHECK:       [[LEFT]]:
-// CHECK:         [[COPY:%[^,]+]] = copy_value [[LIFETIME]]
-// CHECK:         apply [[CALLEE_OWNED]]([[COPY]])
-// CHECK:         end_borrow [[LIFETIME]]
-// CHECK:         destroy_value [[INSTANCE]]
-// CHECK:         br [[EXIT:bb[0-9]+]]
-// CHECK:       [[RIGHT]]:
-// CHECK:         end_borrow [[LIFETIME]]
-// CHECK:         apply [[CALLEE_OWNED]]([[INSTANCE]])
-// CHECK:         br [[EXIT]]
-// CHECK:       [[EXIT]]:
-// CHECK-LABEL: } // end sil function 'nofold_two_parallel_owned_uses_one_lexical___scope_ends_before_use'
-sil [ossa] @nofold_two_parallel_owned_uses_one_lexical___scope_ends_before_use : $@convention(thin) () -> () {
-entry:
-  %get_owned = function_ref @get_owned : $@convention(thin) () -> (@owned C)
-  %instance = apply %get_owned() : $@convention(thin) () -> (@owned C)
-  %copy_2 = copy_value %instance : $C
-  %lifetime = begin_borrow [lexical] %instance : $C
-  %callee_owned = function_ref @callee_owned : $@convention(thin) (@owned C) -> ()
-  cond_br undef, left, right
-
-left:
-  %copy_1 = copy_value %lifetime : $C
-  apply %callee_owned(%copy_1) : $@convention(thin) (@owned C) -> ()
-  end_borrow %lifetime : $C
-  destroy_value %instance : $C
-  destroy_value %copy_2 : $C
-  br exit
-
-right:
-  end_borrow %lifetime : $C
-  destroy_value %instance : $C
-  apply %callee_owned(%copy_2) : $@convention(thin) (@owned C) -> ()
-  br exit
-
-exit:
-  %retval = tuple ()
-  return %retval : $()
-}
-
 // Fold even if there is a noncanonicalized copy which is otherwise used.
 // CHECK-LABEL: sil [ossa] @fold_noncanonical_copy_with_other_use : {{.*}} {
 // CHECK:       {{bb[0-9]+}}:

test/SILOptimizer/lexical_destroy_folding_unit.sil

@@ -0,0 +1,52 @@
+// RUN: %target-sil-opt -unit-test-runner %s -o /dev/null 2>&1 | %FileCheck %s
+
+class C {}
+sil [ossa] @callee_owned : $@convention(thin) (@owned C) -> ()
+
+// Fold apply when guaranteed lexical value used in one but not two branches
+// and the lexical scope ends before the use on the non-lexical branch.
+//
+// CHECK-LABEL: sil [ossa] @nofold_two_parallel_owned_uses_one_lexical___scope_ends_before_use : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[INSTANCE:%[^,]+]] :
+// CHECK:         [[COPY:%[^,]+]] = copy_value [[INSTANCE]]
+// CHECK:         [[MOVE:%[^,]+]] = move_value [lexical] [[INSTANCE]]
+// CHECK:         [[CALLEE_OWNED:%[^,]+]] = function_ref @callee_owned
+// CHECK:         cond_br undef, [[LEFT:bb[0-9]+]], [[RIGHT:bb[0-9]+]]
+// CHECK:       [[LEFT]]:
+// CHECK:         apply [[CALLEE_OWNED]]([[MOVE]])
+// CHECK:         destroy_value [[COPY]]
+// CHECK:         br [[EXIT:bb[0-9]+]]
+// CHECK:       [[RIGHT]]:
+// CHECK:         destroy_value [[MOVE]]
+// CHECK:         apply [[CALLEE_OWNED]]([[COPY]])
+// CHECK:         br [[EXIT]]
+// CHECK:       [[EXIT]]:
+// CHECK-LABEL: } // end sil function 'nofold_two_parallel_owned_uses_one_lexical___scope_ends_before_use'
+sil [ossa] @nofold_two_parallel_owned_uses_one_lexical___scope_ends_before_use : $@convention(thin) (@owned C) -> () {
+entry(%instance : @owned $C):
+  test_specification "lexical-destroy-folding @trace[0]"
+  %copy_2 = copy_value %instance : $C
+  %lifetime = begin_borrow [lexical] %instance : $C
+  debug_value [trace] %lifetime : $C
+  %callee_owned = function_ref @callee_owned : $@convention(thin) (@owned C) -> ()
+  cond_br undef, left, right
+
+left:
+  %copy_1 = copy_value %lifetime : $C
+  apply %callee_owned(%copy_1) : $@convention(thin) (@owned C) -> ()
+  end_borrow %lifetime : $C
+  destroy_value %instance : $C
+  destroy_value %copy_2 : $C
+  br exit
+
+right:
+  end_borrow %lifetime : $C
+  destroy_value %instance : $C
+  apply %callee_owned(%copy_2) : $@convention(thin) (@owned C) -> ()
+  br exit
+
+exit:
+  %retval = tuple ()
+  return %retval : $()
+}
+