Fix LifetimeDependenceDiagnostics: scoped dependence on a copy

Diagnose a scoped dependence on an argument that inherits its lifetime as an
error:

@Lifetime(borrow arg)
func reborrowSpan<T>(_ arg: Span<T>) -> Span<T> { arg }

@Lifetime(copy span)
public func testBorrowInheritedArg<T>(_ span: Span<T>) -> Span<T> {
  reborrowSpan(span) // expected-error {{lifetime-dependent value escapes its scope}}
}

Fixes: rdar://146319009 ([nonescapable] enforce borrow constraint narrowing of inherited lifetime)

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -202,12 +202,23 @@ private struct DiagnoseDependence {
     // Check that the parameter dependence for this result is the same
     // as the current dependence scope.
     if let arg = dependence.scope.parentValue as? FunctionArgument,
-       function.argumentConventions[resultDependsOn: arg.index] != nil {
-      // The returned value depends on a lifetime that is inherited or
-      // borrowed in the caller. The lifetime of the argument value
-      // itself is irrelevant here.
-      log("  has dependent function result")
-      return .continueWalk
+       let argDep = function.argumentConventions[resultDependsOn: arg.index] {
+      switch argDep {
+      case .inherit:
+        if dependence.markDepInst != nil {
+          // A mark_dependence represents a "borrow" scope. A local borrow scope cannot inherit the caller's dependence
+          // because the borrow scope depends on the argument value itself, while the caller allows the result to depend
+          // on a value that the argument was copied from.
+          break
+        }
+        fallthrough
+      case .scope:
+        // The returned value depends on a lifetime that is inherited or
+        // borrowed in the caller. The lifetime of the argument value
+        // itself is irrelevant here.
+        log("  has dependent function result")
+        return .continueWalk
+      }
     }
     return .abortWalk
   }

test/SILOptimizer/lifetime_dependence/semantics.swift

@@ -241,6 +241,22 @@ func copySpan<T>(_ arg: Span<T>) -> /* */ Span<T> { arg }
 @lifetime(borrow arg)
 func reborrowSpan<T>(_ arg: Span<T>) -> Span<T> { arg }
 
+@lifetime(&arg)
+func reborrowGenericInout<T: ~Escapable>(_ arg: inout T) -> T { arg }
+
+@lifetime(copy arg)
+func inheritSpan<T>(_ arg: Span<T>) -> Span<T> { arg }
+
+@lifetime(copy arg)
+func inheritGeneric<T: ~Escapable>(_ arg: consuming T) -> T { arg }
+
+public struct NE: ~Escapable {}
+
+@lifetime(&ne)
+func borrowNE<T: ~Escapable>(ne: inout T) -> T {
+  ne
+}
+
 // =============================================================================
 // Initialization
 // =============================================================================
@@ -340,6 +356,30 @@ func testInheritedCopyVar(_ arg: [Int] ) {
   parse(result) // ✅ Safe: within lifetime of 'a'
 }
 
+@lifetime(copy span)
+public func testBorrowInheritedArg<T>(_ span: Span<T>) -> Span<T> {
+  reborrowSpan(span) // expected-error {{lifetime-dependent value escapes its scope}}
+  // expected-note @-2{{it depends on the lifetime of argument 'span'}}
+} // expected-note {{this use causes the lifetime-dependent value to escape}}
+
+@lifetime(copy t)
+public func testBorrowInheritedInoutArg<T: ~Escapable>(_ t: inout T) -> T {
+  // expected-error @-1{{lifetime-dependent variable 't' escapes its scope}}
+  // expected-note @-2{{it depends on the lifetime of argument 't'}}
+  reborrowGenericInout(&t)
+  // expected-note @-1{{this use causes the lifetime-dependent value to escape}}
+}
+
+@lifetime(copy span)
+public func testCopyInheritedArg<T>(_ span: Span<T>) -> Span<T> {
+  inheritSpan(span)
+}
+
+@lifetime(copy t)
+public func testCopyInheritedGenericArg<T: ~Escapable>(_ t: consuming T) -> T {
+  inheritGeneric(t)
+}
+
 // =============================================================================
 // Scoped dependence on inherited dependence
 // =============================================================================
@@ -364,6 +404,23 @@ func testScopedOfInheritedWithLet(_ arg: [Int] ) {
   _ = result
 } // expected-note {{this use of the lifetime-dependent value is out of scope}}
 
+// Test a scoped dependence on an inherited inout argument.
+//
+// If testScopedOfInheritedWithLet is not an error, then its result can outlive its borrowed value:
+//  let ne1 = NE()
+//  var ne2 = ne1
+//  let dep = foo(ne: &ne2)
+//  _ = consume ne2
+//  _ = dep
+//
+@lifetime(copy ne)
+public func testScopedOfInheritedInout<T: ~Escapable>(ne: inout T) -> T {
+  // expected-error @-1{{lifetime-dependent variable 'ne' escapes its scope}}
+  // expected-note  @-2{{it depends on the lifetime of argument 'ne'}}
+  borrowNE(ne: &ne)
+  // expected-note  @-1{{this use causes the lifetime-dependent value to escape}}
+}
+
 // =============================================================================
 // Scoped dependence on trivial values
 // =============================================================================

test/SILOptimizer/lifetime_dependence/verify_diagnostics.sil

@@ -49,6 +49,7 @@ sil @useA : $@convention(thin) (A) -> ()
 sil @makeNE : $@convention(thin) () -> @lifetime(immortal) @owned NE
 sil @makeNEObject : $@convention(thin) () -> @lifetime(immortal) @owned NEObject
 sil @useNE : $@convention(thin) (@guaranteed NE) -> ()
+sil @reborrowNE : $@convention(thin) (@guaranteed NE) -> @lifetime(borrow 0) @owned NE
 
 sil @initHolder : $@convention(thin) () -> @out Holder
 sil @getNE : $@convention(thin) (@in_guaranteed Holder) -> @lifetime(borrow address_for_deps 0) @owned NE
@@ -167,6 +168,26 @@ bb0:
   return %12
 }
 
