[JExtract] Bridge closures with UnsafeRawBufferPointer parameter

First step to bridging closures with conversions.

Author: rintaro

Samples/SwiftKitSampleApp/Sources/MySwiftLibrary/MySwiftLibrary.swift

@@ -53,6 +53,10 @@ public func globalReceiveRawBuffer(buf: UnsafeRawBufferPointer) -> Int {
 
 public var globalBuffer: UnsafeRawBufferPointer = UnsafeRawBufferPointer(UnsafeMutableRawBufferPointer.allocate(byteCount: 124, alignment: 1))
 
+public func withBuffer(body: (UnsafeRawBufferPointer) -> Void) {
+  body(globalBuffer)
+}
+
 // ==== Internal helpers
 
 func p(_ msg: String, file: String = #fileID, line: UInt = #line, function: String = #function) {

Samples/SwiftKitSampleApp/src/main/java/com/example/swift/HelloJava2Swift.java

@@ -47,6 +47,9 @@ static void examples() {
 
         SwiftKit.trace("getGlobalBuffer().byteSize()=" + MySwiftLibrary.getGlobalBuffer().byteSize());
 
+        MySwiftLibrary.withBuffer((buf) -> {
+            SwiftKit.trace("withBuffer{$0.byteSize()}=" + buf.byteSize());
+        });
         // Example of using an arena; MyClass.deinit is run at end of scope
         try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass obj = MySwiftClass.init(2222, 7777, arena);

Sources/JExtractSwiftLib/FFM/CDeclLowering/FFMSwift2JavaGenerator+FunctionLowering.swift

@@ -332,14 +332,15 @@ struct CdeclLowering {
     var parameters: [SwiftParameter] = []
     var parameterConversions: [ConversionStep] = []
 
-    for parameter in fn.parameters {
-      if let _ = try? CType(cdeclType: parameter.type) {
-        parameters.append(SwiftParameter(convention: .byValue, type: parameter.type))
-        parameterConversions.append(.placeholder)
-      } else {
-        // Non-trivial types are not yet supported.
-        throw LoweringError.unhandledType(.function(fn))
-      }
+    for (i, parameter) in fn.parameters.enumerated() {
+      let parameterName = parameter.parameterName ?? "_\(i)"
+      let loweredParam = try lowerClosureParameter(
+        parameter.type,
+        convention: parameter.convention,
+        parameterName: parameterName
+      )
+      parameters.append(contentsOf: loweredParam.cdeclParameters)
+      parameterConversions.append(loweredParam.conversion)
     }
 
     let resultType: SwiftType
@@ -352,15 +353,74 @@ struct CdeclLowering {
       throw LoweringError.unhandledType(.function(fn))
     }
 
-    // Ignore the conversions for now, since we don't support non-trivial types yet.
-    _ = (parameterConversions, resultConversion)
+    let isCompatibleWithC = parameterConversions.allSatisfy(\.isPlaceholder) && resultConversion.isPlaceholder
 
     return (
       type: .function(SwiftFunctionType(convention: .c, parameters: parameters, resultType: resultType)),
-      conversion: .placeholder
+      conversion: isCompatibleWithC ? .placeholder : .closureLowering(parameters: parameterConversions, result: resultConversion)
     )
   }
 
+  func lowerClosureParameter(
+    _ type: SwiftType,
+    convention: SwiftParameterConvention,
+    parameterName: String
+  ) throws -> LoweredParameter {
+    // If there is a 1:1 mapping between this Swift type and a C type, we just
+    // return it.
+    if let _ = try? CType(cdeclType: type) {
+      return LoweredParameter(
+        cdeclParameters: [
+          SwiftParameter(
+            convention: .byValue,
+            parameterName: parameterName,
+            type: type
+          ),
+        ],
+        conversion: .placeholder
+      )
+    }
+    
+    switch type {
+    case .nominal(let nominal):
+      if let knownType = nominal.nominalTypeDecl.knownStandardLibraryType {
+        switch knownType {
+        case .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer:
+          // pointer buffers are lowered to (raw-pointer, count) pair.
+          let isMutable = knownType == .unsafeMutableRawBufferPointer
+          return LoweredParameter(
+            cdeclParameters: [
+              SwiftParameter(
+                convention: .byValue,
+                parameterName: "\(parameterName)_pointer",
+                type: .optional(isMutable ? knownTypes.unsafeMutableRawPointer : knownTypes.unsafeRawPointer)
+              ),
+              SwiftParameter(
+                convention: .byValue,
+                parameterName: "\(parameterName)_count",
+                type: knownTypes.int
+              ),
+            ],
+            conversion: .tuplify([
+              .member(.placeholder, member: "baseAddress"),
+              .member(.placeholder, member: "count")
+            ])
+          )
+
+        default:
+          throw LoweringError.unhandledType(type)
+        }
+      }
+
+      // Custom types are not supported yet.
+      throw LoweringError.unhandledType(type)
+
+    case .function, .metatype, .optional, .tuple:
+      // TODO: Implement
+      throw LoweringError.unhandledType(type)
+    }
+  }
+
   /// Lower a Swift result type to cdecl out parameters and return type.
   ///
   /// - Parameters:

Sources/JExtractSwiftLib/FFM/ConversionStep.swift

@@ -58,6 +58,8 @@ enum ConversionStep: Equatable {
   /// Perform multiple conversions using the same input.
   case aggregate([ConversionStep], name: String?)
 
+  indirect case closureLowering(parameters: [ConversionStep], result: ConversionStep)
+
   indirect case member(ConversionStep, member: String)
 
   /// Count the number of times that the placeholder occurs within this
@@ -73,13 +75,20 @@ enum ConversionStep: Equatable {
       inner.placeholderCount
     case .initialize(_, arguments: let arguments):
       arguments.reduce(0) { $0 + $1.argument.placeholderCount }
-    case .placeholder, .tupleExplode:
+    case .placeholder, .tupleExplode, .closureLowering:
       1
     case .tuplify(let elements), .aggregate(let elements, _):
       elements.reduce(0) { $0 + $1.placeholderCount }
     }
   }
 
+  var isPlaceholder: Bool {
+    if case .placeholder = self {
+      return true
+    }
+    return false
+  }
+
   /// Convert the conversion step into an expression with the given
   /// value as the placeholder value in the expression.
   func asExprSyntax(placeholder: String, bodyItems: inout [CodeBlockItemSyntax]) -> ExprSyntax? {
@@ -165,6 +174,48 @@ enum ConversionStep: Equatable {
         }
       }
       return nil
+
+    case .closureLowering(let parameterSteps, let resultStep):
+      var body: [CodeBlockItemSyntax] = []
+
+      // Lower parameters.
+      var params: [String] = []
+      var args: [ExprSyntax] = []
+      for (i, parameterStep) in parameterSteps.enumerated() {
+        let paramName = "_\(i)"
+        params.append(paramName)
+        if case .tuplify(let elemSteps) = parameterStep {
+          for elemStep in elemSteps {
+            if let elemExpr = elemStep.asExprSyntax(placeholder: paramName, bodyItems: &body) {
+              args.append(elemExpr)
+            }
+          }
+        } else if let paramExpr = parameterStep.asExprSyntax(placeholder: paramName, bodyItems: &body) {
+          args.append(paramExpr)
+        }
+      }
+
+      // Call the lowered closure with lowered parameters.
+      let loweredResult = "\(placeholder)(\(args.map(\.description).joined(separator: ", ")))"
+
+      // Raise the lowered result.
+      let result = resultStep.asExprSyntax(placeholder: loweredResult.description, bodyItems: &body)
+      body.append("return \(result)")
+
+      // Construct the closure expression.
+      var closure = ExprSyntax(
+        """
+        { (\(raw: params.joined(separator: ", "))) in
+          }
+        """
+      ).cast(ClosureExprSyntax.self)
+
+      closure.statements = CodeBlockItemListSyntax {
+        body.map {
+          $0.with(\.leadingTrivia, [.newlines(1), .spaces(4)])
+        }
+      }
+      return ExprSyntax(closure)
     }
   }
 }

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -251,7 +251,6 @@ extension FFMSwift2JavaGenerator {
       )
     } else {
       // Otherwise, the lambda must be wrapped with the lowered function instance.
-      assertionFailure("should be unreachable at this point")
       let apiParams = functionType.parameters.flatMap {
         $0.javaParameters.map { param in "\(param.type) \(param.name)" }
       }
@@ -262,13 +261,38 @@ extension FFMSwift2JavaGenerator {
         public interface \(functionType.name) {
           \(functionType.result.javaResultType) apply(\(apiParams.joined(separator: ", ")));
         }
-        private static MemorySegment $toUpcallStub(\(functionType.name) fi, Arena arena) {
-          return \(cdeclDescriptor).toUpcallStub((<cdecl-params>) -> {
-            <maybe-return> fi(<converted-args>)
-          }, arena);
-        }
         """
       )
+
+      let cdeclParams = functionType.cdeclType.parameters.map( { "\($0.parameterName!)" })
+
+      printer.printBraceBlock(
+        """
+        private static MemorySegment $toUpcallStub(\(functionType.name) fi, Arena arena)
+        """
+      ) { printer in
+        printer.print(
+          """
+          return \(cdeclDescriptor).toUpcallStub((\(cdeclParams.joined(separator: ", "))) -> {
+          """
+        )
+        printer.indent()
+        var convertedArgs: [String] = []
+        for param in functionType.parameters {
+          let arg = param.conversion.render(&printer, param.javaParameters[0].name)
+          convertedArgs.append(arg)
+        }
+
+        let call = "fi.apply(\(convertedArgs.joined(separator: ", ")))"
+        let result = functionType.result.conversion.render(&printer, call)
+        if functionType.result.javaResultType == .void {
+          printer.print("\(result);")
+        } else {
+          printer.print("return \(result);")
+        }
+        printer.outdent()
+        printer.print("}, arena);")
+      }
     }
   }
 
@@ -419,7 +443,7 @@ extension JavaConversionStep {
   /// Whether the conversion uses SwiftArena.
   var requiresSwiftArena: Bool {
     switch self {
-    case .placeholder, .constant, .readOutParameter:
+    case .placeholder, .explodedName, .constant, .readMemorySegment:
       return false
     case .constructSwiftValue:
       return true
@@ -436,9 +460,9 @@ extension JavaConversionStep {
   /// Whether the conversion uses temporary Arena.
   var requiresTemporaryArena: Bool {
     switch self {
-    case .placeholder, .constant:
+    case .placeholder, .explodedName, .constant:
       return false
-    case .readOutParameter:
+    case .readMemorySegment:
       return true
     case .cast(let inner, _), .construct(let inner, _), .constructSwiftValue(let inner, _), .swiftValueSelfSegment(let inner):
       return inner.requiresSwiftArena
@@ -459,6 +483,9 @@ extension JavaConversionStep {
     case .placeholder:
       return placeholder
 
+    case .explodedName(let component):
+      return "\(placeholder)_\(component)"
+
     case .swiftValueSelfSegment:
       return "\(placeholder).$memorySegment()"
 
@@ -491,8 +518,9 @@ extension JavaConversionStep {
     case .constant(let value):
       return value
 
-    case .readOutParameter(let javaType, let name):
-      return "\(placeholder)_\(name).get(\(ForeignValueLayout(javaType: javaType)!), 0)"
+    case .readMemorySegment(let inner, let javaType):
+      let inner = inner.render(&printer, placeholder)
+      return "\(inner).get(\(ForeignValueLayout(javaType: javaType)!), 0)"
     }
   }
 }