Improve the ArgumentConvention API

Author: atrick

SwiftCompilerSources/Sources/SIL/ApplySite.swift

@@ -59,10 +59,31 @@ public struct ApplyOperandConventions : Collection {
   }
 
   public func convention(of operand: Operand) -> ArgumentConvention? {
-    guard let argIdx = calleeArgumentIndex(of: operand) else { return nil }
+    guard let argIdx = calleeArgumentIndex(of: operand) else {
+      return nil
+    }
     return calleeArgumentConventions[argIdx]
   }
 
+  public func originalParameter(of operand: Operand) -> ParameterInfo? {
+    guard let argIdx = calleeArgumentIndex(of: operand) else {
+      return nil
+    }
+    guard argIdx >= calleeArgumentConventions.firstParameterIndex else {
+      return nil
+    }
+    return calleeArgumentConventions.originalParameters[argIdx]
+  }
+
+  public var firstParameterOperandIndex: Int {
+    return ApplyOperandConventions.firstArgumentIndex +
+      calleeArgumentConventions.firstParameterIndex
+  }
+
+  // TODO: rewrite uses of this API to pass an Operand instead, and
+  // make this private. No client should have multiple integer
+  // indices, some of which are caller indices, and some of which are
+  // callee indices.
   public func calleeArgumentIndex(ofOperandIndex index: Int) -> Int? {
     let callerArgIdx = index - ApplyOperandConventions.firstArgumentIndex
     guard callerArgIdx >= 0 else { return nil }
@@ -108,22 +129,24 @@ extension ApplySite {
     argumentOperands.values
   }
 
-  public var substitutionMap: SubstitutionMap {
-    SubstitutionMap(bridged.ApplySite_getSubstitutionMap())
-  }
-
-  /// Get the conventions of the callee without the applied substitutions.
-  public var originalCalleeConvention: FunctionConvention {
-    FunctionConvention(for: callee.type.bridged.getASTType(), in: parentFunction)
+  /// Indirect results including the error result.
+  public var indirectResultOperands: OperandArray {
+    let offset = ApplyOperandConventions.firstArgumentIndex
+    return operands[offset..<operandConventions.firstParameterOperandIndex]
   }
 
-  /// Get the conventions of the callee with the applied substitutions.
-  public var substitutedCalleeConvention: FunctionConvention {
-    FunctionConvention(for: bridged.ApplySite_getSubstitutedCalleeType(), in: parentFunction)
+  public var substitutionMap: SubstitutionMap {
+    SubstitutionMap(bridged.ApplySite_getSubstitutionMap())
   }
 
   public var calleeArgumentConventions: ArgumentConventions {
-    ArgumentConventions(functionConvention: substitutedCalleeConvention)
+    let originalConv = FunctionConvention(for: callee.type.bridged.getASTType(),
+                                          in: parentFunction)
+    let substConv = FunctionConvention(
+      for: bridged.ApplySite_getSubstitutedCalleeType(),
+      in: parentFunction)
+    return ArgumentConventions(originalFunctionConvention: originalConv,
+                               substitutedFunctionConvention: substConv)
   }
 
   public var operandConventions: ApplyOperandConventions {

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -170,22 +170,34 @@ public struct TerminatorResult {
 /// ArgumentConventions indexed on a SIL function's argument index.
 /// When derived from an ApplySite, this corresponds to the callee index.
 public struct ArgumentConventions : Collection, CustomStringConvertible {
-  public let functionConvention: FunctionConvention
+  public let originalFunctionConvention: FunctionConvention
+  public let substitutedFunctionConvention: FunctionConvention?
 
-  public var bridgedFunctionType: BridgedASTType { functionConvention.bridgedFunctionType }
-
-  /// Indirect results including the error result.
+  /// Indirect results including the error result. Apply type
+  /// substitution if it is available.
   public var indirectSILResults: LazyFilterSequence<FunctionConvention.Results> {
-    functionConvention.indirectSILResults
+    if let substitutedFunctionConvention {
+      return substitutedFunctionConvention.indirectSILResults
+    }
+    return originalFunctionConvention.indirectSILResults
   }
 
   /// Number of SIL arguments for the function type's results
   /// including the error result. Use this to avoid lazy iteration.
   var indirectSILResultCount: Int {
-    functionConvention.indirectSILResultCount
+    originalFunctionConvention.indirectSILResultCount
+  }
+
+  public var originalParameters: FunctionConvention.Parameters {
+    originalFunctionConvention.parameters
   }
 
-  public var parameters: FunctionConvention.Parameters { functionConvention.parameters }
+  public var parameters: FunctionConvention.Parameters {
+    if let substitutedFunctionConvention {
+      return substitutedFunctionConvention.parameters
+    }
+    return originalFunctionConvention.parameters
+  }
 
   public var startIndex: Int { 0 }
 
@@ -207,17 +219,22 @@ public struct ArgumentConventions : Collection, CustomStringConvertible {
 
   /// The SIL argument index of the 'self' paramter.
   var selfIndex: Int? {
-    guard functionConvention.hasSelfParameter else { return nil }
+    guard originalFunctionConvention.hasSelfParameter else { return nil }
     // self is the last parameter
     return endIndex - 1
   }
 
   public var description: String {
-    var str = String(taking: bridgedFunctionType.getDebugDescription())
+    var str = String(taking: originalFunctionConvention.bridgedFunctionType.getDebugDescription())
+    if let substitutedFunctionConvention {
+      str += "\n" + String(taking: substitutedFunctionConvention.bridgedFunctionType.getDebugDescription())
+    }
     indirectSILResults.forEach {
       str += "\nindirect result: " + $0.description
     }
-    parameters.forEach { str += "\n      parameter: " + $0.description }
+    parameters.forEach {
+      str += "\n      parameter: " + $0.description
+    }
     return str
   }
 }

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -103,7 +103,8 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
   }
 
   public var argumentConventions: ArgumentConventions {
-    ArgumentConventions(functionConvention: convention)
+    ArgumentConventions(originalFunctionConvention: convention,
+                        substitutedFunctionConvention: nil)
   }
 
   public var returnInstruction: ReturnInst? {