Remove diagnostic: lifetime_dependence_on_bitwise_copyable

Allow lifetime depenendence on types that are BitwiseCopyable & Escapable.

This is unsafe in the sense that the compiler will not diagnose any use of the
dependent value outside of the lexcial scope of the source value. But, in
practice, dependence on an UnsafePointer is often needed. In that case, the
programmer should have already taken responsibility for ensuring the lifetime of the
pointer over all dependent uses. Typically, an unsafe pointer is valid for the
duration of a closure. Lifetime dependence prevents the dependent value from
being returned by the closure, so common usage is safe by default.

Typical example:

func decode(_ bufferRef: Span<Int>) { /*...*/ }

extension UnsafeBufferPointer {
  // The client must ensure the lifetime of the buffer across the invocation of `body`.
  // The client must ensure that no code modifies the buffer during the invocation of `body`.
  func withUnsafeSpan<Result>(_ body: (Span<Element>) throws -> Result) rethrows -> Result {
    // Construct Span using its internal, unsafe API.
    try body(Span(unsafePointer: baseAddress!, count: count))
  }
}

func decodeArrayAsUBP(array: [Int]) {
  array.withUnsafeBufferPointer { buffer in
    buffer.withUnsafeSpan {
      decode($0)
    }
  }
}

In the future, we may add SILGen support for tracking the lexical scope of
BitwiseCopyable values. That would allow them to have the same dependence
behavior as other source values.

Author: atrick

include/swift/AST/DiagnosticsSema.def

@@ -7985,8 +7985,6 @@ ERROR(lifetime_dependence_cannot_infer_ambiguous_candidate, none,
        "expected nil or self as return values in an initializer with "
        "lifetime dependent specifiers",
        ())
