LifetimeDependenceInsertion: do not emit inherited dependencies.

These were always redundant. And there is no way to emit them
correctly for valid OSA when the original dependence scope is in the
caller.

NFC without:
-enable-experimental-feature NonescapableTypes
-enable-lifetime-dependence-diagnostics

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceInsertion.swift

@@ -102,14 +102,16 @@ extension LifetimeDependentApply {
   }
 }
 
-/// Replace the each dependent apply result with a chain of
-/// mark_dependence [nonescaping] instructions; one for each base.
+/// If the result of this apply depends on the scope of one or more
+/// arguments, then insert a mark_dependence [unresolved] from the
+/// result on each argument so that the result is recognized as a
+/// dependent value within each scope.
 private func insertDependencies(for apply: LifetimeDependentApply,
   _ context: FunctionPassContext ) {
   precondition(apply.applySite.results.count > 0,
     "a lifetime-dependent instruction must have at least one result")
 
-  let bases = recursivelyFindDependenceBases(of: apply, context)
+  let bases = findDependenceBases(of: apply, context)
   let builder = Builder(after: apply.applySite, context)
   for dependentValue in apply.applySite.resultOrYields {
     insertMarkDependencies(value: dependentValue, initializer: nil,
@@ -138,6 +140,31 @@ private func insertDependencies(for apply: LifetimeDependentApply,
   }
 }
 
+private func findDependenceBases(of apply: LifetimeDependentApply,
+                                 _ context: FunctionPassContext)
+  -> [Value] {
+  log("Creating dependencies for \(apply.applySite)")
+  var bases: [Value] = []
+  for lifetimeArg in apply.getLifetimeArguments() {
+    switch lifetimeArg.convention {
+    case .inherit:
+      continue
+    case .scope:
+      // Create a new dependence on the apply's access to the argument.
+      for varIntoducer in gatherVariableIntroducers(for: lifetimeArg.value,
+                                                    context) {
+        if let scope =
+             LifetimeDependence.Scope(base: varIntoducer, context) {
+          log("Scoped lifetime from \(lifetimeArg.value)")
+          log("  scope: \(scope)")
+          bases.append(scope.parentValue)
+        }
+      }
+    }
+  }
+  return bases
+}
+
 private func insertMarkDependencies(value: Value, initializer: Instruction?,
                                     bases: [Value], builder: Builder,
                                     _ context: FunctionPassContext) {
@@ -155,6 +182,7 @@ private func insertMarkDependencies(value: Value, initializer: Instruction?,
   }
 }
 
+/*
 /// Return base values that this return value depends on.
 ///
 /// For lifetime copies, walk up the dependence chain to find the
@@ -212,3 +240,4 @@ private func recursivelyUpdate(scope: LifetimeDependence.Scope,
   }
   return scope
 }
+*/

test/SILOptimizer/lifetime_dependence_diagnostics.swift

@@ -18,14 +18,26 @@ func bv_copy(_ bv: borrowing BV) -> _copy(bv) BV {
   copy bv
 }
 
-// Diagnostics resolves mark_dependence [nonescaping].
+// No mark_dependence is needed for a inherited scope.
 //
-// CHECK-LABEL: sil hidden @$s4test14bv_borrow_copy0B0AA2BVVAE_tF : $@convention(thin) (@guaranteed BV) -> _scope(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 {
+// CHECK-LABEL: sil hidden @$s4test14bv_borrow_copyyAA2BVVADF : $@convention(thin) (@guaranteed BV) -> _scope(1) @owned BV {
+// CHECK:      bb0(%0 : @noImplicitCopy $BV):
+// CHECK:        apply %{{.*}}(%0) : $@convention(thin) (@guaranteed BV) -> _inherit(1) @owned BV // user: %4
+// CHECK-NEXT:   return %3 : $BV
+// CHECK-LABEL: } // end sil function '$s4test14bv_borrow_copyyAA2BVVADF'
+func bv_borrow_copy(_ bv: borrowing BV) -> _borrow(bv) BV {
   bv_copy(bv) 
 }
+
+// The mark_dependence for the borrow scope should be marked
+// [nonescaping] after diagnostics.
+//
+// CHECK-LABEL: sil hidden @$s4test010bv_borrow_C00B0AA2BVVAE_tF : $@convention(thin) (@guaranteed BV) -> _scope(1) @owned BV {
+// CHECK:       bb0(%0 : @noImplicitCopy $BV):
+// CHECK:         [[R:%.*]] = apply %{{.*}}(%0) : $@convention(thin) (@guaranteed BV) -> _scope(1) @owned BV
+// CHECK:         %{{.*}} = mark_dependence [nonescaping] [[R]] : $BV on %0 : $BV
+// CHECK-NEXT:    return %{{.*}} : $BV
+// CHECK-LABEL: } // end sil function '$s4test010bv_borrow_C00B0AA2BVVAE_tF'
+func bv_borrow_borrow(bv: borrowing BV) -> _borrow(bv) BV {
+  bv_borrow_copy(bv)
+}