Unit tests for '@'_addressable lifetime dependence.

Author: atrick

test/SILOptimizer/lifetime_dependence/dependence_insertion.sil

@@ -25,6 +25,17 @@ struct NCE: ~Escapable, ~Copyable {
   init()
 }
 
+struct TrivialHolder {
+  var pointer: UnsafeRawPointer
+}
+
+struct Holder {
+  var object: AnyObject
+}
+
+@_addressableForDependencies
+struct AddressableForDeps {}
+
 sil @getPtr : $@convention(thin) () -> @out UnsafeRawPointer
 sil @getSpan : $@convention(thin) (@in_guaranteed AnyObject) -> @lifetime(borrow 0) @out NE
 sil @getInoutSpan : $@convention(thin) (@inout AnyObject) -> @lifetime(borrow 0) @out NCE
@@ -92,3 +103,39 @@ bb0(%0 : $*AnyObject):
   dealloc_stack %1
   return %7
 }
+
+// =============================================================================
+// @_addressable
+// =============================================================================
+
+sil hidden [ossa] @addressableArg : $@convention(method) (@in_guaranteed Holder) -> @lifetime(borrow address 0) @owned NE {
+
+sil hidden [ossa] @addressableTuple : $@convention(method) (@in_guaranteed (Holder, Holder)) -> @lifetime(borrow address 0) @owned NE {
+
+sil hidden [ossa] @testAddressableArg : $@convention(thin) (Holder) -> Int {
+bb0(%0 : $Holder):
+  debug_value %0, let, name "arg", argno 1
+  %2 = alloc_stack $Holder
+  store %0 to [trivial] %2
+  %4 = function_ref @addressableArg : $@convention(thin) (@in_guaranteed Holder) -> @lifetime(borrow address 0) @owned NE
+  %5 = apply %4(%2) : $@convention(thin) (@in_guaranteed Holder) -> @lifetime(borrow address 0) @owned NE
+  dealloc_stack %2
+  %7 = move_value [var_decl] %5
+  debug_value %7, let, name "ne"
+  %9 = alloc_stack $Int
+  %10 = begin_borrow %7
+  %11 = struct_extract %10, #NE.p
+  %12 = metatype $@thin Int.Type
+  %13 = metatype $@thick Int.Type
+
+  %14 = function_ref @$sSV4load14fromByteOffset2asxSi_xmtlFfA_ : $@convention(thin) <τ_0_0> () -> Int
+  %15 = apply %14<Int>() : $@convention(thin) <τ_0_0> () -> Int
+
+  %16 = function_ref @$sSV4load14fromByteOffset2asxSi_xmtlF : $@convention(method) <τ_0_0> (Int, @thick τ_0_0.Type, UnsafeRawPointer) -> @out τ_0_0
+  %17 = apply %16<Int>(%9, %15, %13, %11) : $@convention(method) <τ_0_0> (Int, @thick τ_0_0.Type, UnsafeRawPointer) -> @out τ_0_0
+  end_borrow %10
+  %19 = load [trivial] %9
+  dealloc_stack %9
+  destroy_value %7
+  return %19
+}

test/SILOptimizer/lifetime_dependence/semantics.swift

@@ -3,12 +3,17 @@
 // RUN:   -verify \
 // RUN:   -sil-verify-all \
 // RUN:   -module-name test \
+// RUN:   -enable-builtin-module \
 // RUN:   -enable-experimental-feature LifetimeDependence \
 // RUN:   -enable-experimental-feature AddressableParameters \
 // RUN:   -enable-experimental-feature AddressableTypes
 
 // REQUIRES: swift_in_compiler
 // REQUIRES: swift_feature_LifetimeDependence
+// REQUIRES: swift_feature_AddressableParameters
+// REQUIRES: swift_feature_AddressableTypes
+
+import Builtin
 
 @_unsafeNonescapableResult
 @_transparent
@@ -69,6 +74,12 @@ public struct Span<T>: ~Escapable {
     self.base = base
     self.count = count
   }
+
+  public subscript(_ position: Int) -> T {
+    unsafeAddress {
+      return base!.advanced(by: position)
+    }
+  }
 }
 
 extension Span {
@@ -131,9 +142,24 @@ struct InnerTrivial {
   }
 }
 
+struct TrivialHolder {
+  var p: UnsafePointer<Int>
+  var pa: UnsafePointer<AddressableInt>
+
+  var addressableInt: AddressableInt { unsafeAddress { pa } }
+
+  @lifetime(borrow self)
+  borrowing func span() -> Span<Int> {
+    Span(base: p, count: 1)
+  }
+}
+
 struct Holder {
   let object: AnyObject
   var p: UnsafePointer<Int>
+  var pa: UnsafePointer<AddressableInt>
+
+  var addressableInt: AddressableInt { unsafeAddress { pa } }
 
   @lifetime(borrow self)
   borrowing func span() -> Span<Int> {
@@ -143,10 +169,11 @@ struct Holder {
 
 @_addressableForDependencies
 struct AddressableInt {
-  let object: AnyObject
+  let value: Int
 
   @lifetime(borrow self)
   borrowing func span() -> Span<Int> {
+    // TODO: we actually want the address of self.value
     let p = UnsafePointer<Int>(Builtin.unprotectedAddressOfBorrow(self))
     let span = Span(base: p, count: 1)
     return _overrideLifetime(span, borrowing: self)
@@ -159,6 +186,7 @@ struct AddressableObject {
 
   @lifetime(borrow self)
   borrowing func span() -> Span<AnyObject> {
+    // TODO: we actually want the address of self.object
     let p = UnsafePointer<AnyObject>(Builtin.unprotectedAddressOfBorrow(self))
     let span = Span(base: p, count: 1)
     return _overrideLifetime(span, borrowing: self)
@@ -506,29 +534,69 @@ func testReturnObjectTemp(outer: Outer) -> Span<Int> {
 // Scoped dependence on addressable parameters
 // =============================================================================
 
+// @_addressableForDependencies supports returning a Span.
 @lifetime(borrow arg)
 func testAddressableInt(arg: AddressableInt) -> Span<Int> {
   arg.span()
 }
 
+// @_addressableForDependencies supports returning a Span.
 @lifetime(borrow arg)
 func testAddressableObject(arg: AddressableObject) -> Span<AnyObject> {
   arg.span()
 }
 
+// Helper: create a dependence on the argument's address.
 @lifetime(borrow arg)
-func borrowAddressHelper(arg: @addressable Holder) -> Span<Int> {
+func dependsOnTrivialAddressHelper(arg: @_addressable TrivialHolder) -> Span<Int> {
   arg.span()
 }
 
+// Helper: create a dependence on the argument's address.
 @lifetime(borrow arg)
-func testNonAddressable(arg: Holder) -> Span<Int> {
-  borrowAddressHelper(arg: arg)
+func dependsOnAddressHelper(arg: @_addressable Holder) -> Span<Int> {
+  arg.span()
 }
 
+/* TODO: requires -enable-address-dependencies
+
+// Non-addressable error returning a Span.
+@lifetime(borrow arg)
+func testTrivialNonAddressable(arg: TrivialHolder) -> Span<Int> {
+  dependsOnTrivialAddressHelper(arg: arg)
+  // todo-error @-1{{lifetime-dependent value escapes its scope}
+  // todo-note  @-3{{it depends on the lifetime of variable 'arg'}}
+} // todo-note  {{this use causes the lifetime-dependent value to escape}}
+
+// Non-addressable error returning a Span.
+@lifetime(borrow arg)
+func testNonAddressable(arg: Holder) -> Span<Int> {
+  dependsOnAddressHelper(arg: arg)
+  // todo-error @-1{{lifetime-dependent value escapes its scope}
+  // todo-note  @-3{{it depends on the lifetime of variable 'arg'}}
+} // todo-note  {{this use causes the lifetime-dependent value to escape}}
+*/
+
 /* TODO: rdar://145872854 (SILGen: @addressable inout arguments are copied)
 @lifetime(borrow arg)
 func test(arg: inout AddressableInt) -> Span<Int> {
   arg.span()
 }
+
+// unsafeAddress generates an addressable value with a local scope.
+@lifetime(borrow arg)
+func testBorrowedAddressableInt(arg: Holder) -> Int {
+  let span = arg.addressableInt.span()
+  return span[0]
+}
+
+// unsafeAddress generates an addressable value.
+// Error returning a dependence on its local scope.
+@lifetime(borrow arg)
+func testBorrowedAddressableIntReturn(arg: Holder) -> Span<Int> {
+  arg.addressableInt.span()
+  // todo-error @-1{{lifetime-dependent value escapes its scope}
+  // todo-note  @-2{{it depends on the lifetime of this parent value}}
+} // todo-note  {{this use causes the lifetime-dependent value to escape}}
+
 */