[move-only] Add support in SILGen for unwrapping moveonlywrapped values before materializing for a function argument.

I discovered this as I began to write some Interpreter tests for move only. This
was triggered by SILGen attempting to pass a non-trivial type to StringBuilder
which is generic, so we needed to materialize.

I also discovered a small bug where we were not properly ignoring class_method
in the move only type eliminator. I just folded the small fix + a test for that
into this commit.

Author: gottesmm

lib/SILGen/SILGenApply.cpp

@@ -3082,6 +3082,18 @@ class ArgEmitter {
 
       // If it's not already in memory, put it there.
       if (!result.getType().isAddress()) {
+        // If we have a move only wrapped type, we need to unwrap before we
+        // materialize. We will forward as appropriate so it will show up as a
+        // consuming use or a guaranteed use as appropriate.
+        if (result.getType().isMoveOnlyWrapped()) {
+          if (result.isPlusOne(SGF)) {
+            result =
+                SGF.B.createOwnedMoveOnlyWrapperToCopyableValue(loc, result);
+          } else {
+            result = SGF.B.createGuaranteedMoveOnlyWrapperToCopyableValue(
+                loc, result);
+          }
+        }
         result = result.materialize(SGF, loc);
       }
 

lib/SILGen/SILGenBuilder.cpp

@@ -918,5 +918,6 @@ ManagedValue SILGenBuilder::createGuaranteedMoveOnlyWrapperToCopyableValue(
     SILLocation loc, ManagedValue value) {
   auto *mdi =
       createGuaranteedMoveOnlyWrapperToCopyableValue(loc, value.getValue());
+  assert(mdi->getOperand()->getType().isObject() && "Expected an object?!");
   return ManagedValue::forUnmanaged(mdi);
 }

lib/SILOptimizer/Mandatory/MoveOnlyTypeEliminator.cpp

@@ -182,6 +182,7 @@ struct SILMoveOnlyTypeEliminatorVisitor
   NO_UPDATE_NEEDED(RefToBridgeObject)
   NO_UPDATE_NEEDED(BridgeObjectToRef)
   NO_UPDATE_NEEDED(UnconditionalCheckedCast)
+  NO_UPDATE_NEEDED(ClassMethod)
 #undef NO_UPDATE_NEEDED
 };
 

test/Interpreter/noimplicitcopy.swift

@@ -0,0 +1,38 @@
+// RUN: %target-run-simple-swift( -Xfrontend -enable-experimental-move-only ) | %FileCheck %s
+
+// A small sanity check.
+
+// REQUIRES: executable_test
+
+import StdlibUnittest
+
+var Tests = TestSuite("TrivialMoveOnly")
+defer { runAllTests() }
+
+func print2(_ x: Int) {
+    print("printInt: \(x + 1)")
+}
+
+// CHECK: printInt: 11
+// CHECK: printInt: 5
+Tests.test("printInt") {
+    @_noImplicitCopy let x: Int = 5
+    // Infix operators where we pass values as guaranteed parameters.
+    print2(x + x)
+    print("printInt: \(x)")
+}
+
+class Klass {
+    var i = 8
+    func increment() { i += 1 }
+}
+
+// CHECK: printKlass: main.Klass
+// CHECK: printKlass: 10
+Tests.test("printKlass") {
+    @_noImplicitCopy let x = Klass()
+    x.increment()
+    x.increment()
+    print("printKlass: \(x)")
+    print("printKlass: \(x.i)")
+}

test/SILGen/noimplicitcopy.swift

