[SILGen] Used move_value for @noImplicitCopy.

Replace the pattern of begin_borrow [lexical] + copy_value with
move_value [lexical] to avoid introducing a spurious copy to begin with.

Author: nate-chandler

lib/SILGen/SILGenDecl.cpp

@@ -843,10 +843,9 @@ class LetValueInitialization : public Initialization {
 
     // If we have a no implicit copy lexical, emit the instruction stream so
     // that the move checker knows to check this variable.
-    value = SGF.B.createBeginBorrow(
-        PrologueLoc, value,
-        /*isLexical*/ true, /*hasPointerEscape=*/false, /*fromVarDecl=*/true);
-    value = SGF.B.createCopyValue(PrologueLoc, value);
+    value =
+        SGF.B.createMoveValue(PrologueLoc, value, /*IisLexical*/ true,
+                              /*hasPointerEscape=*/false, /*fromVarDecl=*/true);
     value = SGF.B.createOwnedCopyableToMoveOnlyWrapperValue(PrologueLoc, value);
     return SGF.B.createMarkUnresolvedNonCopyableValueInst(
         PrologueLoc, value,
@@ -2192,14 +2191,10 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
 
       if (auto *copyToMove = dyn_cast<CopyableToMoveOnlyWrapperValueInst>(
               mvi->getOperand())) {
-        if (auto *cvi = dyn_cast<CopyValueInst>(copyToMove->getOperand())) {
-          if (auto *bbi = dyn_cast<BeginBorrowInst>(cvi->getOperand())) {
-            if (bbi->isLexical()) {
-              B.emitDestroyValueOperation(silLoc, mvi);
-              B.createEndBorrow(silLoc, bbi);
-              B.emitDestroyValueOperation(silLoc, bbi->getOperand());
-              return;
-            }
+        if (auto *move = dyn_cast<MoveValueInst>(copyToMove->getOperand())) {
+          if (move->isLexical()) {
+            B.emitDestroyValueOperation(silLoc, mvi);
+            return;
           }
         }
       }

test/SILGen/noimplicitcopy.swift

@@ -337,8 +337,7 @@ func callClosureIntOwned() {
 // NOTE: MOW expands to MOVEONLYWRAPPED
 //
 // CHECK-LABEL: sil hidden [ossa] @$s14noimplicitcopy10printKlassyyF : $@convention(thin) () -> () {
-// CHECK:   [[X:%.*]] = begin_borrow [lexical] [var_decl] {{%[0-9]+}} : $Klass
-// CHECK:   [[X_COPY:%.*]] = copy_value [[X]]
+// CHECK:   [[X:%.*]] = move_value [lexical] [var_decl] {{%[0-9]+}} : $Klass
 // CHECK:   [[X_MOVEONLYWRAPPED:%.*]] = copyable_to_moveonlywrapper [owned] [[X_COPY]]
 // CHECK:   [[X_MOVEONLYWRAPPED_MARKED:%.*]] = mark_unresolved_non_copyable_value [consumable_and_assignable] [[X_MOVEONLYWRAPPED]]
 // CHECK:   [[BORROWED_X_MOVEONLYWRAPPED_MARKED:%.*]] = begin_borrow [[X_MOVEONLYWRAPPED_MARKED]]

test/SILOptimizer/noimplicitcopy_borrow_to_destructure_transform_diagnostics.sil

@@ -23,9 +23,8 @@ sil [ossa] @aggStructConsumeField : $@convention(thin) (@guaranteed AggStruct) -
 bb0(%0 : @guaranteed $AggStruct):
   debug_value %0 : $AggStruct, let, name "x", argno 1
   %2 = copy_value %0 : $AggStruct
-  %3 = begin_borrow [lexical] %2 : $AggStruct
-  %4 = copy_value %3 : $AggStruct
-  %5 = copyable_to_moveonlywrapper [owned] %4 : $AggStruct
+  %3 = move_value [lexical] [var_decl] %2 : $AggStruct
+  %5 = copyable_to_moveonlywrapper [owned] %3 : $AggStruct
   %6 = mark_unresolved_non_copyable_value [consumable_and_assignable] %5 : $@moveOnly AggStruct
   debug_value %6 : $@moveOnly AggStruct, let, name "x2"
   %8 = begin_borrow %6 : $@moveOnly AggStruct
@@ -52,8 +51,6 @@ bb2:
 
 bb3:
   destroy_value %6 : $@moveOnly AggStruct
-  end_borrow %3 : $AggStruct
-  destroy_value %2 : $AggStruct
   %64 = tuple ()
   return %64 : $()
 }