Fix lifetime_dependence tests for trivial dependence.

To allow enforcement of trivial borrows.

Author: atrick

test/SIL/implicit_lifetime_dependence.swift

@@ -7,6 +7,14 @@
 // REQUIRES: swift_feature_LifetimeDependence
 // REQUIRES: swift_feature_LifetimeDependenceDiagnoseTrivial
 
+@_unsafeNonescapableResult
+@lifetime(source)
+func unsafeLifetime<T: ~Copyable & ~Escapable, U: ~Copyable & ~Escapable>(
+  dependent: consuming T, dependsOn source: borrowing U)
+  -> T {
+  dependent
+}
+
 struct BufferView : ~Escapable {
   let ptr: UnsafeRawBufferPointer
   let c: Int
@@ -136,6 +144,7 @@ struct GenericBufferView<Element> : ~Escapable {
   let count: Int
 
 // CHECK-LABEL: sil hidden @$s28implicit_lifetime_dependence17GenericBufferViewV11baseAddress5countACyxGSV_SitcfC : $@convention(method) <Element> (UnsafeRawPointer, Int, @thin GenericBufferView<Element>.Type) -> @lifetime(borrow 0) @owned GenericBufferView<Element> {
+  @lifetime(borrow baseAddress)
   init<Storage>(baseAddress: Pointer,
                 count: Int,
                 dependsOn: borrowing Storage) {
@@ -162,10 +171,13 @@ struct GenericBufferView<Element> : ~Escapable {
 // CHECK: sil hidden @$s28implicit_lifetime_dependence17GenericBufferViewVyACyxGAA9FakeRangeVySVGcig : $@convention(method) <Element> (FakeRange<UnsafeRawPointer>, @guaranteed GenericBufferView<Element>) -> @lifetime(copy 1) @owned GenericBufferView<Element> {
   subscript(bounds: FakeRange<Pointer>) -> Self {
     get {
-      GenericBufferView(
-        baseAddress: UnsafeRawPointer(bounds.lowerBound),
+      let pointer = UnsafeRawPointer(bounds.lowerBound)
+      let result = GenericBufferView(
+        baseAddress: pointer,
         count: bounds.upperBound.distance(to:bounds.lowerBound) / MemoryLayout<Element>.stride
       )
+      // assuming that bounds is within self
+      return unsafeLifetime(dependent: result, dependsOn: self)
     }
   }
 }

test/SILOptimizer/lifetime_dependence/lifetime_dependence_insertion.swift

@@ -58,7 +58,8 @@ func bv_borrow_var(p: UnsafeRawPointer, i: Int) {
 // CHECK: apply %{{.*}}<UnsafePointer<Int>, UnsafeRawPointer>([[RAW:%.*]], %{{.*}}) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : _Pointer, τ_0_1 : _Pointer> (@in_guaranteed τ_0_0) -> @out τ_0_1
 // CHECK: [[RAW:%.*]] = load [trivial] %6 : $*UnsafeRawPointer
 // CHECK: [[BV:%.*]] = apply %13([[RAW]], {{.*}}) : $@convention(method) (UnsafeRawPointer, Int, @thin BV.Type) -> @lifetime(borrow 0) @owned BV
-// CHECK: return [[BV]] : $BV
+// CHECK: [[MD:%.*]] = mark_dependence [unresolved] [[BV]] : $BV on %0 : $UnsafePointer<Int>
+// CHECK: return [[MD]] : $BV
 // CHECK-LABEL: } // end sil function '$s4test18bv_pointer_convert1pAA2BVVSPySiG_tF'
 @lifetime(borrow p)
 func bv_pointer_convert(p: UnsafePointer<Int>) -> BV {

test/SILOptimizer/lifetime_dependence/lifetime_dependence_mutate.swift

@@ -2,6 +2,7 @@
 // RUN:   -o /dev/null \
 // RUN:   -verify \
 // RUN:   -sil-verify-all \
+// RUN:   -disable-access-control \
 // RUN:   -module-name test \
 // RUN:   -enable-experimental-feature LifetimeDependence \
 // RUN:   -enable-experimental-feature LifetimeDependenceDiagnoseTrivial
@@ -59,7 +60,8 @@ extension Array where Element == Int {
   mutating func mutspan() -> /* dependsOn(scoped self) */ MutableSpan {
     /* not the real implementation */
     let p = self.withUnsafeMutableBufferPointer { $0.baseAddress! }
-    return MutableSpan(p, count)
+    let span = MutableSpan(p, count)
+    return _overrideLifetime(span, borrowing: self)
   }
 }
 

test/SILOptimizer/lifetime_dependence/lifetime_dependence_scope_fixup.swift

@@ -159,14 +159,15 @@ func test6(_ a: Array<Int>) {
 // CHECK-LABEL: sil hidden @$s31lifetime_dependence_scope_fixup5test7yySWF : $@convention(thin) (UnsafeRawBufferPointer) -> () {
 // CHECK:   [[CONT:%.*]] = alloc_stack [var_decl] $View
 // function_ref View.init(_:_:)
-// CHECK:   [[VIEW1:%.*]] = apply %{{.*}}(%0, %{{.*}}, %{{.*}}) : $@convention(method) (UnsafeRawBufferPointer, Int, @thin View.Type) -> @lifetime(borrow 0) @owned View // users: %14, %9, %12, %8
+// CHECK:   [[VIEW1:%.*]] = apply %{{.*}}(%0, %{{.*}}, %{{.*}}) : $@convention(method) (UnsafeRawBufferPointer, Int, @thin View.Type) -> @lifetime(borrow 0) @owned View
+// CHECK:   [[MD1:%.*]] = mark_dependence [nonescaping] %{{.*}} : $View on %0 : $UnsafeRawBufferPointer
 // CHECK:   [[BA:%.*]] = begin_access [read] [static] [[CONT]] : $*View
 // CHECK:   [[FUNC:%.*]] = function_ref @$s31lifetime_dependence_scope_fixup16getBorrowingViewyAA0G0VADF : $@convention(thin) (@guaranteed View) -> @lifetime(borrow 0) @owned View
-// CHECK:   [[VIEW2:%.*]] = apply [[FUNC]]([[VIEW1]]) : $@convention(thin) (@guaranteed View) -> @lifetime(borrow 0) @owned View
-// CHECK:   [[MDI:%.*]] = mark_dependence [nonescaping] [[VIEW2]] : $View on [[BA]] : $*View
+// CHECK:   [[VIEW2:%.*]] = apply [[FUNC]]([[MD1]]) : $@convention(thin) (@guaranteed View) -> @lifetime(borrow 0) @owned View
+// CHECK:   [[MD2:%.*]] = mark_dependence [nonescaping] [[VIEW2]] : $View on [[BA]] : $*View
 // CHECK:   [[USE:%.*]] = function_ref @$s31lifetime_dependence_scope_fixup3useyyAA4ViewVF : $@convention(thin) (@guaranteed View) -> ()
-// CHECK:   apply [[USE]]([[MDI]]) : $@convention(thin) (@guaranteed View) -> ()
-// CHECK:   release_value [[MDI]] : $View
+// CHECK:   apply [[USE]]([[MD2]]) : $@convention(thin) (@guaranteed View) -> ()
+// CHECK:   release_value [[MD2]] : $View
 // CHECK:   end_access [[BA]] : $*View
 // CHECK-LABEL: } // end sil function '$s31lifetime_dependence_scope_fixup5test7yySWF'
 func test7(_ a: UnsafeRawBufferPointer) {

test/SILOptimizer/lifetime_dependence/lifetime_dependence_util.sil

@@ -133,7 +133,10 @@ entry(%0 : @owned $C, %1 : @owned $D, %2 : @guaranteed $D, %3 : $*D, %4 : $*D):
   %trivial_mark = mark_dependence [nonescaping] %yield_mark : $C on %zero : $Builtin.Int1
   specify_test "lifetime_dependence_scope %trivial_mark"
 // CHECK-LABEL: dependence_scope: lifetime_dependence_scope with: %trivial_mark
-// CHECK-NEXT: Trivial Dependence
+// CHECK-NEXT: Unknown:   %{{.*}} = integer_literal $Builtin.Int1, 0
+// CHECK-NEXT: Dependent: %{{.*}} = mark_dependence [nonescaping]
+// CHECK-NEXT: begin:     %{{.*}} = integer_literal $Builtin.Int1, 0
+// CHECK-NEXT: ends:{{[ ]+$}}
 // CHECK: dependence_scope: lifetime_dependence_scope with: %trivial_mark
 
   %f = ref_element_addr %borrow : $D, #D.object

test/SILOptimizer/lifetime_dependence/semantics.swift

@@ -11,7 +11,6 @@
 // REQUIRES: swift_feature_LifetimeDependenceDiagnoseTrivial
 
 // Lifetime dependence semantics by example.
-
 struct Span<T>: ~Escapable {
   private var base: UnsafePointer<T>
   private var count: Int
@@ -31,7 +30,8 @@ struct Span<T>: ~Escapable {
 
 extension Span {
   consuming func dropFirst() -> Span<T> {
-    let local = Span(base: self.base + 1, count: self.count - 1)
+    let nextPointer = self.base + 1
+    let local = Span(base: nextPointer, count: self.count - 1)
     return unsafeLifetime(dependent: local, dependsOn: self)
   }
 }
@@ -67,11 +67,12 @@ extension Span {
 }
 
 extension Array {
-  // TODO: comment out
-  borrowing func span() -> /* */ Span<Element> {
+  @lifetime(borrow self)
+  borrowing func span() -> Span<Element> {
     /* not the real implementation */
     let p = self.withUnsafeBufferPointer { $0.baseAddress! }
-    return Span(base: p, count: 1)
+    let span = Span(base: p, count: 1)
+    return unsafeLifetime(dependent: span, scope: self)
   }
 }
 
@@ -160,3 +161,16 @@ func testScopedOfInheritedWithLet(_ arg: [Int] ) {
   // expected-note @-1{{it depends on the lifetime of this parent value}}  
   _ = result
 } // expected-note {{this use of the lifetime-dependent value is out of scope}}
+
+// =============================================================================
+// Scoped dependence on trivial values
+// =============================================================================
+
+@lifetime(borrow a)
+func testTrivialScope<T>(a: Array<T>) -> Span<T> {
+  let p = a.withUnsafeBufferPointer { $0.baseAddress! }
+  return Span(base: p, count: 1)
+  // expected-error @-1{{lifetime-dependent value escapes its scope}}
+  // expected-note  @-3{{it depends on the lifetime of variable 'p'}}
+  // expected-note  @-3{{this use causes the lifetime-dependent value to escape}}
+}