[move-only] Emit the move only marker for move only trivial enums.

Just an oversight I discovered when writing the enum deinit tests.

Author: gottesmm

include/swift/SIL/SILType.h

@@ -622,6 +622,10 @@ class SILType {
   /// wrapped type.
   bool isMoveOnly() const;
 
+  /// Is this a type that is a first class move only type. This returns false
+  /// for a move only wrapped type.
+  bool isPureMoveOnly() const;
+
   /// Returns true if and only if this type is a first class move only
   /// type. NOTE: Returns false if the type is a move only wrapped type.
   bool isMoveOnlyType() const;

lib/SIL/IR/SILType.cpp

@@ -948,3 +948,10 @@ bool SILType::isMoveOnlyType() const {
       return true;
   return false;
 }
+
+bool SILType::isPureMoveOnly() const {
+  if (auto *nom = getNominalOrBoundGenericNominal())
+    if (nom->isMoveOnly())
+      return true;
+  return false;
+}

lib/SILGen/SILGenApply.cpp

@@ -4248,6 +4248,7 @@ RValue CallEmission::applyEnumElementConstructor(SGFContext C) {
       uncurriedLoc, std::move(payload),
       SGF.getLoweredType(formalResultType),
       element, uncurriedContext);
+
   return RValue(SGF, uncurriedLoc, formalResultType, resultMV);
 }
 

lib/SILGen/SILGenDecl.cpp

@@ -570,10 +570,21 @@ class LetValueInitialization : public Initialization {
                                              SILValue value, bool wasPlusOne) {
     // If we have none...
     if (value->getOwnershipKind() == OwnershipKind::None) {
-      // ... and we don't have a no implicit copy trivial type, just return
-      // value.
-      if (!SGF.getASTContext().LangOpts.Features.count(Feature::MoveOnly) ||
-          !vd->isNoImplicitCopy() || !value->getType().isTrivial(SGF.F))
+      // If we don't have move only features enabled, just return, we are done.
+      if (!SGF.getASTContext().LangOpts.Features.count(Feature::MoveOnly))
+        return value;
+
+      // Then check if we have a pure move only type. In that case, we need to
+      // insert a no implicit copy
+      if (value->getType().isPureMoveOnly()) {
+        value = SGF.B.createMoveValue(PrologueLoc, value, /*isLexical*/ true);
+        return SGF.B.createMarkMustCheckInst(
+            PrologueLoc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
+      }
+
+      // Otherwise, if we don't have a no implicit copy trivial type, just
+      // return value.
+      if (!vd->isNoImplicitCopy() || !value->getType().isTrivial(SGF.F))
         return value;
 
       // Otherwise, we have a no implicit copy trivial type, so wrap it in the

test/SILGen/moveonly_enum_literal.swift

@@ -0,0 +1,27 @@
+// RUN: %target-swift-frontend -enable-experimental-move-only -emit-silgen %s | %FileCheck %s
+
+// This test makes sure that we properly setup enums when we construct moveonly
+// enums from literals.
+
+@_moveOnly
+enum MoveOnlyIntPair {
+case lhs(Int)
+case rhs(Int)
+}
+
+func consumeMoveIntPair(_ x: __owned MoveOnlyIntPair) {}
+
+var value: Bool { false }
+
+// CHECK-LABEL: sil hidden [ossa] @$s21moveonly_enum_literal4testyyF : $@convention(thin) () -> () {
+// CHECK: [[VALUE:%.*]] = enum $MoveOnlyIntPair, #MoveOnlyIntPair.lhs!enumelt,
+// CHECK: [[MV:%.*]] = move_value [lexical] [[VALUE]]
+// CHECK: [[MARKED_VALUE:%.*]] = mark_must_check [no_implicit_copy] [[MV]]
+// CHECK: debug_value [[MARKED_VALUE]]
+// CHECK: } // end sil function '$s21moveonly_enum_literal4testyyF'
+func test() {
+    let x = MoveOnlyIntPair.lhs(5)
+    if value {
+        consumeMoveIntPair(x)
+    }
+}