[move-only] Fix a few bugs around MoveOnlyWrapperToCopyableValue.

The main fixes are:

1. MoveOnlyWrapperToCopyableValue needed to be marked as a
   FirstArgOwnershipForwardingSingleValueInst instead of just as being an
   Ownership mixin. I discovered that in certain cases I was treating it that
   way (in the isa check for FirstArgOwnershipForwardingSingleValueInst), but we
   were inconsistent. Now we are consistent.

2. MoveOnlyWrapperToCopyableValue is always specified as being initialized as
   owned or guaranteed. What is key to understand though is that the
   owned/guaranteed property here is more a semantic property around whether the
   lifetime of the move only value is ending or if we are allowing it to escape
   as an moveonlywrapped unwrapped guaranteed parameter to a function. The main
   implication of this is that we can not just use the actual ownership kind to
   determine the type of moveonlywrapper_to_copyable we are using. This is b/c
   after ownership lowering, the resulting ownership kind will be none, meaning
   the instruction will be in an invalid state. Thus the need to represent this
   as a separate bit in the instruction. It may make sense to rename the forms
   of this instruction to be `[lifetime end]` and `[guaranteed function arg]`
   that way it is semantically clear. But I am going to do that change at
   another time.

Author: gottesmm

include/swift/SIL/SILBuilder.h

@@ -1299,14 +1299,16 @@ class SILBuilder {
   MoveOnlyWrapperToCopyableValueInst *
   createOwnedMoveOnlyWrapperToCopyableValue(SILLocation loc, SILValue src) {
     return insert(new (getModule()) MoveOnlyWrapperToCopyableValueInst(
-        *F, getSILDebugLocation(loc), src, OwnershipKind::Owned));
+        *F, getSILDebugLocation(loc), src,
+        MoveOnlyWrapperToCopyableValueInst::Owned));
   }
 
   MoveOnlyWrapperToCopyableValueInst *
   createGuaranteedMoveOnlyWrapperToCopyableValue(SILLocation loc,
                                                  SILValue src) {
     return insert(new (getModule()) MoveOnlyWrapperToCopyableValueInst(
-        *F, getSILDebugLocation(loc), src, OwnershipKind::Guaranteed));
+        *F, getSILDebugLocation(loc), src,
+        MoveOnlyWrapperToCopyableValueInst::Guaranteed));
   }
 
   UnconditionalCheckedCastInst *

include/swift/SIL/SILInstruction.h

@@ -7627,19 +7627,29 @@ class CopyableToMoveOnlyWrapperValueInst
 class MoveOnlyWrapperToCopyableValueInst
     : public UnaryInstructionBase<
           SILInstructionKind::MoveOnlyWrapperToCopyableValueInst,
-          SingleValueInstruction>,
-      public OwnershipForwardingMixin {
+          FirstArgOwnershipForwardingSingleValueInst> {
+public:
+  enum InitialKind {
+    Guaranteed,
+    Owned,
+  };
+
+private:
   friend class SILBuilder;
 
+  InitialKind initialKind;
+
   MoveOnlyWrapperToCopyableValueInst(const SILFunction &fn,
                                      SILDebugLocation DebugLoc,
-                                     SILValue operand,
-                                     OwnershipKind forwardingOwnershipKind)
-      : UnaryInstructionBase(DebugLoc, operand,
-                             operand->getType().removingMoveOnlyWrapper()),
-        OwnershipForwardingMixin(
-            SILInstructionKind::MoveOnlyWrapperToCopyableValueInst,
-            forwardingOwnershipKind) {}
+                                     SILValue operand, InitialKind kind)
+      : UnaryInstructionBase(
+            DebugLoc, operand, operand->getType().removingMoveOnlyWrapper(),
+            kind == InitialKind::Guaranteed ? OwnershipKind::Guaranteed
+                                            : OwnershipKind::Owned),
+        initialKind(kind) {}
+
+public:
+  InitialKind getInitialKind() const { return initialKind; }
 };
 
 /// Given an object reference, return true iff it is non-nil and refers
@@ -9783,8 +9793,7 @@ inline bool OwnershipForwardingMixin::isa(SILInstructionKind kind) {
          OwnershipForwardingConversionInst::classof(kind) ||
          OwnershipForwardingSelectEnumInstBase::classof(kind) ||
          OwnershipForwardingMultipleValueInstruction::classof(kind) ||
-         kind == SILInstructionKind::MarkMustCheckInst ||
-         kind == SILInstructionKind::MoveOnlyWrapperToCopyableValueInst;
+         kind == SILInstructionKind::MarkMustCheckInst;
 }
 
 inline OwnershipForwardingMixin *

lib/SIL/IR/SILPrinter.cpp

@@ -1921,15 +1921,11 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
 
   void visitMoveOnlyWrapperToCopyableValueInst(
       MoveOnlyWrapperToCopyableValueInst *I) {
-    switch (I->getForwardingOwnershipKind()) {
-    case OwnershipKind::None:
-    case OwnershipKind::Any:
-    case OwnershipKind::Unowned:
-      llvm_unreachable("Move only values are always non-trivial");
-    case OwnershipKind::Owned:
+    switch (I->getInitialKind()) {
+    case MoveOnlyWrapperToCopyableValueInst::Owned:
       *this << "[owned] ";
       break;
-    case OwnershipKind::Guaranteed:
+    case MoveOnlyWrapperToCopyableValueInst::Guaranteed:
       *this << "[guaranteed] ";
       break;
     }