Migrate SwiftCompilerSources to FunctionConvention.

Layers:
- FunctionConvention: AST FunctionType: results, parameters
- ArgumentConventions: SIL function arguments
- ApplyOperandConventions: applied operands

The meaning of an integer index is determined by the collection
type. All the mapping between the various indices (results,
parameters, SIL argument, applied arguments) is restricted to the
collection type that owns that mapping. Remove the concept of a
"caller argument index".

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -188,10 +188,8 @@ private struct SideEffectsVisitor : EscapeVisitorWithResult {
       return .ignore
     }
     if user == apply {
-      if let argIdx = apply.argumentIndex(of: operand) {
-        let e = calleeAnalysis.getSideEffects(of: apply, forArgument: argIdx, path: path.projectionPath)
-        result.merge(with: e)
-      }
+      let e = calleeAnalysis.getSideEffects(of: apply, operand: operand, path: path.projectionPath)
+      result.merge(with: e)
     }
     return .continueWalk
   }
@@ -246,7 +244,7 @@ private struct IsIndirectResultWalker: AddressDefUseWalker {
 
   mutating func leafUse(address: Operand, path: UnusedWalkingPath) -> WalkResult {
     if address.instruction == apply,
-       let argIdx = apply.argumentIndex(of: address),
+       let argIdx = apply.calleeArgumentIndex(of: address),
        argIdx < apply.numIndirectResultArguments {
       return .abortWalk
     }

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -78,16 +78,18 @@ public struct CalleeAnalysis {
   }
 
   /// Returns the argument specific side effects of an apply.
-  public func getSideEffects(of apply: ApplySite, forArgument argumentIdx: Int, path: SmallProjectionPath) -> SideEffects.GlobalEffects {
-    let calleeArgIdx = apply.calleeArgIndex(callerArgIndex: argumentIdx)
-    let convention = apply.getArgumentConvention(calleeArgIndex: calleeArgIdx)
-    let argument = apply.arguments[argumentIdx].at(path)
+  public func getSideEffects(of apply: ApplySite, operand: Operand, path: SmallProjectionPath) -> SideEffects.GlobalEffects {
+    var result = SideEffects.GlobalEffects()
+    guard let calleeArgIdx = apply.calleeArgumentIndex(of: operand) else {
+      return result
+    }
+    let convention = apply.convention(of: operand)!
+    let argument = operand.value.at(path)
 
     guard let callees = getCallees(callee: apply.callee) else {
       return .worstEffects.restrictedTo(argument: argument, withConvention: convention)
     }
 
-    var result = SideEffects.GlobalEffects()
     for callee in callees {
       let calleeEffects = callee.getSideEffects(forArgument: argument,
                                                 atIndex: calleeArgIdx,

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

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

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -239,9 +239,9 @@ private struct CollectedEffects {
 
   private mutating func handleApply(_ apply: ApplySite) {
     let callees = calleeAnalysis.getCallees(callee: apply.callee)
-    let args = apply.arguments.enumerated().lazy.map {
-      (calleeArgumentIndex: apply.calleeArgIndex(callerArgIndex: $0.0),
-       callerArgument: $0.1)
+    let args = apply.argumentOperands.lazy.map {
+      (calleeArgumentIndex: apply.calleeArgumentIndex(of: $0)!,
+       callerArgument: $0.value)
     }
     addEffects(ofFunctions: callees, withArguments: args)
   }
@@ -316,7 +316,7 @@ private struct CollectedEffects {
           if let calleePath = calleeEffect.copy    { addEffects(.copy,    to: argument, fromInitialPath: calleePath) }
           if let calleePath = calleeEffect.destroy { addEffects(.destroy, to: argument, fromInitialPath: calleePath) }
         } else {
-          let convention = callee.getArgumentConvention(for: calleeArgIdx)
+          let convention = callee.argumentConventions[calleeArgIdx]
           let wholeArgument = argument.at(defaultPath(for: argument))
           let calleeEffects = callee.getSideEffects(forArgument: wholeArgument,
                                                     atIndex: calleeArgIdx,
@@ -444,7 +444,7 @@ private struct ArgumentEscapingWalker : ValueDefUseWalker, AddressDefUseWalker {
       return .continueWalk
 
     case let apply as ApplySite:
-      if apply.isCalleeOperand(value) {
+      if apply.isCallee(operand: value) {
         // `CollectedEffects.handleApply` only handles argument operands of an apply, but not the callee operand.
         return .abortWalk
       }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjCBridgingOptimization.swift

@@ -350,7 +350,7 @@ func isBridgeToSwiftCall(_ value: Value) -> ApplyInst? {
     return nil
   }
   guard bridgingCall.arguments.count == 2,
-        bridgingCall.getArgumentConvention(calleeArgIndex: 0) == .directGuaranteed else {
+        bridgingCall.calleeArgumentConventions[0] == .directGuaranteed else {
     return nil
   }
   return bridgingCall
@@ -362,7 +362,7 @@ func isBridgeToObjcCall(_ value: Value) -> ApplyInst? {
         let bridgingFunc = bridgingCall.referencedFunction,
         bridgingFunc.hasSemanticsAttribute("convertToObjectiveC"),
         bridgingCall.arguments.count == 1,
-        bridgingCall.getArgumentConvention(calleeArgIndex: 0) == .directGuaranteed else {
+        bridgingCall.calleeArgumentConventions[0] == .directGuaranteed else {
     return nil
   }
   return bridgingCall

SwiftCompilerSources/Sources/Optimizer/ModulePasses/ReadOnlyGlobalVariables.swift

@@ -59,9 +59,8 @@ private struct FindWrites : AddressDefUseWalker {
       return address == ca.sourceOperand ? .continueWalk : .abortWalk
 
     case let apply as FullApplySite:
-      if let callerArgIdx = apply.argumentIndex(of: address) {
-        let calleeArgIdx = apply.calleeArgIndex(callerArgIndex: callerArgIdx)
-        let convention = apply.getArgumentConvention(calleeArgIndex: calleeArgIdx)
+      if let calleeArgIdx = apply.calleeArgumentIndex(of: address) {
+        let convention = apply.calleeArgumentConventions[calleeArgIdx]
         if convention.isIndirectIn {
           return .continueWalk
         }

SwiftCompilerSources/Sources/Optimizer/ModulePasses/StackProtection.swift

@@ -260,13 +260,13 @@ private struct StackProtectionOptimization {
 
         for functionRefUse in fri.uses {
           guard let apply = functionRefUse.instruction as? ApplySite,
-                let callerArgIdx = apply.callerArgIndex(calleeArgIndex: arg.index) else {
+                let callerArgOp = apply.operand(forCalleeArgumentIndex: arg.index) else {
             if enableMoveInout {
               return NeedInsertMoves.yes
             }
             continue
           }
-          let callerArg = apply.arguments[callerArgIdx]
+          let callerArg = callerArgOp.value
           if callerArg.type.isAddress {
             // It's an indirect argument.
             switch callerArg.accessBase.isStackAllocated {

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -491,7 +491,7 @@ extension Operand {
 
 extension Instruction {
   func setOperand(at index : Int, to value: Value, _ context: some MutatingContext) {
-    if self is FullApplySite && index == ApplyOperands.calleeOperandIndex {
+    if let apply = self as? FullApplySite, apply.isCallee(operand: operands[index]) {
       context.notifyCallsChanged()
     }
     context.notifyInstructionsChanged()

SwiftCompilerSources/Sources/Optimizer/Utilities/Devirtualization.swift

@@ -107,7 +107,7 @@ extension DestroyValueInst : DevirtualizableDestroy {
     let builder = Builder(before: self, context)
     let subs = context.getContextSubstitutionMap(for: type)
     let deinitRef = builder.createFunctionRef(deinitializer)
-    if deinitializer.getArgumentConvention(for: deinitializer.selfArgumentIndex).isIndirect {
+    if deinitializer.argumentConventions[deinitializer.selfArgumentIndex].isIndirect {
       let allocStack = builder.createAllocStack(type)
       builder.createStore(source: destroyedValue, destination: allocStack, ownership: .initialize)
       builder.createApply(function: deinitRef, subs, arguments: [allocStack])
@@ -175,7 +175,7 @@ extension DestroyAddrInst : DevirtualizableDestroy {
     let builder = Builder(before: self, context)
     let subs = context.getContextSubstitutionMap(for: destroyedAddress.type)
     let deinitRef = builder.createFunctionRef(deinitializer)
-    if !deinitializer.getArgumentConvention(for: deinitializer.selfArgumentIndex).isIndirect {
+    if !deinitializer.argumentConventions[deinitializer.selfArgumentIndex].isIndirect {
       let value = builder.createLoad(fromAddress: destroyedAddress, ownership: .take)
       builder.createApply(function: deinitRef, subs, arguments: [value])
     } else {

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -555,7 +555,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   /// Handle an apply (full or partial) during the walk-down.
   private mutating
   func walkDownCallee(argOp: Operand, apply: ApplySite, path: Path) -> WalkResult {
-    guard let argIdx = apply.argumentIndex(of: argOp) else {
+    guard let calleeArgIdx = apply.calleeArgumentIndex(of: argOp) else {
       // The callee or a type dependent operand of the apply does not let escape anything.
       return .continueWalk
     }
@@ -591,8 +591,6 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       return isEscaping
     }
 
-    let calleeArgIdx = apply.calleeArgIndex(callerArgIndex: argIdx)
-
     for callee in callees {
       let effects = callee.effects
       if !effects.escapeEffects.canEscape(argumentIndex: calleeArgIdx,
@@ -617,12 +615,12 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       case .escapingToArgument(let toArgIdx, let toPath):
         // Note: exclusive argument -> argument effects cannot appear, so we don't need to handle them here.
         if effect.matches(calleeArgIdx, argPath.projectionPath) {
-          guard let callerToIdx = apply.callerArgIndex(calleeArgIndex: toArgIdx) else {
+          guard let argOp = apply.operand(forCalleeArgumentIndex: toArgIdx) else {
             return isEscaping
           }
 
           // Continue at the destination of an arg-to-arg escape.
-          let arg = apply.arguments[callerToIdx]
+          let arg = argOp.value
 
           let p = Path(projectionPath: toPath, followStores: false, knownType: nil)
           if walkUp(addressOrValue: arg, path: p) == .abortWalk {
@@ -778,10 +776,10 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
         switch effect.kind {
         case .escapingToReturn(let toPath, let exclusive):
           if exclusive && path.projectionPath.matches(pattern: toPath) {
-            guard let callerArgIdx = apply.callerArgIndex(calleeArgIndex: effect.argumentIndex) else {
+            guard let argOp = apply.operand(forCalleeArgumentIndex: effect.argumentIndex) else {
               return .abortWalk
             }
-            let arg = apply.arguments[callerArgIdx]
+            let arg = argOp.value
 
             let p = Path(projectionPath: effect.pathPattern, followStores: path.followStores, knownType: nil)
             if walkUp(addressOrValue: arg, path: p) == .abortWalk {