Bridge YieldInfo

Author: atrick

SwiftCompilerSources/Sources/SIL/ApplySite.swift

@@ -140,13 +140,8 @@ extension ApplySite {
   }
 
   public var calleeArgumentConventions: ArgumentConventions {
-    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)
+    ArgumentConventions(originalFunctionConvention: originalFunctionConvention,
+                        substitutedFunctionConvention: substitutedFunctionConvention)
   }
 
   public var operandConventions: ApplyOperandConventions {
@@ -155,14 +150,6 @@ extension ApplySite {
       unappliedArgumentCount: bridged.PartialApply_getCalleeArgIndexOfFirstAppliedArg())
   }
 
-  /// Returns the argument index of an operand.
-  ///
-  /// Returns nil if 'operand' is not an argument operand. This is the case if
-  /// it's the callee function operand.
-  public func calleeArgumentIndex(of operand: Operand) -> Int? {
-    operandConventions.calleeArgumentIndex(of: operand)
-  }
-
   /// Returns true if `operand` is the callee function operand and not am argument operand.
   public func isCallee(operand: Operand) -> Bool {
     operandConventions.isCallee(operand: operand)
@@ -171,6 +158,17 @@ extension ApplySite {
   public func convention(of operand: Operand) -> ArgumentConvention? {
     operandConventions.convention(of: operand)
   }
+  
+  public var yieldConventions: YieldConventions {
+    YieldConventions(originalFunctionConvention: originalFunctionConvention,
+                     substitutedFunctionConvention: substitutedFunctionConvention)
+  }
+
+  public func convention(of yield: MultipleValueInstructionResult)
+    -> ArgumentConvention {
+    assert(yield.definingInstruction == self)
+    return yieldConventions[yield.index]
+  }
 
   /// Converts an argument index of a callee to the corresponding apply operand.
   ///
@@ -204,6 +202,29 @@ extension ApplySite {
     }
     return false
   }
+
+  /// Returns the argument index of an operand.
+  ///
+  /// Returns nil if 'operand' is not an argument operand. This is the case if
+  /// it's the callee function operand.
+  ///
+  /// Warning: the returned integer can be misused as an index into
+  /// the wrong collection. Replace uses of this API with safer APIs.
+  public func calleeArgumentIndex(of operand: Operand) -> Int? {
+    operandConventions.calleeArgumentIndex(of: operand)
+  }
+}
+
+extension ApplySite {
+  private var originalFunctionConvention: FunctionConvention {
+    FunctionConvention(for: callee.type.bridged.getASTType(),
+                       in: parentFunction)
+  }
+
+  private var substitutedFunctionConvention: FunctionConvention {
+    FunctionConvention(for: bridged.ApplySite_getSubstitutedCalleeType(),
+                       in: parentFunction)
+  }
 }
 
 public protocol FullApplySite : ApplySite {

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -239,6 +239,41 @@ public struct ArgumentConventions : Collection, CustomStringConvertible {
   }
 }
 
