[move-only] Ensure that if we have an allocation that isn't fully initialized (and DI errors on it as such), the move checkers do not run on the allocation.

Previously we would crash.

Since we are relatively late in 5.9, my solution is to just turn off the move
checker on functions whenever DI would emit an error. If we were earlier in the
development cycle, then I would make the error be a per allocation change.

rdar://108993297

Author: gottesmm

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -11,13 +11,15 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "definite-init"
+
 #include "DIMemoryUseCollector.h"
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/Stmt.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/SIL/BasicBlockBits.h"
+#include "swift/AST/SemanticAttrs.h"
 #include "swift/SIL/BasicBlockData.h"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/MemAccessUtils.h"
@@ -1140,7 +1142,15 @@ void LifetimeChecker::doIt() {
   }
 
   // If we emitted an error, there is no reason to proceed with load promotion.
-  if (!EmittedErrorLocs.empty()) return;
+  if (!EmittedErrorLocs.empty()) {
+    // Since we failed DI, for now, turn off the move checker on the entire
+    // function. With time, we should be able to allow for move checker checks
+    // to be emitted on unrelated allocations, but given where we are this is a
+    // good enough fix.
+    TheMemory.getFunction().addSemanticsAttr(
+        semantics::NO_MOVEONLY_DIAGNOSTICS);
+    return;
+  }
 
   // If the memory object has nontrivial type, then any destroy/release of the
   // memory object will destruct the memory.  If the memory (or some element

test/SILOptimizer/moveonly_addresschecker_di_interactions.swift

@@ -0,0 +1,88 @@
+// RUN: %target-swift-emit-sil -sil-verify-all -verify -enable-experimental-feature NoImplicitCopy %s
+
+// This testStruct specifically testStructs how DI and the move checkers interact with each other
+
+func testStructSimpleNoInit() {
+    struct M: ~Copyable {
+        private let i: Int // expected-note {{'self.i' not initialized}}
+
+        // No initialization. Should get DI error and no crash.
+        init() {
+        } // expected-error {{return from initializer without initializing all stored properties}}
+    }
+}
+
+func testStructSimplePartialInit() {
+    struct M: ~Copyable {
+        private let i: Int
+        private let i2: Int // expected-note {{'self.i2' not initialized}}
+
+        init() {
+            i = 5
+        } // expected-error {{return from initializer without initializing all stored properties}}
+    }
+}
+
+func testStructSimplePartialInit2() {
+    struct M: ~Copyable {
+        private let i: Int = 5
+        private let i2: Int // expected-note {{'self.i2' not initialized}}
+
+        init() {
+        } // expected-error {{return from initializer without initializing all stored properties}}
+    }
+}
+
+func testStructGenericNoInit() {
+    struct M<T>: ~Copyable {
+        private let i: T // expected-note {{'self.i' not initialized}}
+
+        init() {
+        } // expected-error {{return from initializer without initializing all stored properties}}
+    }
+}
+
+func testStructGenericPartialInit() {
+    struct M<T>: ~Copyable {
+        private let i: T
+        private let i2: T // expected-note {{'self.i2' not initialized}}
+
+        init(_ t: T) {
+            self.i = t
+        } // expected-error {{return from initializer without initializing all stored properties}}
+    }
+}
+
+func testEnumNoInit() {
+    enum E : ~Copyable {
+        case first
+        case second
+
+        init() {
+        } // expected-error {{'self.init' isn't called on all paths before returning from initializer}}
+    }
+}
+
+func testEnumNoInitWithPayload() {
+    @_moveOnly struct Empty {}
+
+    enum E : ~Copyable {
+        case first(Empty)
+        case second
+
+        init() {
+        } // expected-error {{'self.init' isn't called on all paths before returning from initializer}}
+    }
+}
+
+func testEnumNoInitWithGenericPayload() {
+    @_moveOnly struct Empty {}
+
+    enum E<T> : ~Copyable {
+        case first(Empty)
+        case second(T)
+
+        init() {
+        } // expected-error {{'self.init' isn't called on all paths before returning from initializer}}
+    }
+}