SIL: add ApplySite.calleeArgument(of operand: Operand, in callee: Function)

This is a safer API than using
```
  let argIdx = applySite.calleeArgumentIndex(of: op)
  let arg = callee.arguments[argIdx]
```
because there is no potential misuse of the index.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -141,8 +141,8 @@ private func isOperandOfRecursiveCall(_ op: Operand) -> Bool {
   if let applySite = inst as? FullApplySite,
      let callee = applySite.referencedFunction,
      callee == inst.parentFunction,
-     let argIdx = applySite.calleeArgumentIndex(of: op),
-     op.value == callee.arguments[argIdx] {
+     let calleeArg = applySite.calleeArgument(of: op, in: callee),
+     op.value == calleeArg {
     return true
   }
   return false

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyCopyBlock.swift

@@ -89,9 +89,9 @@ private extension PartialApplyInst {
     guard isOnStack,
           let callee = referencedFunction,
           callee.isDefinition,
-          let argIdx = calleeArgumentIndex(of: closure),
+          let calleeArg = calleeArgument(of: closure, in: callee),
           // If the callee only _calls_ the closure argument, it does not escape.
-          callee.arguments[argIdx].uses.allSatisfy(isCalleeOperandOfApply)
+          calleeArg.uses.allSatisfy(isCalleeOperandOfApply)
     else {
       return true
     }

SwiftCompilerSources/Sources/SIL/ApplySite.swift

@@ -277,15 +277,24 @@ extension ApplySite {
     return argumentOperands[callerArgIdx]
   }
 
-  /// Returns the argument index of an operand.
+  /// Returns the argument of `operand` in a callee function.
   ///
-  /// Returns nil if 'operand' is not an argument operand. This is the case if
+  /// Returns nil if `operand` is not an argument operand. This is the case if
   /// it's the callee function operand.
+  public func calleeArgument(of operand: Operand, in callee: Function) -> FunctionArgument? {
+    if let argIdx = calleeArgumentIndex(of: operand) {
+      return callee.arguments[argIdx]
+    }
+    return nil
+  }
+
+  /// Returns the argument index of an operand.
   ///
-  /// Warning: the returned integer can be misused as an index into
-  /// the wrong collection. Replace uses of this API with safer APIs.
+  /// Returns nil if `operand` is not an argument operand. This is the case if
+  /// it's the callee function operand.
   ///
-  /// TODO: delete this API and rewrite the users. 
+  /// Warning: the returned integer can be misused as an index into the wrong collection.
+  /// Use `calleeArgument(of:,in:)` if possible.
   public func calleeArgumentIndex(of operand: Operand) -> Int? {
     operandConventions.calleeArgumentIndex(of: operand)
   }