[move-only] Begin implementing support for concrete move only types.

This is just the very beginning... I still need to implement more parts of
SILGen for this. But all great things start small. I am going to iterate on top
of this and just wanted to get some initial parts of the work in as I go.

Author: gottesmm

include/swift/SIL/SILInstruction.h

@@ -7587,8 +7587,8 @@ class MarkMustCheckInst
         OwnershipForwardingMixin(SILInstructionKind::MarkMustCheckInst,
                                  operand->getOwnershipKind()),
         kind(checkKind) {
-    assert(operand->getType().isMoveOnlyWrapped() &&
-           "mark_must_check can only take a move only wrapped value");
+    assert(operand->getType().isMoveOnly() &&
+           "mark_must_check can only take a move only typed value");
   }
 
 public:

lib/SIL/IR/SILType.cpp

@@ -925,8 +925,10 @@ SILType::getSingletonAggregateFieldType(SILModule &M,
   return SILType();
 }
 
+// TODO: Create isPureMoveOnly.
 bool SILType::isMoveOnly() const {
   if (auto *nom = getNominalOrBoundGenericNominal())
-    return nom->isMoveOnly();
+    if (nom->isMoveOnly())
+      return true;
   return isMoveOnlyWrapped();
 }

lib/SILGen/SILGenConstructor.cpp

@@ -26,6 +26,7 @@
 #include "swift/AST/PropertyWrappers.h"
 #include "swift/Basic/Defer.h"
 #include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILUndef.h"
 #include "swift/SIL/TypeLowering.h"
 
@@ -386,6 +387,7 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
 
   // Allocate the local variable for 'self'.
   emitLocalVariableWithCleanup(selfDecl, MUIKind)->finishInitialization(*this);
+
   SILValue selfLV = VarLocs[selfDecl].value;
 
   // Emit the prolog.
@@ -831,6 +833,11 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
                                 StoreOwnershipQualifier::Init);
     } else {
       selfArg = B.createMarkUninitialized(selfDecl, selfArg, MUKind);
+      if (selfArg.getType().isMoveOnly()) {
+        assert(selfArg.getOwnershipKind() == OwnershipKind::Owned);
+        selfArg = B.createMarkMustCheckInst(
+            selfDecl, selfArg, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+      }
       VarLocs[selfDecl] = VarLoc::get(selfArg.getValue());
     }
   }

lib/SILGen/SILGenDecl.cpp

@@ -572,15 +572,21 @@ class LetValueInitialization : public Initialization {
           // 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->getType().isMoveOnlyWrapped() &&
-              value->getOwnershipKind() == OwnershipKind::Owned) {
+          if (value->getOwnershipKind() == OwnershipKind::Owned) {
             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.
-            value = SGF.B.createOwnedMoveOnlyWrapperToCopyableValue(PrologueLoc,
-                                                                    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);
+              }
+            }
           }
 
           // If we still have a non-trivial thing, emit code that will need to

lib/SILGen/SILGenPattern.cpp

