LifetimeDependenceInsertion: remove a bailout on ~Copyable

Needed to diagnose MutableSpan and OutputSpan.

For now, simply remove the bailout and TODO. The next change will introduce more
logic to force a diagnostic error in rare cases that can't be handled completely.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceInsertion.swift

@@ -235,7 +235,7 @@ private func insertResultDependencies(for apply: LifetimeDependentApply, _ conte
   guard var sources = apply.getResultDependenceSources() else {
     return
   }
-  log("Creating dependencies for \(apply.applySite)")
+  log("Creating result dependencies for \(apply.applySite)")
 
   // Find the dependence base for each source.
   sources.initializeBases(context)
@@ -249,12 +249,6 @@ private func insertResultDependencies(for apply: LifetimeDependentApply, _ conte
     guard case let .store(initializingStore, initialAddress) = accessBase.findSingleInitializer(context) else {
       continue
     }
-    // TODO: This might bail-out on SIL that should be diagnosed. We should handle/cleanup projections and casts that
-    // occur before the initializingStore. Or check in the SIL verifier that all stores without an access scope follow
-    // this form. Then convert this bail-out to an assert.
-    guard initialAddress.usesOccurOnOrAfter(instruction: initializingStore, context) else {
-      continue
-    }
     assert(initializingStore == resultOper.instruction, "an indirect result is a store")
     Builder.insert(after: apply.applySite, context) { builder in
       insertMarkDependencies(value: initialAddress, initializer: initializingStore, bases: sources.bases,
@@ -268,7 +262,7 @@ private func insertParameterDependencies(apply: LifetimeDependentApply, target:
   guard var sources = apply.getParameterDependenceSources(target: target) else {
     return
   }
-  log("Creating dependencies for \(apply.applySite)")
+  log("Creating parameter dependencies for \(apply.applySite)")
 
   sources.initializeBases(context)
 
@@ -285,8 +279,13 @@ private func insertMarkDependencies(value: Value, initializer: Instruction?,
     let markDep = builder.createMarkDependence(
       value: currentValue, base: base, kind: .Unresolved)
 
-    // Address dependencies cannot be represented as SSA values, so it doesn not make sense to replace any uses of the
-    // dependent address. TODO: consider a separate mark_dependence_addr instruction since the semantics are different.
+    // Address dependencies cannot be represented as SSA values, so it does not make sense to replace any uses of the
+    // dependent address.
+    //
+    // TODO: either (1) insert a separate mark_dependence_addr instruction with no return value, or (2) perform data
+    // flow to replace all reachable address uses, and if any aren't dominated by base, then insert an extra
+    // escaping mark_dependence at this apply site that directly uses the mark_dependence [nonescaping] to force
+    // diagnostics to fail.
     if !value.type.isAddress {
       let uses = currentValue.uses.lazy.filter {
         if $0.isScopeEndingUse {

test/SILOptimizer/Inputs/SpanExtras.swift

@@ -28,7 +28,7 @@ public func _overrideLifetime<
 
 @_unsafeNonescapableResult
 @inlinable @inline(__always)
-@lifetime(source)
+@lifetime(borrow source)
 public func _overrideLifetime<
   T: ~Copyable & ~Escapable,
   U: ~Copyable & ~Escapable
@@ -117,7 +117,7 @@ extension MutableSpan {
   ) {
     let rb = UnsafeMutableBufferPointer(rebasing: elements)
     let ms = MutableSpan(_unsafeElements: rb)
-    self = _overrideLifetime(of: ms, to: rb)
+    self = _overrideLifetime(of: ms, to: elements)
   }
 }
 

test/SILOptimizer/lifetime_dependence/dependence_insertion.sil

@@ -18,8 +18,16 @@ struct NE: ~Escapable {
   init()
 }
 
+struct NCE: ~Escapable, ~Copyable {
+  var p: UnsafeRawPointer
+
+  @lifetime(immortal)
+  init()
+}
+
 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
 
 // Check that the inserted dependence is on the 'self' argument, not the temporary borrow.
 //
@@ -62,3 +70,25 @@ bb0(%0 : @guaranteed $AnyObject):
   destroy_value %3
   return %15
 }
+
+// CHECK-LABEL: sil [available 9999] [ossa] @testInoutSpanProp : $@convention(method) (@inout AnyObject) -> @lifetime(borrow 0) @owned NCE {
+// CHECK: bb0(%0 : $*AnyObject):
+// CHECK:   [[ALLOC:%.*]] = alloc_stack $NCE
+// CHECK:   [[MD:%.*]] = mark_unresolved_non_copyable_value [consumable_and_assignable] [[ALLOC]]
+// CHECK:   [[ACCESS:%.*]] = begin_access [modify] [unknown] %0
+// CHECK:   apply %{{.*}}([[MD]], [[ACCESS]]) : $@convention(thin) (@inout AnyObject) -> @lifetime(borrow 0) @out NCE
+// CHECK:   mark_dependence [unresolved] [[ALLOC]] on [[ACCESS]]
+// CHECK:   end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function 'testInoutSpanProp'
+sil [available 9999] [ossa] @testInoutSpanProp : $@convention(method) (@inout AnyObject) -> @lifetime(borrow 0) @owned NCE {
+bb0(%0 : $*AnyObject):
+  %1 = alloc_stack $NCE
+  %2 = mark_unresolved_non_copyable_value [consumable_and_assignable] %1
+  %3 = begin_access [modify] [unknown] %0
+  %4 = function_ref @getInoutSpan : $@convention(thin) (@inout AnyObject) -> @lifetime(borrow 0) @out NCE
+  %5 = apply %4(%2, %3) : $@convention(thin) (@inout AnyObject) -> @lifetime(borrow 0) @out NCE
+  end_access %3
+  %7 = load [take] %2
+  dealloc_stack %1
+  return %7
+}

test/SILOptimizer/lifetime_dependence/lifetime_dependence_mutate.swift

@@ -2,13 +2,54 @@
 // RUN:   -o /dev/null \
 // RUN:   -verify \
 // RUN:   -sil-verify-all \
-// RUN:   -disable-access-control \
 // RUN:   -module-name test \
 // RUN:   -enable-experimental-feature LifetimeDependence
 
 // REQUIRES: swift_in_compiler
 // REQUIRES: swift_feature_LifetimeDependence
 
+/// Unsafely discard any lifetime dependency on the `dependent` argument. Return
+/// a value identical to `dependent` with a lifetime dependency on the caller's
+/// borrow scope of the `source` argument.
+@_unsafeNonescapableResult
+@_transparent
+@lifetime(borrow source)
+internal func _overrideLifetime<
+  T: ~Copyable & ~Escapable, U: ~Copyable & ~Escapable
+>(
+  _ dependent: consuming T, borrowing source: borrowing U
+) -> T {
+  dependent
+}
+
+/// Unsafely discard any lifetime dependency on the `dependent` argument. Return
+/// a value identical to `dependent` that inherits all lifetime dependencies from
+/// the `source` argument.
+@_unsafeNonescapableResult
+@_transparent
+@lifetime(source)
+internal func _overrideLifetime<
+  T: ~Copyable & ~Escapable, U: ~Copyable & ~Escapable
+>(
+  _ dependent: consuming T, copying source: borrowing U
+) -> T {
+  dependent
+}
+
+/// Unsafely discard any lifetime dependency on the `dependent` argument. Return
+/// a value identical to `dependent` that inherits all lifetime dependencies from
+/// the `source` argument.
+@_unsafeNonescapableResult
+@_transparent
+@lifetime(borrow source)
+internal func _overrideLifetime<
+  T: ~Copyable & ~Escapable, U: ~Copyable & ~Escapable
+>(
+  _ dependent: consuming T, mutating source: inout U
+) -> T {
+  dependent
+}
+
 struct MutableSpan : ~Escapable, ~Copyable {
   let base: UnsafeMutableRawPointer
   let count: Int
@@ -59,7 +100,7 @@ extension Array where Element == Int {
     /* not the real implementation */
     let p = self.withUnsafeMutableBufferPointer { $0.baseAddress! }
     let span = MutableSpan(p, count)
-    return _overrideLifetime(span, borrowing: self)
+    return _overrideLifetime(span, mutating: &self)
   }
 }
 

test/SILOptimizer/lifetime_dependence/semantics.swift

@@ -37,6 +37,20 @@ internal func _overrideLifetime<
   dependent
 }
 
+/// Unsafely discard any lifetime dependency on the `dependent` argument. Return
+/// a value identical to `dependent` that inherits all lifetime dependencies from
+/// the `source` argument.
+@_unsafeNonescapableResult
+@_transparent
+@lifetime(borrow source)
+internal func _overrideLifetime<
+  T: ~Copyable & ~Escapable, U: ~Copyable & ~Escapable
+>(
+  _ dependent: consuming T, mutating source: inout U
+) -> T {
+  dependent
+}
+
 // Lifetime dependence semantics by example.
 public struct Span<T>: ~Escapable {
   private var base: UnsafePointer<T>?
@@ -102,7 +116,7 @@ extension Array {
     /* not the real implementation */
     let p = self.withUnsafeMutableBufferPointer { $0.baseAddress! }
     let span = MutableSpan<Element>(base: p, count: 1)
-    return _overrideLifetime(span, borrowing: self)
+    return _overrideLifetime(span, mutating: &self)
   }
 }