[move-only] Fix a place in DI where we were not converting an assignable_but_not_consumable -> initable_but_not_consumable.

I fixed this for assign but missed a place where we needed to do the same thing for copy_addr.

rdar://111709236

Author: gottesmm

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -2381,6 +2381,21 @@ void LifetimeChecker::updateInstructionForInitState(unsigned UseID) {
     CA->setIsInitializationOfDest(InitKind);
     if (InitKind == IsInitialization)
       setStaticInitAccess(CA->getDest());
+
+    // If we had an initialization and had an assignable_but_not_consumable
+    // noncopyable type, convert it to be an initable_but_not_consumable so that
+    // we do not consume an uninitialized value.
+    if (InitKind == IsInitialization) {
+      if (auto *mmci =
+          dyn_cast<MarkMustCheckInst>(stripAccessMarkers(CA->getDest()))) {
+        if (mmci->getCheckKind() ==
+            MarkMustCheckInst::CheckKind::AssignableButNotConsumable) {
+          mmci->setCheckKind(
+              MarkMustCheckInst::CheckKind::InitableButNotConsumable);
+        }
+      }
+    }
+
     return;
   }
 

test/SILOptimizer/moveonly_addresschecker_di_interactions.sil

@@ -0,0 +1,59 @@
+// RUN: %target-sil-opt -definite-init %s | %FileCheck %s
+
+// Make sure that DI properly converts mark_must_check
+// [assignable_but_not_consumable] -> mark_must_check
+// [initable_but_not_consumable].
+
+sil_stage raw
+
+fileprivate final class _Box<T> {
+  var value: _Node<T>
+
+  init(_ value: consuming _Node<T>)
+}
+
+struct _Node<T> : ~Copyable {
+  var value: T
+  var _next: ListEntry<T>
+
+  init(_ newValue: T)
+}
+
+struct ListEntry<T> : ~Copyable {
+  private var innerBox: _Box<T>
+}
+
+// CHECK-LABEL: sil private [ossa] @boxInit : $@convention(method) <T> (@in _Node<T>, @owned _Box<T>) -> @owned _Box<T> {
+// CHECK: bb0([[INPUT:%.*]] : $*_Node<T>, [[SELF:%.*]] : @owned
+// CHECK:   [[BORROW_SELF:%.*]] = begin_borrow [[SELF]]
+// CHECK:   [[REF:%.*]] = ref_element_addr [[BORROW_SELF]]
+// CHECK:   [[ACCESS:%.*]] = begin_access [modify] [dynamic] [[REF]]
+// CHECK:   [[MARK:%.*]] = mark_must_check [initable_but_not_consumable] [[ACCESS]]
+// CHECK:   copy_addr [take] {{%.*}} to [init] [[MARK]]
+// CHECK:   end_access [[ACCESS]]
+// CHECK: } // end sil function 'boxInit'
+sil private [ossa] @boxInit : $@convention(method) <T> (@in _Node<T>, @owned _Box<T>) -> @owned _Box<T> {
+bb0(%0 : $*_Node<T>, %1 : @owned $_Box<T>):
+  %2 = alloc_stack [lexical] $_Node<T>, var, name "value"
+  %3 = mark_must_check [consumable_and_assignable] %2 : $*_Node<T>
+  copy_addr [take] %0 to [init] %3 : $*_Node<T>
+  debug_value %1 : $_Box<T>, let, name "self", argno 2, implicit
+  %6 = mark_uninitialized [rootself] %1 : $_Box<T>
+  %7 = begin_borrow %6 : $_Box<T>
+  %8 = begin_access [read] [static] %3 : $*_Node<T>
+  %9 = alloc_stack $_Node<T>
+  copy_addr %8 to [init] %9 : $*_Node<T>
+  end_access %8 : $*_Node<T>
+  %12 = ref_element_addr %7 : $_Box<T>, #_Box.value
+  %13 = begin_access [modify] [dynamic] %12 : $*_Node<T>
+  %14 = mark_must_check [assignable_but_not_consumable] %13 : $*_Node<T>
+  copy_addr [take] %9 to %14 : $*_Node<T>
+  end_access %13 : $*_Node<T>
+  dealloc_stack %9 : $*_Node<T>
+  end_borrow %7 : $_Box<T>
+  %19 = copy_value %6 : $_Box<T>
+  destroy_value %6 : $_Box<T>
+  destroy_addr %3 : $*_Node<T>
+  dealloc_stack %2 : $*_Node<T>
+  return %19 : $_Box<T>
+}

test/SILOptimizer/moveonly_addresschecker_di_interactions.swift

@@ -86,3 +86,32 @@ func testEnumNoInitWithGenericPayload() {
         } // expected-error {{'self.init' isn't called on all paths before returning from initializer}}
     }
 }
+
+// This test doesn't actually test anything today... but once the memory
+// lifetime verifier runs on ref_element_addr, this would assert in _Box<T>.init
+// since we were not setting the mark_must_check to initable_but_not_assignable.
+fileprivate final class _Box<T> {
+  var value: _Node<T>
+
+  init(_ value: consuming _Node<T>) { self.value = value }
+}
+
+struct _Node<T> : ~Copyable {
+  var value: T
+  var _next: ListEntry<T> = ListEntry<T>()
+
+  init(_ newValue: T) {
+    value = newValue
+  }
+}
+
+/// A noncopyable box that contains the memory for a linked list node. Can be
+/// embedded within other noncopyable data structures to point at a Node data
+/// structure.
+///
+/// Internally uses a class as the actual box.
+struct ListEntry<T> : ~Copyable {
+  private var innerBox: _Box<T>?
+
+  init() { innerBox = nil }
+}