- ERROR(lifetime_dependence_on_bitwise_copyable, none,
-       "invalid lifetime dependence on BitwiseCopyable type", ())
  ERROR(lifetime_dependence_cannot_be_applied_to_tuple_elt, none,
        "lifetime dependence specifiers cannot be applied to tuple elements", ())
  ERROR(lifetime_dependence_method_escapable_bitwisecopyable_self, none,

lib/AST/LifetimeDependence.cpp

@@ -207,24 +207,16 @@ LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd) {
                                           Type paramType,
                                           ValueOwnership ownership) {
     auto loc = specifier.getLoc();
-
-    // Diagnose when we have lifetime dependence on a type that is
-    // BitwiseCopyable & Escapable.
-    // ~Escapable types are non-trivial in SIL and we should not raise this
-    // error.
-    // TODO: Diagnose ~Escapable types are always non-trivial in SIL.
-    if (paramType->isEscapable()) {
-      if (isBitwiseCopyable(paramType, mod, ctx)) {
-        diags.diagnose(loc, diag::lifetime_dependence_on_bitwise_copyable);
-        return true;
-      }
-    }
-
     auto parsedLifetimeKind = specifier.getParsedLifetimeDependenceKind();
     auto lifetimeKind =
         getLifetimeDependenceKindFromDecl(parsedLifetimeKind, paramType);
-    bool isCompatible = isLifetimeDependenceCompatibleWithOwnership(
+    bool isCompatible = true;
+    // Lifetime dependence always propagates through temporary BitwiseCopyable
+    // values, even if the dependence is scoped.
+    if (!isBitwiseCopyable(paramType, mod, ctx)) {
+      isCompatible = isLifetimeDependenceCompatibleWithOwnership(
         lifetimeKind, ownership, afd);
+    }
     if (parsedLifetimeKind == ParsedLifetimeDependenceKind::Scope &&
         !isCompatible) {
       diags.diagnose(

test/ModuleInterface/Inputs/lifetime_dependence.swift

@@ -1,8 +1,7 @@
 public struct AnotherView : ~Escapable {
   @usableFromInline let _ptr: UnsafeRawBufferPointer
   @usableFromInline let _count: Int
-  @_unsafeNonescapableResult
-  internal init(_ ptr: UnsafeRawBufferPointer, _ count: Int) {
+  internal init(_ ptr: UnsafeRawBufferPointer, _ count: Int) -> dependsOn(ptr) Self {
     self._ptr = ptr
     self._count = count
   }
@@ -11,9 +10,8 @@ public struct AnotherView : ~Escapable {
 public struct BufferView : ~Escapable {
   @usableFromInline let _ptr: UnsafeRawBufferPointer
   @usableFromInline let _count: Int
-  @_unsafeNonescapableResult
   @usableFromInline 
-  internal init(_ ptr: UnsafeRawBufferPointer, _ count: Int) {
+  internal init(_ ptr: UnsafeRawBufferPointer, _ count: Int) -> dependsOn(ptr) Self  {
     self._ptr = ptr
     self._count = count
   }

test/Parse/explicit_lifetime_dependence_specifiers.swift

@@ -5,10 +5,10 @@ import Builtin
 
 struct BufferView : ~Escapable {
   let ptr: UnsafeRawBufferPointer
-  @_unsafeNonescapableResult
-  init(_ ptr: UnsafeRawBufferPointer) {
+  init(_ ptr: UnsafeRawBufferPointer) -> dependsOn(ptr) Self {
     self.ptr = ptr
   }
+  // TODO:  -> dependsOn(ptr) Self
   @_unsafeNonescapableResult
   init?(_ ptr: UnsafeRawBufferPointer, _ i: Int) {
     if (i % 2 == 0) {
@@ -45,8 +45,7 @@ struct BufferView : ~Escapable {
 
 struct MutableBufferView : ~Escapable, ~Copyable {
   let ptr: UnsafeMutableRawBufferPointer
-  @_unsafeNonescapableResult
-  init(_ ptr: UnsafeMutableRawBufferPointer) {
+  init(_ ptr: UnsafeMutableRawBufferPointer) -> dependsOn(ptr) Self {
     self.ptr = ptr
   }
 }

test/SIL/Parser/lifetime_dependence.sil

@@ -8,7 +8,7 @@ import Swift
 
 struct BufferView : ~Escapable {
   @_hasStorage let ptr: UnsafeRawBufferPointer { get }
-  @_unsafeNonescapableResult @inlinable init(_ ptr: UnsafeRawBufferPointer)
+  @inlinable init(_ ptr: UnsafeRawBufferPointer) -> _scope(ptr) Self
   init(_ ptr: UnsafeRawBufferPointer, _ a: borrowing Array<Int>) -> _scope(a) Self
 }
 

test/SIL/explicit_lifetime_dependence_specifiers.swift

@@ -8,17 +8,21 @@ import Builtin
 
 struct BufferView : ~Escapable {
   let ptr: UnsafeRawBufferPointer
-  @_unsafeNonescapableResult
-  init(_ ptr: UnsafeRawBufferPointer) {
+  init(_ ptr: UnsafeRawBufferPointer) -> dependsOn(ptr) Self {
     self.ptr = ptr
   }
+  // TODO:  -> dependsOn(ptr) Self
   @_unsafeNonescapableResult
   init?(_ ptr: UnsafeRawBufferPointer, _ i: Int) {
     if (i % 2 == 0) {
       return nil
     } 
     self.ptr = ptr
   }
+  @_unsafeNonescapableResult
+  init(independent ptr: UnsafeRawBufferPointer) {
+    self.ptr = ptr
+  }
 // CHECK: sil hidden @$s39explicit_lifetime_dependence_specifiers10BufferViewVyACSW_SaySiGhYlstcfC : $@convention(method) (UnsafeRawBufferPointer, @guaranteed Array<Int>, @thin BufferView.Type) -> _scope(1) @owned BufferView {
   init(_ ptr: UnsafeRawBufferPointer, _ a: borrowing Array<Int>) -> dependsOn(a) Self {
     self.ptr = ptr
@@ -38,8 +42,7 @@ struct BufferView : ~Escapable {
 
 struct MutableBufferView : ~Escapable, ~Copyable {
   let ptr: UnsafeMutableRawBufferPointer
-  @_unsafeNonescapableResult
-  init(_ ptr: UnsafeMutableRawBufferPointer) {
+  init(_ ptr: UnsafeMutableRawBufferPointer) -> dependsOn(ptr) Self {
     self.ptr = ptr
   }
 }
@@ -57,28 +60,28 @@ func testBasic() {
 
 // CHECK: sil hidden @$s39explicit_lifetime_dependence_specifiers6deriveyAA10BufferViewVADYlsF : $@convention(thin) (@guaranteed BufferView) -> _scope(0) @owned BufferView {
 func derive(_ x: borrowing BufferView) -> dependsOn(scoped x) BufferView {
-  return BufferView(x.ptr)
+  return BufferView(independent: x.ptr)
 }
 
 // CHECK: sil hidden @$s39explicit_lifetime_dependence_specifiers16consumeAndCreateyAA10BufferViewVADnYliF : $@convention(thin) (@owned BufferView) -> _inherit(0) @owned BufferView {
 func consumeAndCreate(_ x: consuming BufferView) -> dependsOn(x) BufferView {
-  return BufferView(x.ptr)
+  return BufferView(independent: x.ptr)
 }
 
 // CHECK: sil hidden @$s39explicit_lifetime_dependence_specifiers17deriveThisOrThat1yAA10BufferViewVADYls_ADYlstF : $@convention(thin) (@guaranteed BufferView, @guaranteed BufferView) -> _scope(0, 1) @owned BufferView {
 func deriveThisOrThat1(_ this: borrowing BufferView, _ that: borrowing BufferView) -> dependsOn(scoped this, that) BufferView {
   if (Int.random(in: 1..<100) == 0) {
-    return BufferView(this.ptr)
+    return BufferView(independent: this.ptr)
   }
-  return BufferView(that.ptr)
+  return BufferView(independent: that.ptr)
 }
 
 // CHECK: sil hidden @$s39explicit_lifetime_dependence_specifiers17deriveThisOrThat2yAA10BufferViewVADYls_ADnYlitF : $@convention(thin) (@guaranteed BufferView, @owned BufferView) -> _inherit(1) _scope(0) @owned BufferView {
 func deriveThisOrThat2(_ this: borrowing BufferView, _ that: consuming BufferView) -> dependsOn(scoped this) dependsOn(that) BufferView {
   if (Int.random(in: 1..<100) == 0) {
-    return BufferView(this.ptr)
+    return BufferView(independent: this.ptr)
   }
-  return BufferView(that.ptr)
+  return BufferView(independent: that.ptr)
 }
 
 func use(_ x: borrowing BufferView) {}
@@ -101,19 +104,18 @@ struct Wrapper : ~Escapable {
 
 struct Container : ~Escapable {
  let ptr: UnsafeRawBufferPointer
- @_unsafeNonescapableResult
- init(_ ptr: UnsafeRawBufferPointer) {
+ init(_ ptr: UnsafeRawBufferPointer) -> dependsOn(ptr) Self {
    self.ptr = ptr
  }
 }
 
 // CHECK-LABEL: sil hidden @$s39explicit_lifetime_dependence_specifiers16getConsumingViewyAA06BufferG0VAA9ContainerVnYliF : $@convention(thin) (@owned Container) -> _inherit(0) @owned BufferView {
 func getConsumingView(_ x: consuming Container) -> dependsOn(x) BufferView {
-  return BufferView(x.ptr)
+  return BufferView(independent: x.ptr)
 }
 
 // CHECK-LABEL: sil hidden @$s39explicit_lifetime_dependence_specifiers16getBorrowingViewyAA06BufferG0VAA9ContainerVYlsF : $@convention(thin) (@guaranteed Container) -> _scope(0) @owned BufferView {
 func getBorrowingView(_ x: borrowing Container) -> dependsOn(scoped x) BufferView {
-  return BufferView(x.ptr)
+  return BufferView(independent: x.ptr)
 }
 

test/SIL/implicit_lifetime_dependence.swift

@@ -6,8 +6,12 @@
 struct BufferView : ~Escapable {
   let ptr: UnsafeRawBufferPointer
   let c: Int
+  init(_ ptr: UnsafeRawBufferPointer, _ c: Int) -> dependsOn(ptr) Self {
+    self.ptr = ptr
+    self.c = c
+  }
   @_unsafeNonescapableResult
-  init(_ ptr: UnsafeRawBufferPointer, _ c: Int) {
+  init(independent ptr: UnsafeRawBufferPointer, _ c: Int) {
     self.ptr = ptr
     self.c = c
   }
@@ -31,8 +35,7 @@ struct BufferView : ~Escapable {
 struct MutableBufferView : ~Escapable, ~Copyable {
   let ptr: UnsafeMutableRawBufferPointer
   let c: Int
-  @_unsafeNonescapableResult
-  init(_ ptr: UnsafeMutableRawBufferPointer, _ c: Int) {
+  init(_ ptr: UnsafeMutableRawBufferPointer, _ c: Int) -> dependsOn(ptr) Self {
     self.ptr = ptr
     self.c = c
   }
@@ -54,12 +57,12 @@ func derive(_ x: borrowing BufferView) -> BufferView {
 }
 
 func derive(_ unused: Int, _ x: borrowing BufferView) -> BufferView {
-  return BufferView(x.ptr, x.c)
+  return BufferView(independent: x.ptr, x.c)
 }
 
 // CHECK: sil hidden @$s28implicit_lifetime_dependence16consumeAndCreateyAA10BufferViewVADnYliF : $@convention(thin) (@owned BufferView) -> _inherit(0) @owned BufferView {
 func consumeAndCreate(_ x: consuming BufferView) -> BufferView {
-  return BufferView(x.ptr, x.c)
+  return BufferView(independent: x.ptr, x.c)
 }
 
 func use(_ x: borrowing BufferView) {}
@@ -135,8 +138,7 @@ struct GenericBufferView<Element> : ~Escapable {
                                       count: count)
   }
   // unsafe private API
-  @_unsafeNonescapableResult
-  init(baseAddress: Pointer, count: Int) {
+  init(baseAddress: Pointer, count: Int) -> dependsOn(baseAddress) Self {
     precondition(count >= 0, "Count must not be negative")
     self.baseAddress = baseAddress
     self.count = count

test/SIL/lifetime_dependence_generics.swift

@@ -15,6 +15,7 @@ extension P {
 }
 
 public struct View: ~Escapable {
+  // TODO: dependsOn(immortal)
   @_unsafeNonescapableResult
   init() { }
 }

test/SIL/type_lowering_unit.sil

@@ -248,6 +248,7 @@ extension GSNCInt: Copyable where T: Copyable  {}
 
 struct GSNEInt<T: ~Escapable>: ~Escapable {
     var x: Int
+    // TODO: dependsOn(immortal)
     @_unsafeNonescapableResult
     init() { x = 0 }
 }

test/SILOptimizer/lifetime_dependence_borrow.swift

@@ -21,8 +21,7 @@ struct BV : ~Escapable {
 
   public var isEmpty: Bool { i == 0 }
 
-  @_unsafeNonescapableResult
-  init(_ p: UnsafeRawPointer, _ i: Int) {
+  init(_ p: UnsafeRawPointer, _ i: Int) -> dependsOn(p) Self {
     self.p = p
     self.i = i
   }
@@ -38,8 +37,7 @@ struct MBV : ~Escapable, ~Copyable {
   let p: UnsafeRawPointer
   let i: Int
 
-  @_unsafeNonescapableResult
-  init(_ p: UnsafeRawPointer, _ i: Int) {
+  init(_ p: UnsafeRawPointer, _ i: Int) -> dependsOn(p) Self {
     self.p = p
     self.i = i
   }