+// Test that a borrowed dependency cannot inherit a copied dependency.
+sil [ossa] @testReborrow : $@convention(thin) (@guaranteed NE) -> @lifetime(copy 0) @owned NE {
+bb0(%0 : @guaranteed $NE):
+  debug_value %0, let, name "ne", argno 1
+  %2 = function_ref @reborrowNE : $@convention(thin) (@guaranteed NE) -> @lifetime(borrow 0) @owned NE
+  %3 = apply %2(%0) : $@convention(thin) (@guaranteed NE) -> @lifetime(borrow 0) @owned NE
+  // expected-error @-1{{lifetime-dependent value escapes its scope}}
+  %4 = mark_dependence [unresolved] %3 on %0
+  return %4 // expected-note {{this use causes the lifetime-dependent value to escape}}
+}
+
+sil [ossa] @testBorrowValue : $@convention(thin) (@guaranteed NE) -> @lifetime(copy 0) @owned NE {
+bb0(%0 : @guaranteed $NE):
+  %2 = function_ref @reborrowNE : $@convention(thin) (@guaranteed NE) -> @lifetime(borrow 0) @owned NE
+  %3 = apply %2(%0) : $@convention(thin) (@guaranteed NE) -> @lifetime(borrow 0) @owned NE
+  // expected-error @-1{{lifetime-dependent value escapes its scope}}
+  %4 = mark_dependence [unresolved] %3 on %0
+  return %4 // expected-note {{this use causes the lifetime-dependent value to escape}}
+}
+
 // Test a borrowed dependency on an address
 sil [ossa] @testBorrowAddress : $@convention(thin) <T where T : ~Escapable> (@thick T.Type) -> @lifetime(immortal) @out T {
 bb0(%0 : $*T, %1 : $@thick T.Type):