+public struct YieldConventions : Collection, CustomStringConvertible {
+  public let originalFunctionConvention: FunctionConvention
+  public let substitutedFunctionConvention: FunctionConvention?
+
+  public var yields: FunctionConvention.Yields {
+    if let substitutedFunctionConvention {
+      return substitutedFunctionConvention.yields
+    }
+    return originalFunctionConvention.yields
+  }
+
+  public var startIndex: Int { 0 }
+
+  public var endIndex: Int { yields.count }
+
+  public func index(after index: Int) -> Int {
+    return index + 1
+  }
+
+  public subscript(_ index: Int) -> ArgumentConvention {
+    return yields[index].convention
+  }
+
+  public var description: String {
+    var str = String(taking: originalFunctionConvention.bridgedFunctionType.getDebugDescription())
+    if let substitutedFunctionConvention {
+      str += "\n" + String(taking: substitutedFunctionConvention.bridgedFunctionType.getDebugDescription())
+    }
+    yields.forEach {
+      str += "\n      yield: " + $0.description
+    }
+    return str
+  }
+}
+
 public enum ArgumentConvention : CustomStringConvertible {
   /// This argument is passed indirectly, i.e. by directly passing the address
   /// of an object in memory.  The callee is responsible for destroying the

SwiftCompilerSources/Sources/SIL/FunctionConvention.swift

@@ -98,6 +98,29 @@ public struct FunctionConvention : CustomStringConvertible {
     bridgedFunctionType.SILFunctionType_hasSelfParam()
   }
 
+  public struct Yields : Collection {
+    let bridged: BridgedYieldInfoArray
+    let hasLoweredAddresses: Bool
+
+    public var startIndex: Int { 0 }
+
+    public var endIndex: Int { bridged.count() }
+
+    public func index(after index: Int) -> Int {
+      return index + 1
+    }
+
+    public subscript(_ index: Int) -> ParameterInfo {
+      return ParameterInfo(bridged: bridged.at(index),
+        hasLoweredAddresses: hasLoweredAddresses)
+    }
+  }
+
+  public var yields: Yields {
+    Yields(bridged: bridgedFunctionType.SILFunctionType_getYields(),
+      hasLoweredAddresses: hasLoweredAddresses)
+  }
+
   public var description: String {
     var str = String(taking: bridgedFunctionType.getDebugDescription())
     parameters.forEach { str += "\nparameter: " + $0.description }
@@ -145,8 +168,9 @@ public struct ParameterInfo : CustomStringConvertible {
   public let hasLoweredAddresses: Bool
 
   /// Is this parameter passed indirectly in SIL? Most formally
-  /// indirect results can be passed directly in SIL. This depends on
-  /// whether the calling function has lowered addresses.
+  /// indirect results can be passed directly in SIL (opaque values
+  /// mode). This depends on whether the calling function has lowered
+  /// addresses.
   public var isSILIndirect: Bool {
     switch convention {
     case .indirectIn, .indirectInGuaranteed:

include/swift/SIL/SILBridging.h

@@ -181,6 +181,24 @@ struct BridgedParameterInfoArray {
   BridgedParameterInfo at(SwiftInt parameterIndex) const;
 };
 
+struct BridgedYieldInfoArray {
+  BridgedArrayRef yieldInfoArray;
+
+#ifdef USED_IN_CPP_SOURCE
+  BridgedYieldInfoArray(llvm::ArrayRef<swift::SILYieldInfo> yields)
+    : yieldInfoArray(yields) {}
+
+  llvm::ArrayRef<swift::SILYieldInfo> unbridged() const {
+    return yieldInfoArray.unbridged<swift::SILYieldInfo>();
+  }
+#endif
+
+  BRIDGED_INLINE SwiftInt count() const;
+
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE
+  BridgedParameterInfo at(SwiftInt resultIndex) const;
+};
+
 // Temporary access to the AST type within SIL until ASTBridging provides it.
 struct BridgedASTType {
   swift::TypeBase * _Nullable type;
@@ -215,6 +233,9 @@ struct BridgedASTType {
   BridgedParameterInfoArray SILFunctionType_getParameters() const;
 
   BRIDGED_INLINE bool SILFunctionType_hasSelfParam() const;
+
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE
+  BridgedYieldInfoArray SILFunctionType_getYields() const;
 };
 
 struct BridgedType {

include/swift/SIL/SILBridgingImpl.h

@@ -53,6 +53,18 @@ BridgedResultInfo BridgedResultInfoArray::at(SwiftInt resultIndex) const {
   return BridgedResultInfo(unbridged()[resultIndex]);
 }
 
+//===----------------------------------------------------------------------===//
+//                             BridgedYieldInfo
+//===----------------------------------------------------------------------===//
+
+SwiftInt BridgedYieldInfoArray::count() const {
+  return unbridged().size();
+}
+
+BridgedParameterInfo BridgedYieldInfoArray::at(SwiftInt resultIndex) const {
+  return BridgedParameterInfo(unbridged()[resultIndex]);
+}
+
 //===----------------------------------------------------------------------===//
 //                            BridgedParameterInfo
 //===----------------------------------------------------------------------===//
@@ -110,6 +122,10 @@ bool BridgedASTType::SILFunctionType_hasSelfParam() const {
   return unbridged()->castTo<swift::SILFunctionType>()->hasSelfParam();
 }
 
+BridgedYieldInfoArray BridgedASTType::SILFunctionType_getYields() const {
+  return unbridged()->castTo<swift::SILFunctionType>()->getYields();
+}
+
 //===----------------------------------------------------------------------===//
 //                                BridgedType
 //===----------------------------------------------------------------------===//