@@ -2835,9 +2835,13 @@ void SILGenFunction::emitSwitchStmt(SwitchStmt *S) {
   auto subject = ([&]() -> ConsumableManagedValue {
     // If we have a move only value, ensure plus one and convert it. Switches
     // always consume move only values.
-    if (subjectMV.getType().isMoveOnlyWrapped()) {
-      subjectMV = B.createOwnedMoveOnlyWrapperToCopyableValue(
-          S, subjectMV.ensurePlusOne(*this, S));
+    if (subjectMV.getType().isMoveOnly()) {
+      if (subjectMV.getType().isMoveOnlyWrapped()) {
+        subjectMV = B.createOwnedMoveOnlyWrapperToCopyableValue(
+            S, subjectMV.ensurePlusOne(*this, S));
+      } else {
+        subjectMV = B.createMoveValue(S, subjectMV.ensurePlusOne(*this, S));
+      }
     }
 
     // If we have a plus one value...

lib/SILGen/SILGenProlog.cpp

@@ -314,6 +314,20 @@ struct ArgumentInitHelper {
                 loc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
             SGF.emitManagedRValueWithCleanup(value);
           }
+        } else if (value->getType().isMoveOnly()) {
+          if (value->getOwnershipKind() == OwnershipKind::Owned) {
+            value = SGF.B.createMoveValue(loc, argrv.forward(SGF),
+                                          /*isLexical*/ true);
+            value = SGF.B.createMarkMustCheckInst(
+                loc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+            SGF.emitManagedRValueWithCleanup(value);
+          } else {
+            assert(value->getOwnershipKind() == OwnershipKind::Guaranteed);
+            value = SGF.B.createCopyValue(loc, value);
+            value = SGF.B.createMarkMustCheckInst(
+                loc, value, MarkMustCheckInst::CheckKind::NoCopy);
+            SGF.emitManagedRValueWithCleanup(value);
+          }
         } else {
           if (value->getOwnershipKind() == OwnershipKind::Owned) {
             value = SILValue(

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -11,12 +11,14 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "definite-init"
+
 #include "DIMemoryUseCollector.h"
 #include "swift/AST/Expr.h"
 #include "swift/SIL/ApplySite.h"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SILOptimizer/Utils/DistributedActor.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Debug.h"
@@ -1211,6 +1213,7 @@ void ElementUseCollector::collectClassSelfUses(SILValue ClassPointer) {
       Uses.append(beginAccess->getUses().begin(), beginAccess->getUses().end());
       continue;
     }
+
     if (isa<EndAccessInst>(User))
       continue;
 
@@ -1489,9 +1492,9 @@ void ElementUseCollector::collectClassSelfUses(
 
     // Look through begin_borrow, upcast, unchecked_ref_cast
     // and copy_value.
-    if (isa<BeginBorrowInst>(User) || isa<BeginAccessInst>(User)
-        || isa<UpcastInst>(User) || isa<UncheckedRefCastInst>(User)
-        || isa<CopyValueInst>(User)) {
+    if (isa<BeginBorrowInst>(User) || isa<BeginAccessInst>(User) ||
+        isa<UpcastInst>(User) || isa<UncheckedRefCastInst>(User) ||
+        isa<CopyValueInst>(User) || isa<MarkMustCheckInst>(User)) {
       auto value = cast<SingleValueInstruction>(User);
       std::copy(value->use_begin(), value->use_end(),
                 std::back_inserter(Worklist));

lib/SILOptimizer/Mandatory/MoveOnlyChecker.cpp

@@ -543,6 +543,46 @@ bool MoveOnlyChecker::searchForCandidateMarkMustChecks() {
       if (!mmci || !mmci->hasMoveCheckerKind())
         continue;
 
+      // Handle guaranteed/owned move only typed arguments.
+      //
+      // 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
+      if (mmci->getOperand()->getType().isMoveOnly() &&
+          !mmci->getOperand()->getType().isMoveOnlyWrapped()) {
+        if (auto *cvi = dyn_cast<CopyValueInst>(mmci->getOperand())) {
+          if (auto *arg = dyn_cast<SILFunctionArgument>(cvi->getOperand())) {
+            if (arg->getOwnershipKind() == OwnershipKind::Guaranteed) {
+              moveIntroducersToProcess.insert(mmci);
+              continue;
+            }
+          }
+        }
+
+        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;
+              }
+            }
+          }
+        }
+
+        if (auto *arg = dyn_cast<SILFunctionArgument>(mmci->getOperand())) {
+          if (arg->getOwnershipKind() == OwnershipKind::Owned) {
+            moveIntroducersToProcess.insert(mmci);
+            continue;
+          }
+        }
+      }
+
       // Handle guaranteed arguments.
       //
       // We are pattern matching this pattern:

test/SILGen/moveonly.swift

@@ -0,0 +1,177 @@
+// RUN: %target-swift-emit-silgen -enable-experimental-move-only %s | %FileCheck %s
+
+//////////////////
+// Declarations //
+//////////////////
+
+@_moveOnly
+public class Klass {
+    var intField: Int
+    var klsField: Klass?
+
+    // CHECK-LABEL: sil hidden [ossa] @$s8moveonly5KlassCACycfc : $@convention(method) (@owned Klass) -> @owned Klass {
+    // CHECK: bb0([[ARG:%.*]] : @owned $Klass):
+    // CHECK:   [[MARK_UNINIT:%.*]] = mark_uninitialized [rootself] [[ARG]]
+    // CHECK:   [[MARK_NO_IMP_COPY:%.*]] = mark_must_check [no_implicit_copy] [[MARK_UNINIT]]
+    // CHECK: } // end sil function '$s8moveonly5KlassCACycfc'
+    init() {
+        klsField = Klass()
+        intField = 5
+    }
+}
+
+public func nonConsumingUseKlass(_ k: Klass) {}
+
+@_moveOnly
+public struct NonTrivialStruct {
+    var k = Klass()
+}
+
+public func nonConsumingUseNonTrivialStruct(_ s: NonTrivialStruct) {}
+
+@_moveOnly
+public enum NonTrivialEnum {
+    case first
+    case second(Klass)
+    case third(NonTrivialStruct)
+}
+
+public func nonConsumingUseNonTrivialEnum(_ e : NonTrivialEnum) {}
+
+///////////
+// Tests //
+///////////
+
+//===---
+// Function Arguments
+//
+
+// CHECK-LABEL: sil [ossa] @$s8moveonly8useKlassyyAA0C0CF : $@convention(thin) (@guaranteed Klass) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Klass):
+// CHECK:   [[OWNED_ARG:%.*]] = copy_value [[ARG]]
+// CHECK:   [[MARKED_OWNED_ARG:%.*]] = mark_must_check [no_copy] [[OWNED_ARG]]
+// CHECK: } // end sil function '$s8moveonly8useKlassyyAA0C0CF'
+public func useKlass(_ k: Klass) {
+    nonConsumingUseKlass(k)
+    let k2 = k
+    nonConsumingUseKlass(k)
+    let _ = k2
+}
+
+// CHECK-LABEL: sil [ossa] @$s8moveonly15useKlassConsumeyyAA0C0CnF : $@convention(thin) (@owned Klass) -> () {
+// CHECK: bb0([[ARG:%.*]] : @owned $Klass):
+// TODO: Is this move_value [lexical] necessary?
+// CHECK:   [[LEXICAL_MOVE:%.*]] = move_value [lexical] [[ARG]]
+// CHECK:   mark_must_check [no_implicit_copy] [[LEXICAL_MOVE]]
+// CHECK: } // end sil function '$s8moveonly15useKlassConsumeyyAA0C0CnF'
+public func useKlassConsume(_ k: __owned Klass) {
+    nonConsumingUseKlass(k)
+    let k2 = k
+    // NOTE: We should mark the next line as a lifetime extending use.
+    nonConsumingUseKlass(k)
+    let _ = k2
+}
+
+// CHECK-LABEL: sil [ossa] @$s8moveonly19useNonTrivialStructyyAA0cdE0VF : $@convention(thin) (@guaranteed NonTrivialStruct) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $NonTrivialStruct):
+// CHECK:   [[COPIED_ARG:%.*]] = copy_value [[ARG]]
+// CHECK:   mark_must_check [no_copy] [[COPIED_ARG]]
+// CHECK: } // end sil function '$s8moveonly19useNonTrivialStructyyAA0cdE0VF'
+public func useNonTrivialStruct(_ s: NonTrivialStruct) {
+    nonConsumingUseNonTrivialStruct(s)
+    let s2 = s
+    let k = s.k
+    let _ = k
+    nonConsumingUseNonTrivialStruct(s)
+    let _ = s2
+}
+
+// CHECK-LABEL: sil [ossa] @$s8moveonly24useNonTrivialOwnedStructyyAA0cdF0VnF : $@convention(thin) (@owned NonTrivialStruct) -> () {
+// CHECK: bb0([[ARG:%.*]] : @owned $NonTrivialStruct):
+// CHECK:   [[MOVED_ARG:%.*]] = move_value [lexical] [[ARG]]
+// CHECK:   mark_must_check [no_implicit_copy] [[MOVED_ARG]]
+// CHECK: } // end sil function '$s8moveonly24useNonTrivialOwnedStructyyAA0cdF0VnF'
+public func useNonTrivialOwnedStruct(_ s: __owned NonTrivialStruct) {
+    nonConsumingUseNonTrivialStruct(s)
+    let s2 = s
+    let k = s.k
+    let _ = k
+    nonConsumingUseNonTrivialStruct(s)
+    let _ = s2
+}
+
+// CHECK-LABEL: sil [ossa] @$s8moveonly17useNonTrivialEnumyyAA0cdE0OF : $@convention(thin) (@guaranteed NonTrivialEnum) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $NonTrivialEnum):
+// CHECK:   [[COPIED_ARG:%.*]] = copy_value [[ARG]]
+// CHECK:   mark_must_check [no_copy] [[COPIED_ARG]]
+// CHECK: } // end sil function '$s8moveonly17useNonTrivialEnumyyAA0cdE0OF'
+public func useNonTrivialEnum(_ s: NonTrivialEnum) {
+    nonConsumingUseNonTrivialEnum(s)
+    let s2 = s
+    switch s {
+    case _:
+        break
+    }
+    nonConsumingUseNonTrivialEnum(s)
+    let _ = s2
+}
+
+// CHECK-LABEL: sil [ossa] @$s8moveonly22useNonTrivialOwnedEnumyyAA0cdF0OnF : $@convention(thin) (@owned NonTrivialEnum) -> () {
+// CHECK: bb0([[ARG:%.*]] : @owned $NonTrivialEnum):
+// CHECK:   [[MOVED_ARG:%.*]] = move_value [lexical] [[ARG]]
+// CHECK:   mark_must_check [no_implicit_copy] [[MOVED_ARG]]
+// CHECK: } // end sil function '$s8moveonly22useNonTrivialOwnedEnumyyAA0cdF0OnF'
+public func useNonTrivialOwnedEnum(_ s: __owned NonTrivialEnum) {
+    nonConsumingUseNonTrivialEnum(s)
+    let s2 = s
+    switch s {
+    case _:
+        break
+    }
+    nonConsumingUseNonTrivialEnum(s)
+    let _ = s2
+}
+
+//===---
+// Self in Init
+//
+
+//===---
+// Self in Methods
+//
+
+extension Klass {
+    // CHECK-LABEL: sil hidden [ossa] @$s8moveonly5KlassC13testNoUseSelfyyF : $@convention(method) (@guaranteed Klass) -> () {
+    // CHECK: bb0([[ARG:%.*]] : @guaranteed $Klass):
+    // CHECK:   [[COPIED_ARG:%.*]] = copy_value [[ARG]]
+    // CHECK:   mark_must_check [no_copy] [[COPIED_ARG]]
+    // CHECK: } // end sil function '$s8moveonly5KlassC13testNoUseSelfyyF'
+    func testNoUseSelf() {
+        let x = self
+        let _ = x
+    }
+}
+
+extension NonTrivialStruct {
+    // CHECK-LABEL: sil hidden [ossa] @$s8moveonly16NonTrivialStructV13testNoUseSelfyyF : $@convention(method) (@guaranteed NonTrivialStruct) -> () {
+    // CHECK: bb0([[ARG:%.*]] : @guaranteed $NonTrivialStruct):
+    // CHECK:   [[COPIED_ARG:%.*]] = copy_value [[ARG]]
+    // CHECK:   mark_must_check [no_copy] [[COPIED_ARG]]
+    // CHECK: } // end sil function '$s8moveonly16NonTrivialStructV13testNoUseSelfyyF'
+    func testNoUseSelf() {
+        let x = self
+        let _ = x
+    }
+}
+
+extension NonTrivialEnum {
+    // CHECK-LABEL: sil hidden [ossa] @$s8moveonly14NonTrivialEnumO13testNoUseSelfyyF : $@convention(method) (@guaranteed NonTrivialEnum) -> () {
+    // CHECK: bb0([[ARG:%.*]] : @guaranteed $NonTrivialEnum):
+    // CHECK:   [[COPIED_ARG:%.*]] = copy_value [[ARG]]
+    // CHECK:   mark_must_check [no_copy] [[COPIED_ARG]]
+    // CHECK: } // end sil function '$s8moveonly14NonTrivialEnumO13testNoUseSelfyyF'
+    func testNoUseSelf() {
+        let x = self
+        let _ = x
+    }
+}