ManualOwnership: avoid implicit SILMoveOnlyWrappedType's

These wrappers are detected by the move checking passes,
to support the implicit no-implicit-copy check for
parameters with ownership specifiers.

ManualOwnership already does this kind of checking, and the
two passes can interfere with each other, such as intercepting
diagnostics that are meant to be emitted by ManualOwnership.

Author: kavon

lib/SILGen/SILGenBuilder.cpp

@@ -537,6 +537,10 @@ static ManagedValue createInputFunctionArgument(
       isNoImplicitCopy |= pd->getSpecifier() == ParamSpecifier::Borrowing;
       isNoImplicitCopy |= pd->getSpecifier() == ParamSpecifier::Consuming;
     }
+
+    // ManualOwnership checks everything for implicit copies already.
+    if (B.hasManualOwnershipAttr())
+      isNoImplicitCopy = false;
   }
   if (isNoImplicitCopy)
     arg->setNoImplicitCopy(isNoImplicitCopy);

lib/SILGen/SILGenDecl.cpp

@@ -561,7 +561,11 @@ class LocalVariableInitialization : public SingleBufferInitialization {
 
     // If our instance type is not already @moveOnly wrapped, and it's a
     // no-implicit-copy parameter, wrap it.
-    if (!isNoImplicitCopy && instanceType->isCopyable()) {
+    //
+    // Unless the function is using ManualOwnership, which checks for
+    // no-implicit-copies using a different mechanism.
+    if (!isNoImplicitCopy && instanceType->isCopyable() &&
+        !SGF.B.hasManualOwnershipAttr()) {
       if (auto *pd = dyn_cast<ParamDecl>(decl)) {
         isNoImplicitCopy = pd->isNoImplicitCopy();
         isNoImplicitCopy |= pd->getSpecifier() == ParamSpecifier::Consuming;

lib/SILGen/SILGenPattern.cpp

@@ -1405,7 +1405,10 @@ void PatternMatchEmission::bindBorrow(Pattern *pattern, VarDecl *var,
   auto bindValue = value.asBorrowedOperand2(SGF, pattern).getFinalManagedValue();
 
   // Borrow bindings of copyable type should still be no-implicit-copy.
-  if (!bindValue.getType().isMoveOnly()) {
+  //
+  // If we're relying on ManualOwnership for explicit-copies enforcement,
+  // we don't need the MoveOnlyWrapper.
+  if (!bindValue.getType().isMoveOnly() && !SGF.B.hasManualOwnershipAttr()) {
     if (bindValue.getType().isAddress()) {
       bindValue = ManagedValue::forBorrowedAddressRValue(
         SGF.B.createCopyableToMoveOnlyWrapperAddr(pattern, bindValue.getValue()));

lib/SILGen/SILGenProlog.cpp

@@ -793,6 +793,10 @@ class ArgumentInitHelper {
         }
       }
     }
+    // If we're relying on ManualOwnership for explicit-copies enforcement,
+    // we don't need @noImplicitCopy / MoveOnlyWrapper.
+    if (SGF.B.hasManualOwnershipAttr())
+      isNoImplicitCopy = false;
 
     // If we have a no implicit copy argument and the argument is trivial,
     // we need to use copyable to move only to convert it to its move only
@@ -1216,8 +1220,9 @@ static void emitCaptureArguments(SILGenFunction &SGF,
   SILType ty = lowering.getLoweredType();
 
   bool isNoImplicitCopy;
-  
-  if (ty.isTrivial(SGF.F) || ty.isMoveOnly()) {
+
+  if (ty.isTrivial(SGF.F) || ty.isMoveOnly() ||
+      SGF.B.hasManualOwnershipAttr()) {
     isNoImplicitCopy = false;
   } else if (VD->isNoImplicitCopy()) {
     isNoImplicitCopy = true;

test/SIL/manual_ownership.swift

@@ -63,6 +63,26 @@ public func basic_return3() -> Triangle {
   return Triangle()
 }
 
+@_manualOwnership
+func return_borrowed(_ t: borrowing Triangle) -> Triangle {
+  return t // expected-error {{ownership of 't' is demanded and cannot not be consumed}}
+}
+@_manualOwnership
+func return_borrowed_fixed(_ t: borrowing Triangle) -> Triangle {
+  return copy t
+}
+
+// FIXME: copy propagation isn't able to simplify this. No copy should be required.
+@_manualOwnership
+func return_consumingParam(_ t: consuming Triangle) -> Triangle { // expected-error {{accessing 't' produces a copy of it}}
+  return t
+}
+
+@_manualOwnership
+func return_owned(_ t: __owned Triangle) -> Triangle {
+  return t
+}
+
 @_manualOwnership
 func reassign_with_lets() -> Triangle {
   let x = Triangle()

test/SILGen/manual_ownership.swift

@@ -26,3 +26,49 @@ class TriangleClass {
 func basic_access_of_loadable(_ t: TriangleClass) -> ShapeClass {
   return copy t.shape
 }
+
+// CHECK-LABEL: sil {{.*}} [manual_ownership] [ossa] @return_borrowed
+// CHECK:       bb0(%0 : @guaranteed $TriangleClass):
+// CHECK-NEXT:     debug_value %0
+// CHECK-NEXT:     [[IMPL_COPY:%.*]] = copy_value %0
+// CHECK-NEXT:     return [[IMPL_COPY]]
+// CHECK-NEXT:  } // end sil function 'return_borrowed'
+@_manualOwnership
+@_silgen_name("return_borrowed")
+func return_borrowed(_ t: borrowing TriangleClass) -> TriangleClass {
+  return t
+}
+
+// CHECK-LABEL: sil {{.*}} [manual_ownership] [ossa] @return_consumingParam
+// CHECK:       bb0(%0 : @_eagerMove @owned $TriangleClass):
+// CHECK-NEXT:     alloc_box ${ var TriangleClass }, var, name "t"
+// CHECK-NEXT:     begin_borrow [var_decl]
+// CHECK-NEXT:     [[ADDR:%.*]] = project_box {{.*}}, 0
+// CHECK-NEXT:     store %0 to [init] [[ADDR]]
+// CHECK-NEXT:     [[ACCESS:%.*]] = begin_access [read] [unknown] [[ADDR]]
+// CHECK-NEXT:     [[IMPL_COPY:%.*]] = load [copy] [[ACCESS]]
+// CHECK-NEXT:     end_access [[ACCESS]]
+// CHECK-NEXT:     end_borrow
+// CHECK-NEXT:     destroy_value
+// CHECK-NEXT:     return [[IMPL_COPY]]
+// CHECK-NEXT:  } // end sil function 'return_consumingParam'
+@_manualOwnership
+@_silgen_name("return_consumingParam")
+func return_consumingParam(_ t: consuming TriangleClass) -> TriangleClass {
+  return t
+}
+
+// CHECK-LABEL: sil {{.*}} [manual_ownership] [ossa] @return_owned
+// CHECK:       bb0(%0 : @owned $TriangleClass):
+// CHECK-NEXT:     debug_value %0
+// CHECK-NEXT:     [[BORROW:%.*]] = begin_borrow %0
+// CHECK-NEXT:     [[IMPL_COPY:%.*]] = copy_value [[BORROW]]
+// CHECK-NEXT:     end_borrow [[BORROW]]
+// CHECK-NEXT:     destroy_value %0
+// CHECK-NEXT:     return [[IMPL_COPY]]
+// CHECK-NEXT:  } // end sil function 'return_owned'
+@_manualOwnership
+@_silgen_name("return_owned")
+func return_owned(_ t: __owned TriangleClass) -> TriangleClass {
+  return t
+}