Lifetime dependence unit tests.

Author: atrick

test/SILOptimizer/argument_conventions.sil

@@ -3,6 +3,8 @@
 // RUN:   -enable-experimental-feature NonescapableTypes \
 // RUN:   2>&1 | %FileCheck %s
 
+// REQUIRES: swift_in_compiler
+
 import Builtin
 
 class C {}

test/SILOptimizer/argument_conventions.swift

@@ -0,0 +1,44 @@
+// RUN: %target-swift-frontend %s -emit-sil \
+// RUN:   -o /dev/null \
+// RUN:   -verify \
+// RUN:   -sil-verify-all \
+// RUN:   -module-name test \
+// RUN:   -disable-experimental-parser-round-trip \
+// RUN:   -enable-experimental-feature NonescapableTypes \
+// RUN:   -Xllvm -enable-lifetime-dependence-diagnostics
+
+// REQUIRES: swift_in_compiler
+
+@_nonescapable
+struct BV {
+  let p: UnsafeRawPointer
+  let c: Int
+
+  public var isEmpty: Bool { c == 0 }
+
+  @_unsafeNonescapableResult
+  init(_ p: UnsafeRawPointer, _ c: Int) {
+    self.p = p
+    self.c = c
+  }
+}
+
+struct NC : ~Copyable {
+  let p: UnsafeRawPointer
+  let c: Int
+
+  // Requires a borrow.
+  borrowing func getBV() -> _borrow(self) BV {
+    BV(p, c)
+  }
+}
+
+// Propagate a borrow.
+func bv_get_borrow(container: borrowing NC) -> _borrow(container) BV {
+  container.getBV()
+}
+
+// Copy a borrow.
+func bv_get_copy(container: borrowing NC) -> _copy(container) BV {
+  return container.getBV()
+}

test/SILOptimizer/lifetime_dependence_borrow.swift

@@ -0,0 +1,37 @@
+// RUN: %target-swift-frontend %s -emit-sil \
+// RUN:   -o /dev/null \
+// RUN:   -verify \
+// RUN:   -sil-verify-all \
+// RUN:   -module-name test \
+// RUN:   -disable-experimental-parser-round-trip \
+// RUN:   -enable-experimental-feature NonescapableTypes \
+// RUN:   -Xllvm -enable-lifetime-dependence-diagnostics
+
+// REQUIRES: swift_in_compiler
+
+@_nonescapable
+struct BV {
+  let p: UnsafeRawPointer
+  let i: Int
+
+  @_unsafeNonescapableResult
+  init(_ p: UnsafeRawPointer, _ i: Int) {
+    self.p = p
+    self.i = i
+  }
+}
+
+struct NC : ~Copyable {
+  let p: UnsafeRawPointer
+  let i: Int
+
+  borrowing func getBV() -> _borrow(self) BV {
+    BV(p, i)
+  }
+}
+
+func bv_get_consume(container: consuming NC) -> BV {
+  return container.getBV() // expected-error {{lifetime-dependent value escapes its scope}}
+    // expected-note @-1{{it depends on this scoped access to variable 'container'}}
+    // expected-note @-2{{this use causes the lifetime-dependent value to escape}}
+}

test/SILOptimizer/lifetime_dependence_borrow_fail.swift

@@ -0,0 +1,31 @@
+// RUN: %target-swift-frontend %s -emit-sil \
+// RUN:   -sil-verify-all \
+// RUN:   -module-name test \
+// RUN:   -disable-experimental-parser-round-trip \
+// RUN:   -enable-experimental-feature NonescapableTypes \
+// RUN:   -Xllvm -enable-lifetime-dependence-diagnostics \
+// RUN:   2>&1 | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+
+@_nonescapable
+struct BV {
+  let p: UnsafeRawPointer
+  let c: Int
+}
+
+func bv_copy(_ bv: borrowing BV) -> _copy(bv) BV {
+  copy bv
+}
+
+// Diagnostics resolves mark_dependence [nonescaping].
+//
+// CHECK-LABEL: sil hidden @$s4test14bv_borrow_copy0B0AA2BVVAE_tF : $@convention(thin) (@guaranteed BV) -> _inherit(1) @owned BV {
+// CHECK: bb0(%0 : @noImplicitCopy $BV):
+// CHECK:   [[R:%.*]] = apply %{{.*}}(%0) : $@convention(thin) (@guaranteed BV) -> _inherit(1) @owned BV
+// CHECK:   [[MD:%.*]] = mark_dependence [nonescaping] [[R]] : $BV on %0 : $BV
+// CHECK:   return [[MD]] : $BV
+// CHECK-LABEL: } // end sil function '$s4test14bv_borrow_copy0B0AA2BVVAE_tF'
+func bv_borrow_copy(bv: borrowing BV) -> _borrow(bv) BV {
+  bv_copy(bv) 
+}

test/SILOptimizer/lifetime_dependence_diagnostics.swift

