[SwiftCompilerSources] add parameter dependencies to conventions.

Add interfaces to FunctionConventions and ArgumentConventions for querying
lifetime dependencies where the target is another parameter.

Author: atrick

SwiftCompilerSources/Sources/SIL/ApplySite.swift

@@ -71,6 +71,12 @@ public struct ApplyOperandConventions : Collection {
       calleeArgumentIndex(ofOperandIndex: operandIndex)!]
   }
 
+  public subscript(parameterDependencies operandIndex: Int)
+    -> FunctionConvention.LifetimeDependencies? {
+    return calleeArgumentConventions[parameterDependencies:
+      calleeArgumentIndex(ofOperandIndex: operandIndex)!]
+  }
+
   public var firstParameterOperandIndex: Int {
     return ApplyOperandConventions.firstArgumentIndex +
       calleeArgumentConventions.firstParameterIndex
@@ -222,6 +228,16 @@ extension ApplySite {
     functionConvention.resultDependencies != nil
   }
 
+  public var hasLifetimeDependence: Bool {
+    functionConvention.hasLifetimeDependencies()
+  }
+
+  public func parameterDependencies(target operand: Operand) -> FunctionConvention.LifetimeDependencies? {
+    let idx = operand.index
+    return idx < operandConventions.startIndex ? nil
+      : operandConventions[parameterDependencies: idx]
+  }
+
   public var yieldConventions: YieldConventions {
     YieldConventions(convention: functionConvention)
   }

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -248,13 +248,22 @@ public struct ArgumentConventions : Collection, CustomStringConvertible {
     return convention.parameters[paramIdx]
   }
 
-  /// Return a dependence of the function results on the indexed parameter.
-  public subscript(resultDependsOn argumentIndex: Int)
-    -> LifetimeDependenceConvention? {
-    guard let paramIdx = parameterIndex(for: argumentIndex) else {
+  public subscript(parameterDependencies targetArgumentIndex: Int) -> FunctionConvention.LifetimeDependencies? {
+    guard let targetParamIdx = parameterIndex(for: targetArgumentIndex) else {
       return nil
     }
-    return convention.resultDependencies?[paramIdx]
+    return convention.parameterDependencies(for: targetParamIdx)
+  }
+
+  /// Return a dependence of the function results on the indexed parameter.
+  public subscript(resultDependsOn argumentIndex: Int) -> LifetimeDependenceConvention? {
+    findDependence(source: argumentIndex, in: convention.resultDependencies)
+  }
+
+  /// Return a dependence of the target argument on the source argument.
+  public func getDependence(target targetArgumentIndex: Int, source sourceArgumentIndex: Int)
+    -> LifetimeDependenceConvention? {
+    findDependence(source: sourceArgumentIndex, in: self[parameterDependencies: targetArgumentIndex])
   }
 
   /// Number of SIL arguments for the function type's results
@@ -295,6 +304,14 @@ extension ArgumentConventions {
     let firstParamIdx = firstParameterIndex  // bridging call
     return argIdx < firstParamIdx ? nil : argIdx - firstParamIdx
   }
+
+  private func findDependence(source argumentIndex: Int, in dependencies: FunctionConvention.LifetimeDependencies?)
+    -> LifetimeDependenceConvention? {
+    guard let paramIdx = parameterIndex(for: argumentIndex) else {
+      return nil
+    }
+    return dependencies?[paramIdx]
+  }
 }
 
 public struct YieldConventions : Collection, CustomStringConvertible {

SwiftCompilerSources/Sources/SIL/FunctionConvention.swift

@@ -73,22 +73,20 @@ public struct FunctionConvention : CustomStringConvertible {
       hasLoweredAddresses: hasLoweredAddresses)
   }
 
-  /// If the function result depends on any parameters, return a
-  /// Collection of LifetimeDependenceConvention indexed on the
-  /// function parameter.
-  public var resultDependencies: ResultDependencies? {
-    let bridgedDependencies = bridgedFunctionType.SILFunctionType_getLifetimeDependencies()
-    let dependencies = LifetimeDependencies(bridged: bridgedDependencies)
-    let targetIndex = parameters.count
-
-    for dependence in dependencies {
-      if dependence.getTargetIndex() == targetIndex {
-        return ResultDependencies(bridged: dependence,
-                                  parameterCount: parameters.count,
-                                  hasSelfParameter: hasSelfParameter)
-      }
-    }
-    return nil
+  /// If the function result depends on any parameters, return a Collection of LifetimeDependenceConventions for the
+  /// dependence source parameters.
+  public var resultDependencies: LifetimeDependencies? {
+    lifetimeDependencies(for: parameters.count)
+  }
+
+  /// If the parameter indexed by 'targetParameterIndex' is the target of any dependencies on other parameters, return a
+  /// Collection of LifetimeDependenceConventions for the dependence source parameters.
+  public func parameterDependencies(for targetParameterIndex: Int) -> LifetimeDependencies? {
+    lifetimeDependencies(for: targetParameterIndex)
+  }
+
+  public func hasLifetimeDependencies() -> Bool {
+    return bridgedFunctionType.SILFunctionType_getLifetimeDependencies().count() != 0
   }
 
   public var description: String {
@@ -248,28 +246,22 @@ public enum LifetimeDependenceConvention : CustomStringConvertible {
 }
 
 extension FunctionConvention {
-  struct LifetimeDependencies : Collection {
-    let bridged: BridgedLifetimeDependenceInfoArray
-
-    var startIndex: Int { 0 }
-
-    var endIndex: Int { bridged.count() }
-
-    func index(after index: Int) -> Int {
-      return index + 1
-    }
-    // Create a Swift LifetimeDependenceInfo for BridgedLifetimeDependenceInfo if this method needs
-    // to be exposed outside FunctionConvention.
-    // That will likely need bridging IndexSubset to Swift.
-    subscript(_ index: Int) -> BridgedLifetimeDependenceInfo {
-      return bridged.at(index)
+  // 'targetIndex' is either the parameter index or parameters.count for the function result.
+  private func lifetimeDependencies(for targetIndex: Int) -> LifetimeDependencies? {
+    let bridgedDependenceInfoArray = bridgedFunctionType.SILFunctionType_getLifetimeDependencies()
+    for infoIndex in 0..<bridgedDependenceInfoArray.count() {
+      let bridgedDependenceInfo = bridgedDependenceInfoArray.at(infoIndex)
+      if bridgedDependenceInfo.targetIndex == targetIndex {
+        return LifetimeDependencies(bridged: bridgedDependenceInfo,
+                                    parameterCount: parameters.count,
+                                    hasSelfParameter: hasSelfParameter)
+      }
     }
+    return nil
   }
-}
 
-extension FunctionConvention {
   /// Collection of LifetimeDependenceConvention? that parallels parameters.
-  public struct ResultDependencies : Collection, CustomStringConvertible {
+  public struct LifetimeDependencies : Collection, CustomStringConvertible {
     let bridged: BridgedLifetimeDependenceInfo
     let paramCount: Int
     let hasSelfParam: Bool