LifetimeDependenceDiagnostics: diagnose indirect closure results.

Add support for diagnosing calls to closures that return a generic
non-Escapable result.

Closures do not yet model lifetime dependencies. The diagnostics have
a special case for handling nonescaple result with no lifetime
dependence, but it previously only handled direct results. This fix handles
cases like the following:

    func callIndirectClosure<T>(f: () -> NE<T>) -> NE<T> {
      f()
    }

Fixes rdar://134318846 ([nonescapable] diagnose function types with nonescapable results)

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -72,12 +72,16 @@ let lifetimeDependenceDiagnosticsPass = FunctionPass(
       markDep.settleToEscaping(context)
       continue
     }
-    if let apply = instruction as? FullApplySite {
-      // Handle ~Escapable results that do not have a lifetime dependence. This includes implicit initializers and
-      // @_unsafeNonescapableResult.
+    if let apply = instruction as? FullApplySite, !apply.hasResultDependence {
+      // Handle ~Escapable results that do not have a lifetime dependence. This includes implicit initializers, calls to
+      // closures, and @_unsafeNonescapableResult.
       apply.resultOrYields.forEach {
-        if let lifetimeDep = LifetimeDependence(unsafeApplyResult: $0,
-                                                context) {
+        if let lifetimeDep = LifetimeDependence(unsafeApplyResult: $0, apply: apply, context) {
+          _ = analyze(dependence: lifetimeDep, context)
+        }
+      }
+      apply.indirectResultOperands.forEach {
+        if let lifetimeDep = LifetimeDependence(unsafeApplyResult: $0.value, apply: apply, context) {
           _ = analyze(dependence: lifetimeDep, context)
         }
       }

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -165,16 +165,12 @@ extension LifetimeDependence {
   //
   // This is necessary because inserting a mark_dependence placeholder for such an unsafe dependence would illegally
   // have the same base and value operand.
-  //
-  // TODO: handle indirect results
-  init?(unsafeApplyResult value: Value, _ context: some Context) {
+  init?(unsafeApplyResult value: Value, apply: FullApplySite, _ context: some Context) {
     if value.isEscapable {
       return nil
     }
-    if (value.definingInstructionOrTerminator as! FullApplySite).hasResultDependence {
-      return nil
-    }
-    assert(value.ownership == .owned, "unsafe apply result must be owned")
+    assert(!apply.hasResultDependence, "mark_dependence should be used instead")
+    assert(value.ownership == .owned || value.type.isAddress, "unsafe apply result must be owned")
     self.scope = Scope(base: value, context)
     self.dependentValue = value
     self.markDepInst = nil
@@ -578,8 +574,8 @@ extension LifetimeDependenceDefUseWalker {
     }
     let root = dependence.dependentValue
     if root.type.isAddress { 
-      // The root address may be an escapable mark_dependence that guards its address uses (unsafeAddress), or an
-      // allocation or incoming argument. In all these cases, it is sufficient to walk down the address uses.
+      // The root address may be an escapable mark_dependence that guards its address uses (unsafeAddress), an
+      // allocation, an incoming argument, or an outgoing argument. In all these cases, walk down the address uses.
       return walkDownAddressUses(of: root)
     }
     return walkDownUses(of: root, using: nil)
@@ -974,7 +970,8 @@ extension LifetimeDependenceDefUseWalker {
 
   private mutating func visitAppliedUse(of operand: Operand, by apply: FullApplySite) -> WalkResult {
     if let conv = apply.convention(of: operand), conv.isIndirectOut {
-      return leafUse(of: operand)
+      // This apply initializes an allocation.
+      return dependentUse(of: operand, dependentAddress: operand.value)
     }
     if apply.isCallee(operand: operand) {
       return leafUse(of: operand)