@@ -0,0 +1,67 @@
+// RUN: %target-swift-frontend -emit-silgen -enable-experimental-move-only %s | %FileCheck %s
+
+//////////////////
+// Declarations //
+//////////////////
+
+class Klass {
+    var i = 8
+    func increment() { i += 1 }
+}
+
+///////////
+// Tests //
+///////////
+func print2(_ x: Int) {
+    print("printInt: \(x + 1)")
+}
+
+// CHECK: sil hidden [ossa] @$s14noimplicitcopy8printIntyyF : $@convention(thin) () -> () {
+// CHECK:   [[X_MOVEONLY:%.*]] = copyable_to_moveonlywrapper {{%.*}} : $Int
+// CHECK:   [[X:%.*]] = begin_borrow [lexical] [[X_MOVEONLY]]
+// CHECK:   [[X_COPY:%.*]] = explicit_copy_value [[X]]
+// CHECK:   [[X_MOVEONLYWRAPPED_MARKED:%.*]] = mark_must_check [no_implicit_copy] [[X_COPY]]
+// CHECK:   [[BORROWED_X_MOVEONLYWRAPPED_MARKED_1:%.*]] = begin_borrow [[X_MOVEONLYWRAPPED_MARKED]]
+// CHECK:   [[BORROWED_X_MOVEONLYWRAPPED_MARKED_2:%.*]] = begin_borrow [[X_MOVEONLYWRAPPED_MARKED]]
+// CHECK:   [[FUNC:%.*]] = function_ref @$sSi1poiyS2i_SitFZ : $@convention(method) (Int, Int, @thin Int.Type) -> Int // user: %15
+// CHECK:   [[GUARANTEED_ESCAPED_X_1:%.*]] = moveonlywrapper_to_copyable [guaranteed] [[BORROWED_X_MOVEONLYWRAPPED_MARKED_1]]
+// CHECK:   [[GUARANTEED_ESCAPED_X_2:%.*]] = moveonlywrapper_to_copyable [guaranteed] [[BORROWED_X_MOVEONLYWRAPPED_MARKED_2]]
+// CHECK:   apply [[FUNC]]([[GUARANTEED_ESCAPED_X_1]], [[GUARANTEED_ESCAPED_X_2]], {{.*}})
+// CHECK:   [[BORROWED_X_MOVEONLYWRAPPED_MARKED:%.*]] = begin_borrow [[X_MOVEONLYWRAPPED_MARKED]]
+// CHECK:   [[GUARANTEED_ESCAPED_X:%.*]] = moveonlywrapper_to_copyable [guaranteed] [[BORROWED_X_MOVEONLYWRAPPED_MARKED]]
+// CHECK:   store [[GUARANTEED_ESCAPED_X]] to [trivial] {{%.*}} : $*Int
+// CHECK: } // end sil function '$s14noimplicitcopy8printIntyyF'
+func printInt() {
+    @_noImplicitCopy let x: Int = 5
+    print2(x + x)
+    print("printInt: \(x)")
+}
+
+// NOTE: MOW expands to MOVEONLYWRAPPED
+//
+// CHECK-LABEL: sil hidden [ossa] @$s14noimplicitcopy10printKlassyyF : $@convention(thin) () -> () {
+// CHECK:   [[X:%.*]] = begin_borrow [lexical] {{%[0-9]+}} : $Klass
+// CHECK:   [[X_COPY:%.*]] = copy_value [[X]]
+// CHECK:   [[X_MOVEONLYWRAPPED:%.*]] = copyable_to_moveonlywrapper [[X_COPY]]
+// CHECK:   [[X_MOVEONLYWRAPPED_MARKED:%.*]] = mark_must_check [no_implicit_copy] [[X_MOVEONLYWRAPPED]]
+// CHECK:   [[BORROWED_X_MOVEONLYWRAPPED_MARKED:%.*]] = begin_borrow [[X_MOVEONLYWRAPPED_MARKED]]
+// CHECK:   [[FUNC:%.*]] = class_method [[BORROWED_X_MOVEONLYWRAPPED_MARKED]]
+// CHECK:   [[GUARANTEED_ESCAPED_X:%.*]] = moveonlywrapper_to_copyable [guaranteed] [[BORROWED_X_MOVEONLYWRAPPED_MARKED]]
+// CHECK:   apply [[FUNC]]([[GUARANTEED_ESCAPED_X]])
+//
+// CHECK:   [[BORROWED_X_MOVEONLYWRAPPED_MARKED:%.*]] = begin_borrow [[X_MOVEONLYWRAPPED_MARKED]]
+// CHECK:   [[FUNC:%.*]] = class_method [[BORROWED_X_MOVEONLYWRAPPED_MARKED]] :
+// CHECK:   [[GUARANTEED_ESCAPED_X:%.*]] = moveonlywrapper_to_copyable [guaranteed] [[BORROWED_X_MOVEONLYWRAPPED_MARKED]]
+// CHECK:   apply [[FUNC]]([[GUARANTEED_ESCAPED_X]])
+//
+// CHECK:   [[BORROWED_X_MOVEONLYWRAPPED_MARKED:%.*]] = begin_borrow [[X_MOVEONLYWRAPPED_MARKED]]
+// CHECK:   [[GUARANTEED_ESCAPED_X:%.*]] = moveonlywrapper_to_copyable [guaranteed] [[BORROWED_X_MOVEONLYWRAPPED_MARKED]]
+// CHECK:   store_borrow [[GUARANTEED_ESCAPED_X]] to
+// CHECK: } // end sil function '$s14noimplicitcopy10printKlassyyF'
+func printKlass() {
+    @_noImplicitCopy let x = Klass()
+    x.increment()
+    x.increment()
+    print("printKlass: \(x)")
+    print("printKlass: \(x.i)")
+}

test/SILOptimizer/move_only_type_eliminator.sil

@@ -25,7 +25,10 @@ struct TrivialPair {
 
 sil @use_trivial : $@convention(thin) (Trivial) -> ()
 
-class Klass {}
+class Klass {
+  func foo()
+}
+
 struct KlassPair {
   var lhs: Klass
   var rhs: Klass
@@ -540,9 +543,9 @@ bb0(%0 : @guaranteed $Klass):
   %f = function_ref @use_klass : $@convention(thin) (@guaranteed Klass) -> ()
   %0aa = copy_value %0 : $Klass
   %0a = copyable_to_moveonlywrapper %0aa : $Klass
+  %notUsed = class_method %0a : $@moveOnly Klass, #Klass.foo : (Klass) -> () -> (), $@convention(method) (@guaranteed Klass) -> ()
   debug_value %0a : $@moveOnly Klass, let, name "foo"
   %2 = enum $@moveOnly FakeOptional<Klass>, #FakeOptional.some!enumelt, %0a : $@moveOnly Klass
-
   switch_enum %2 : $@moveOnly FakeOptional<Klass>, case #FakeOptional.some!enumelt: bb1, case #FakeOptional.none!enumelt: bb2
 
 bb1(%2Payload : @owned $@moveOnly Klass):