ManualOwnership: diagnose copies of generics

copy_addr often is `Releasing`, which is `RefCounting | Deallocating`

Author: kavon

lib/SILOptimizer/Mandatory/PerformanceDiagnostics.cpp

@@ -376,12 +376,15 @@ bool PerformanceDiagnostics::visitInst(SILInstruction *inst,
   LocWithParent loc(inst->getLoc().getSourceLoc(), parentLoc);
 
   if (perfConstr == PerformanceConstraints::ManualOwnership) {
-    if (impact == RuntimeEffect::RefCounting) {
+    if (impact & RuntimeEffect::RefCounting) {
       bool shouldDiagnose = false;
       switch (inst->getKind()) {
+      case SILInstructionKind::DestroyAddrInst:
+      case SILInstructionKind::DestroyValueInst:
+        break; // These modify reference counts, but aren't copies.
       case SILInstructionKind::ExplicitCopyAddrInst:
       case SILInstructionKind::ExplicitCopyValueInst:
-        break;
+        break; // Explicitly acknowledged copies are OK.
       case SILInstructionKind::LoadInst: {
         // FIXME: we don't have an `explicit_load` and transparent functions can
         //   end up bringing in a `load [copy]`. A better approach is needed to

test/SIL/manual_ownership.swift

@@ -34,6 +34,14 @@ public class Triangle {
   borrowing func borrowing() {}
 }
 
+// MARK: utilities
+
+func eat(_ t: consuming Triangle) {}
+func use(_ t: borrowing Triangle) {}
+
+func consume_generic<T>(_ t: consuming T) {}
+func borrow_generic<T>(_ t: borrowing T) {}
+
 /// MARK: return statements
 
 @_manualOwnership
@@ -107,12 +115,9 @@ func basic_methods_consuming(_ t1: Triangle) {
 @_manualOwnership
 func basic_methods_consuming_fixed(_ t1: Triangle) {
   let t2 = Triangle()
-  var t3 = Triangle()
-  t3 = Triangle()
 
   (copy t1).consuming()
   (copy t2).consuming()  // FIXME: why is this not propagated?
-  (copy t3).consuming()
 }
 
 func consumingFunc(_ t0: consuming Triangle) {}
@@ -190,6 +195,8 @@ public func basic_loop_nontrivial_values_fixed(_ t: Triangle, _ xs: [Triangle])
 /// MARK: Globals
 let ref_result = [5, 13, 29]
 
+// FIXME: if we had a borrow operator, we could allow people to elide these simple copies that
+//   are present to avoid exclusivity issues. We'd need to start generating read coroutines.
 @_manualOwnership
 func access_global_1() -> Int {
   return ref_result[2] // expected-error {{explicit 'copy' required here}}
@@ -199,3 +206,41 @@ func access_global_1_fixed() -> Int {
 return (copy ref_result)[2]
 }
 
+/// MARK: closures
+
+// FIXME: (1) Closure capture lists need to support the short-hand [copy t] and produce explicit copies.
+//            We also need a better error message for when this is missed for closure captures.
+//        (2) Escaping closures need to be recursively checked by the PerformanceDiagnostics.
+//            We might just need to widen the propagation of [manual_ownership]?
+@_manualOwnership
+func testClosures() -> () -> Triangle  {
+  let t = Triangle()
+  return { [t = copy t] in return t } // expected-error {{explicit 'copy' required here}}
+}
+
+@_manualOwnership
+func testClosures_noescape() -> Triangle  {
+  let t = Triangle()
+  let f = { [t = copy t] in
+    eat(t)  // FIXME: missing required copies
+    eat(t)
+    return t
+  }
+  return f()
+}
+
+/// MARK: generics
+
+@_manualOwnership
+func copy_generic<T>(_ t: T)  {
+  consume_generic(t) // expected-error {{explicit 'copy' required here}}
+  borrow_generic(t)
+  consume_generic(t) // expected-error {{explicit 'copy' required here}}
+}
+
+@_manualOwnership
+func copy_generic_fixed<T>(_ t: T)  {
+  consume_generic(copy t)
+  borrow_generic(t)
+  consume_generic(copy t)
+}