[move-only] Ported rest of no implicit copy tests to move only and fixed resulting issues.

This is just to get code coverage. A few interesting things I noticed:

1. I am seeing a false diagnostic on this pattern:

let x = ...
var x2 = x
print(x2) // I get that print(x2) is a consuming use of x.

I think it is predictable mem opts maybe forwarding in an interesting way. I am
not sure. It doesn't happen with no implicit copy types since x2 would not be no
implicit copy so we would leave the no implicit copy monad.

2. I think that SILGen creates a real lexical scope for temporary variables
meaning that compiler generated code would actually hit the move checker. I had
to add an extra code pattern to handle this.

Author: gottesmm

lib/SILGen/SILGenDecl.cpp

@@ -584,29 +584,36 @@ class LetValueInitialization : public Initialization {
     // that acts as a consuming use of the value. The reason why we want this is
     // even if we are only performing a borrow for our lexical lifetime, we want
     // to ensure that our defs see this initialization as consuming this value.
-    if (value->getOwnershipKind() == OwnershipKind::Owned) {
+    if (value->getOwnershipKind() == OwnershipKind::Owned &&
+        value->getType().isMoveOnlyWrapped()) {
       assert(wasPlusOne);
       // NOTE: If our type is trivial when not wrapped in a
       // SILMoveOnlyWrappedType, this will return a trivial value. We rely
       // on the checker to determine if this is an acceptable use of the
       // value.
-      if (value->getType().isMoveOnly()) {
-        if (value->getType().isMoveOnlyWrapped()) {
-          value = SGF.B.createOwnedMoveOnlyWrapperToCopyableValue(PrologueLoc,
-                                                                  value);
-        } else {
-          // Change this to be lexical and get rid of borrow scope?
-          value = SGF.B.createMoveValue(PrologueLoc, value);
-        }
-      }
+      value =
+          SGF.B.createOwnedMoveOnlyWrapperToCopyableValue(PrologueLoc, value);
     }
 
     // If we still have a trivial thing, just return that.
     if (value->getType().isTrivial(SGF.F))
       return value;
 
+    // Check if we have a move only type. In that case, we perform a lexical
+    // move and insert a mark_must_check.
+    //
+    // We do this before the begin_borrow "normal" path below since move only
+    // types do not have no implicit copy attr on them.
+    if (value->getOwnershipKind() == OwnershipKind::Owned &&
+        value->getType().isMoveOnly() &&
+        !value->getType().isMoveOnlyWrapped()) {
+      value = SGF.B.createMoveValue(PrologueLoc, value, true /*isLexical*/);
+      return SGF.B.createMarkMustCheckInst(
+          PrologueLoc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+    }
+
     // Otherwise, if we do not have a no implicit copy variable, just do a
-    // borrow lexical.
+    // borrow lexical. This is the "normal path".
     if (!vd->getAttrs().hasAttribute<NoImplicitCopyAttr>())
       return SGF.B.createBeginBorrow(PrologueLoc, value, /*isLexical*/ true);
 

lib/SILOptimizer/Mandatory/MoveOnlyChecker.cpp

@@ -117,16 +117,26 @@ bool MoveOnlyChecker::searchForCandidateMarkMustChecks() {
       if (!mmci || !mmci->hasMoveCheckerKind())
         continue;
 
-      // Handle guaranteed/owned move only typed arguments.
+      // Handle guaranteed/owned move arguments and values.
       //
       // We are pattern matching against these patterns:
       //
       // bb0(%0 : @guaranteed $T):
       //   %1 = copy_value %0
       //   %2 = mark_must_check [no_copy] %1
       // bb0(%0 : @owned $T):
-      //   %1 = copy_value %0
-      //   %2 = mark_must_check [no_copy] %1
+      //   %1 = mark_must_check [no_copy] %2
+      //
+      // This is forming a let or an argument.
+      // bb0:
+      //   %1 = move_value [lexical] %0
+      //   %2 = mark_must_check [no_implicit_copy] %1
+      //
+      // This occurs when SILGen materializes a temporary move only value?
+      // bb0:
+      //   %1 = begin_borrow [lexical] %0
+      //   %2 = copy_value %1
+      //   %3 = mark_must_check [no_copy] %2
       if (mmci->getOperand()->getType().isMoveOnly() &&
           !mmci->getOperand()->getType().isMoveOnlyWrapped()) {
         if (auto *cvi = dyn_cast<CopyValueInst>(mmci->getOperand())) {
@@ -136,16 +146,20 @@ bool MoveOnlyChecker::searchForCandidateMarkMustChecks() {
               continue;
             }
           }
+
+          if (auto *bbi = dyn_cast<BeginBorrowInst>(cvi->getOperand())) {
+            if (bbi->isLexical()) {
+              moveIntroducersToProcess.insert(mmci);
+              continue;
+            }
+          }
         }
 
+        // Any time we have a lexical move_value, we can process it.
         if (auto *mvi = dyn_cast<MoveValueInst>(mmci->getOperand())) {
           if (mvi->isLexical()) {
-            if (auto *arg = dyn_cast<SILFunctionArgument>(mvi->getOperand())) {
-              if (arg->getOwnershipKind() == OwnershipKind::Owned) {
-                moveIntroducersToProcess.insert(mmci);
-                continue;
-              }
-            }
+            moveIntroducersToProcess.insert(mmci);
+            continue;
           }
         }
 
@@ -247,6 +261,8 @@ bool MoveOnlyChecker::searchForCandidateMarkMustChecks() {
       //  %2 = copy_value %1
       //  %3 = copyable_to_moveonlywrapper [owned] %2
       //  %4 = mark_must_check [no_implicit_copy]
+      //
+      // Or for a move only type, we look for a move_value [lexical].
       if (auto *mvi = dyn_cast<CopyableToMoveOnlyWrapperValueInst>(
               mmci->getOperand())) {
         if (auto *cvi = dyn_cast<CopyValueInst>(mvi->getOperand())) {