[move-function] Make sure that we error if the user re-initializes a var via its fields instead of all at once.

In the future we may be able to handle this case, but for now lets just error so
that users are not confused.

Author: gottesmm

lib/SILOptimizer/Mandatory/MoveKillsCopyableAddressesChecker.cpp

@@ -917,12 +917,26 @@ bool GatherClosureUseVisitor::visitUse(Operand *op, AccessUseType useTy) {
     return true;
 
   if (memInstMustInitialize(op)) {
+    if (stripAccessMarkers(op->get()) != useState.address) {
+      LLVM_DEBUG(llvm::dbgs()
+                 << "!!! Error! Found init use not on base address: "
+                 << *op->getUser());
+      return false;
+    }
+
     LLVM_DEBUG(llvm::dbgs() << "ClosureUse: Found init: " << *op->getUser());
     useState.inits.insert(op->getUser());
     return true;
   }
 
   if (memInstMustReinitialize(op)) {
+    if (stripAccessMarkers(op->get()) != useState.address) {
+      LLVM_DEBUG(llvm::dbgs()
+                 << "!!! Error! Found reinit use not on base address: "
+                 << *op->getUser());
+      return false;
+    }
+
     LLVM_DEBUG(llvm::dbgs() << "ClosureUse: Found reinit: " << *op->getUser());
     useState.insertReinit(op->getUser());
     return true;
@@ -1279,12 +1293,26 @@ bool GatherLexicalLifetimeUseVisitor::visitUse(Operand *op,
   }
 
   if (memInstMustInitialize(op)) {
+    if (stripAccessMarkers(op->get()) != useState.address) {
+      LLVM_DEBUG(llvm::dbgs()
+                 << "!!! Error! Found init use not on base address: "
+                 << *op->getUser());
+      return false;
+    }
+
     LLVM_DEBUG(llvm::dbgs() << "Found init: " << *op->getUser());
     useState.inits.insert(op->getUser());
     return true;
   }
 
   if (memInstMustReinitialize(op)) {
+    if (stripAccessMarkers(op->get()) != useState.address) {
+      LLVM_DEBUG(llvm::dbgs()
+                 << "!!! Error! Found reinit use not on base address: "
+                 << *op->getUser());
+      return false;
+    }
+
     LLVM_DEBUG(llvm::dbgs() << "Found reinit: " << *op->getUser());
     useState.insertReinit(op->getUser());
     return true;
@@ -1308,6 +1336,14 @@ bool GatherLexicalLifetimeUseVisitor::visitUse(Operand *op,
   // are going to try and extend move checking into the partial apply using
   // cloning to eliminate destroys or reinits.
   if (auto fas = FullApplySite::isa(op->getUser())) {
+    if (stripAccessMarkers(op->get()) != useState.address) {
+      LLVM_DEBUG(
+          llvm::dbgs()
+          << "!!! Error! Found consuming closure use not on base address: "
+          << *op->getUser());
+      return false;
+    }
+
     if (fas.getArgumentOperandConvention(*op) ==
         SILArgumentConvention::Indirect_InoutAliasable) {
       // If we don't find the function, we can't handle this, so bail.

test/SILOptimizer/move_function_kills_copyable_addressonly_vars.swift

@@ -668,3 +668,25 @@ func multipleCapture2<T : P>(_ k: T) -> () {
     print("foo bar")
 }
 
+//////////////////////
+// Reinit in pieces //
+//////////////////////
+
+// These tests exercise the diagnostic to see how we error if we re-initialize a
+// var in pieces. Eventually we should teach either this diagnostic pass how to
+// handle this or teach DI how to combine the initializations into one large
+// reinit.
+struct ProtPair<T : P> {
+    var lhs: T
+    var rhs: T
+}
+
+func reinitInPieces1<T : P>(_ k: ProtPair<T>) {
+    let selfType = type(of: k.lhs)
+    var k2 = k
+    k2 = k
+
+    let _ = _move(k2) // expected-error {{_move applied to value that the compiler does not support checking}}
+    k2.lhs = selfType.getP()
+    k2.rhs = selfType.getP()
+}

test/SILOptimizer/move_function_kills_copyable_loadable_vars.swift

@@ -710,3 +710,24 @@ func multipleCapture2(_ k: Klass) -> () {
     print("foo bar")
 }
 
+//////////////////////
+// Reinit in pieces //
+//////////////////////
+
+// These tests exercise the diagnostic to see how we error if we re-initialize a
+// var in pieces. Eventually we should teach either this diagnostic pass how to
+// handle this or teach DI how to combine the initializations into one large
+// reinit.
+struct KlassPair {
+    var lhs: Klass
+    var rhs: Klass
+}
+
+func reinitInPieces1(_ k: KlassPair) {
+    var k2 = k
+    k2 = k
+
+    let _ = _move(k2) // expected-error {{_move applied to value that the compiler does not support checking}}
+    k2.lhs = Klass()
+    k2.rhs = Klass()
+}