@@ -0,0 +1,53 @@
+// RUN: %target-swift-frontend %s -emit-sil \
+// RUN:   -o /dev/null \
+// RUN:   -verify \
+// RUN:   -sil-verify-all \
+// RUN:   -module-name test \
+// RUN:   -disable-experimental-parser-round-trip \
+// RUN:   -enable-experimental-feature NonescapableTypes \
+// RUN:   -enable-experimental-feature NoncopyableGenerics \
+// RUN:   -Xllvm -enable-lifetime-dependence-diagnostics \
+// RUN:   -parse-stdlib -module-name Swift
+
+// REQUIRES: swift_in_compiler
+
+@_marker public protocol Escapable {}
+
+@_silgen_name("imagineInt64")
+func imagineInt64() -> Builtin.Int64
+
+protocol P {
+  associatedtype E: ~Escapable
+  borrowing func getE() -> _borrow(self) E
+}
+
+extension P {
+  borrowing func getDefault() -> _borrow(self) E {
+    return getE()
+  }
+}
+
+public struct Bits {
+  var i = imagineInt64()
+}
+
+struct PBits: P {
+  func getE() -> Bits { return Bits() }
+}
+
+public func pbits_ret_concerete() -> Bits {
+  let pbits = PBits()
+  return pbits.getDefault()
+}
+
+public func consume_indirect<NE: ~Escapable>(ne: consuming NE) -> _consume(ne) NE {
+  return ne
+}
+
+public func copy_indirect<NE: ~Escapable>(ne: borrowing NE) -> _copy(ne) NE {
+  return copy ne
+}
+
+public func copy_inout<NE: ~Escapable>(ne: inout NE) -> _copy(ne) NE {
+  return copy ne
+}

test/SILOptimizer/lifetime_dependence_generic.swift

@@ -0,0 +1,37 @@
+// RUN: %target-swift-frontend %s -emit-sil \
+// RUN:   -o /dev/null \
+// RUN:   -verify \
+// RUN:   -sil-verify-all \
+// RUN:   -module-name test \
+// RUN:   -disable-experimental-parser-round-trip \
+// RUN:   -enable-experimental-feature NonescapableTypes \
+// RUN:   -enable-experimental-feature NoncopyableGenerics \
+// RUN:   -Xllvm -enable-lifetime-dependence-diagnostics \
+// RUN:   -parse-stdlib -module-name Swift
+
+// REQUIRES: swift_in_compiler
+
+@_marker public protocol Escapable {}
+
+protocol P {
+  associatedtype E: ~Escapable
+  borrowing func getE() -> _borrow(self) E
+}
+
+extension P {
+  borrowing func getDefault() -> _borrow(self) E {
+    return getE()
+  }
+}
+
+public struct View: ~Escapable {}
+
+public struct PView: P {
+  borrowing func getE() -> _borrow(self) View { return View() }
+}
+
+public func pview_ret_concrete(pview: consuming PView) -> _consume(pview) View {
+  return pview.getDefault() // expected-error {{lifetime-dependent value escapes its scope}}
+  // expected-note @-1 {{it depends on this scoped access to variable 'pview'}}
+  // expected-note @-2 {{this use of the lifetime-dependent value is out of scope}}
+}

test/SILOptimizer/lifetime_dependence_generic_fail.swift

@@ -0,0 +1,39 @@
+// RUN: %target-swift-frontend %s -emit-sil \
+// RUN:   -o /dev/null \
+// RUN:   -verify \
+// RUN:   -sil-verify-all \
+// RUN:   -module-name test \
+// RUN:   -disable-experimental-parser-round-trip \
+// RUN:   -enable-experimental-feature NonescapableTypes \
+// RUN:   -Xllvm -enable-lifetime-dependence-diagnostics
+
+// REQUIRES: swift_in_compiler
+
+@_nonescapable
+struct BV {
+  let p: UnsafeRawPointer
+  let i: Int
+
+  @_unsafeNonescapableResult
+  init(_ p: UnsafeRawPointer, _ i: Int) {
+    self.p = p
+    self.i = i
+  }
+
+  consuming func derive() -> _consume(self) BV {
+    // Technically, this "new" view does not depend on the 'view' argument.
+    // This unsafely creates a new view with no dependence.
+    return BV(self.p, self.i)
+  }
+}
+
+@_nonescapable
+struct NE {
+  var bv: BV
+
+  // Test lifetime inheritance through initialization.
+  init(_ bv: consuming BV) -> _consume(bv) Self {
+    self.bv = bv
+    return self
+  }
+}

test/SILOptimizer/lifetime_dependence_inherit.swift

@@ -0,0 +1,45 @@
+// RUN: %target-swift-frontend %s -emit-sil \
+// RUN:   -o /dev/null \
+// RUN:   -verify \
+// RUN:   -sil-verify-all \
+// RUN:   -module-name test \
+// RUN:   -disable-experimental-parser-round-trip \
+// RUN:   -enable-experimental-feature NonescapableTypes \
+// RUN:   -Xllvm -enable-lifetime-dependence-diagnostics
+
+// REQUIRES: swift_in_compiler
+
+@_nonescapable
+struct BV {
+  let p: UnsafeRawPointer
+  let i: Int
+
+  @_unsafeNonescapableResult
+  init(_ p: UnsafeRawPointer, _ i: Int) {
+    self.p = p
+    self.i = i
+  }
+
+  consuming func derive() -> _consume(self) BV {
+    // Technically, this "new" view does not depend on the 'view' argument.
+    // This unsafely creates a new view with no dependence.
+    return BV(self.p, self.i)
+  }
+}
+
+@_nonescapable
+struct NE {
+  var bv: BV
+
+  init(_ bv: consuming BV) -> _consume(bv) Self {
+    self.bv = bv
+    return self
+  }
+}
+
+func bv_derive_local(bv: consuming BV) -> _consume(bv) BV {
+  let bv2 = BV(bv.p, bv.i)
+  return bv2.derive() // expected-error {{lifetime-dependent value escapes its scope}}
+  // expected-note @-2 {{it depends on the lifetime of variable 'bv2'}}
+  // expected-note @-2 {{this use causes the lifetime-dependent value to escape}}
+}