Fix CapturePromotion handling of mark_dependence

Author: atrick

lib/SILOptimizer/Mandatory/CapturePromotion.cpp

@@ -1210,16 +1210,16 @@ static bool findEscapeOrMutationUses(Operand *op,
   }
 
   // A mark_dependence user on a partial_apply is safe.
-  if (auto *mdi = dyn_cast<MarkDependenceInst>(user)) {
-    if (mdi->getBase() == op->get()) {
-      auto parent = mdi->getValue();
-      while ((mdi = dyn_cast<MarkDependenceInst>(parent))) {
-        parent = mdi->getValue();
+  if (auto *userMDI = dyn_cast<MarkDependenceInst>(user)) {
+    if (userMDI->getBase() == op->get()) {
+      auto parent = userMDI->getValue();
+      while (auto *parentMDI = dyn_cast<MarkDependenceInst>(parent)) {
+        parent = parentMDI->getValue();
       }
       if (isa<PartialApplyInst>(parent))
         return false;
       state.accumulatedEscapes.push_back(
-          &mdi->getOperandRef(MarkDependenceInst::Value));
+          &userMDI->getOperandRef(MarkDependenceInst::Value));
       return true;
     }
   }

test/SILOptimizer/capture_promotion_ownership.sil

@@ -1,4 +1,6 @@
-// RUN: %target-sil-opt -enable-sil-verify-all %s -capture-promotion | %FileCheck %s
+// RUN: %target-sil-opt -enable-sil-verify-all %s -capture-promotion \
+// RUN: -enable-experimental-feature NonescapableTypes -enable-experimental-feature NoncopyableGenerics -module-name Swift \
+// RUN: | %FileCheck %s
 
 // Check to make sure that the process of promoting closure captures results in
 // a correctly cloned and modified closure function body. This test
@@ -25,6 +27,10 @@ struct Baz {
   var x: Int
 }
 
+@_marker public protocol Escapable { }
+
+struct Nonescapable: ~Escapable {}
+
 sil @convert_from_integer_literal : $@convention(thin) (Builtin.Word, @thin Int.Type) -> Int
 sil @foo_allocating_init : $@convention(thin) (@thick Foo.Type) -> @owned Foo
 sil @baz_init : $@convention(thin) (@thin Baz.Type) -> @owned Baz
@@ -514,3 +520,36 @@ bb0(%0 : @owned $Builtin.NativeObject):
   %pai = partial_apply %3(%1) : $@convention(thin) (@guaranteed { var Builtin.NativeObject }) -> ()
   return %pai : $@callee_owned () -> ()
 }
+
+sil @foo_dependence : $@convention(thin) (@guaranteed Foo) -> _scope(1) @owned Nonescapable
+sil @use_nonescapable : $@convention(thin) (@guaranteed Nonescapable) -> ()
+
+// Test that the pass does not crash when it sees a mark_dependence on an alloc_box base that does not have a partial_apply value.
+sil [ossa] @test_capture_promotion_mark_dependence : $@convention(thin) () -> () {
+bb0:
+  %6 = alloc_box ${ let Foo }, let, name "c"
+  %7 = begin_borrow [lexical] [var_decl] %6 : ${ let Foo }
+  %8 = project_box %7 : ${ let Foo }, 0
+  %9 = metatype $@thick Foo.Type
+
+  %12 = function_ref @foo_allocating_init : $@convention(thin) (@thick Foo.Type) -> @owned Foo
+  %13 = apply %12(%9) : $@convention(thin) (@thick Foo.Type) -> @owned Foo
+  store %13 to [init] %8 : $*Foo
+  %16 = load_borrow %8 : $*Foo
+
+  %17 = function_ref @foo_dependence : $@convention(thin) (@guaranteed Foo) -> _scope(1) @owned Nonescapable
+  %18 = apply %17(%16) : $@convention(thin) (@guaranteed Foo) -> _scope(1) @owned Nonescapable
+
+  %19 = mark_dependence [unresolved] %18 : $Nonescapable on %6 : ${ let Foo }
+  %20 = move_value [var_decl] %19 : $Nonescapable
+  end_borrow %16 : $Foo
+
+  %23 = function_ref @use_nonescapable : $@convention(thin) (@guaranteed Nonescapable) -> ()
+  %24 = apply %23(%20) : $@convention(thin) (@guaranteed Nonescapable) -> ()
+  destroy_value %20 : $Nonescapable
+  end_borrow %7 : ${ let Foo }
+
+  destroy_value %6 : ${ let Foo }
+  %28 = tuple ()
+  return %28 : $()
+}