ManualOwnership: adjust CopyExpr emission

We were getting an address-based emission for loadable types,
if the result of a LoadExpr was explicit-copied. This emission
had extra hidden copies that could not be silenced.

Author: kavon

lib/SILGen/SILGenExpr.cpp

@@ -7279,6 +7279,19 @@ RValue RValueEmitter::visitCopyExpr(CopyExpr *E, SGFContext C) {
 
   if (auto *li = dyn_cast<LoadExpr>(subExpr)) {
     FormalEvaluationScope writeback(SGF);
+
+    // If we're relying on ManualOwnership for explicit-copies enforcement,
+    // avoid doing address-based emission for loadable types.
+    if (subType.isLoadableOrOpaque(SGF.F) &&
+        SGF.F.getPerfConstraints() == PerformanceConstraints::ManualOwnership) {
+      // Interpret this 'load' as a borrow + copy instead.
+      LValue lv =
+        SGF.emitLValue(li->getSubExpr(), SGFAccessKind::BorrowedObjectRead);
+      auto value = SGF.emitBorrowedLValue(li, std::move(lv));
+      ManagedValue copy = SGF.B.createExplicitCopyValue(E, value);
+      return RValue(SGF, {copy}, subType.getASTType());
+    }
+
     LValue lv =
         SGF.emitLValue(li->getSubExpr(), SGFAccessKind::BorrowedAddressRead);
     auto address = SGF.emitAddressOfLValue(subExpr, std::move(lv));

test/SIL/manual_ownership.swift

@@ -172,9 +172,8 @@ public func basic_loop_trivial_values_fixed(_ t: Triangle, _ xs: [Triangle]) {
 // FIXME: the only reason for so many copies below is because
 // `Triangle.nontrivial` only exposes get/set rather than read/modify by default
 //
-// We should figure out when the coroutine accessors are generated, and ensure
-// that when it is available, it is used without copying the result, rather than
-// calling the get/set
+// There's complexity in auto-generating a read accessor for classes, but if it's provided
+// we could then allow someone to elide the copy with a `borrow x` expression.
 
 @_manualOwnership
 public func basic_loop_nontrivial_values(_ t: Triangle, _ xs: [Triangle]) {
@@ -185,14 +184,35 @@ public func basic_loop_nontrivial_values(_ t: Triangle, _ xs: [Triangle]) {
   t.nontrivial.a = p // expected-error {{accessing 't.nontrivial' produces a copy of it}}
 }
 
-// FIXME: there should be no copies required in the below, other than what's already written.
 @_manualOwnership
 public func basic_loop_nontrivial_values_fixed(_ t: Triangle, _ xs: [Triangle]) {
-  var p: Pair = (copy t.nontrivial).a  // expected-error {{accessing 't.nontrivial' produces a copy of it}}
+  var p: Pair = (copy t.nontrivial).a
   for x in copy xs {
-    p = p.midpoint((copy x.nontrivial).a) // expected-error {{accessing 'x.nontrivial' produces a copy of it}}
+    p = p.midpoint((copy x.nontrivial).a)
   }
-  (copy t.nontrivial).a = p // expected-error {{accessing 't.nontrivial' produces a copy of it}}
+  (copy t.nontrivial).a = p
+}
+
+@_manualOwnership
+public func basic_loop_nontrivial_values_reduced_copies(_ t: Triangle, _ xs: [Triangle]) {
+  // FIXME: confusing variable names are chosen
+  let nt = t.nontrivial // expected-error {{accessing 'nt' produces a copy of it}}
+  var p: Pair = nt.a
+  for x in copy xs {
+    let xnt = x.nontrivial // expected-error {{accessing 'xnt' produces a copy of it}}
+    p = p.midpoint(xnt.a)
+  }
+  nt.a = p
+}
+@_manualOwnership
+public func basic_loop_nontrivial_values_reduced_copies_fixed(_ t: Triangle, _ xs: [Triangle]) {
+  let nt = copy t.nontrivial
+  var p: Pair = nt.a
+  for x in copy xs {
+    let xnt = copy x.nontrivial
+    p = p.midpoint(xnt.a)
+  }
+  nt.a = p
 }
 
 

test/SILGen/manual_ownership.swift

@@ -0,0 +1,28 @@
+// RUN: %target-swift-frontend %s -emit-silgen -verify \
+// RUN:   -enable-experimental-feature ManualOwnership -o %t.silgen
+
+// RUN: %FileCheck %s --input-file %t.silgen
+
+// REQUIRES: swift_feature_ManualOwnership
+
+class ShapeClass {}
+class TriangleClass {
+  var shape = ShapeClass()
+}
+
+// CHECK-LABEL: sil {{.*}} @basic_access_of_loadable
+// CHECK:       bb0(%0 : @guaranteed $TriangleClass):
+// CHECK-NEXT:    debug_value %0
+// CHECK-NEXT:    [[M:%.*]] = class_method %0, #TriangleClass.shape!getter
+// CHECK-NEXT:    [[SHAPE:%.*]] = apply [[M]](%0)
+// CHECK-NEXT:    [[B:%.*]] = begin_borrow [[SHAPE]]
+// CHECK-NEXT:    [[COPY:%.*]] = explicit_copy_value [[B]]
+// CHECK-NEXT:    end_borrow [[B]]
+// CHECK-NEXT:    destroy_value [[SHAPE]]
+// CHECK-NEXT:    return [[COPY]]
+// CHECK-NEXT:  } // end sil function 'basic_access_of_loadable'
+@_manualOwnership
+@_silgen_name("basic_access_of_loadable")
+func basic_access_of_loadable(_ t: TriangleClass) -> ShapeClass {
+  return copy t.shape
+}