[JExtract] Import any C compatible closure

Generalized closure parameter import, part 1. Start with C-compatible
closures which don't need any conversions.

Author: rintaro

Samples/SwiftKitSampleApp/Sources/MySwiftLibrary/MySwiftStruct.swift

@@ -48,6 +48,10 @@ public struct MySwiftStruct {
     self.len
   }
 
+  public func withCapLen(_ body: (Int, Int) -> Void) {
+    body(cap, len)
+  }
+
   public mutating func increaseCap(by value: Int) -> Int {
     precondition(value > 0)
      self.cap += value

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

@@ -67,6 +67,9 @@ static void examples() {
 
             MySwiftStruct swiftValue = MySwiftStruct.init(2222, 1111, arena);
             SwiftKit.trace("swiftValue.capacity = " + swiftValue.getCapacity());
+            swiftValue.withCapLen((cap, len) -> {
+                SwiftKit.trace("withCapLenCallback: cap=" + cap + ", len=" + len);
+            });
         }
 
         System.out.println("DONE.");

Samples/SwiftKitSampleApp/src/test/java/com/example/swift/MySwiftLibraryTest.java

@@ -64,11 +64,9 @@ void call_writeString_jni() {
     void call_globalCallMeRunnable() {
         CountDownLatch countDownLatch = new CountDownLatch(3);
 
-        MySwiftLibrary.globalCallMeRunnable(new Runnable() {
-            @Override
-            public void run() {
-                countDownLatch.countDown();
-            }
+        MySwiftLibrary.globalCallMeRunnable.run fn = () -> {};
+        MySwiftLibrary.globalCallMeRunnable(() -> {
+            countDownLatch.countDown();
         });
         assertEquals(2, countDownLatch.getCount());
 

Sources/JExtractSwift/CDeclLowering/Swift2JavaTranslator+FunctionLowering.swift

@@ -276,25 +276,59 @@ struct CdeclLowering {
       }
       return LoweredParameter(cdeclParameters: parameters, conversion: .tuplify(conversions))
 
-    case .function(let fn) where fn.parameters.isEmpty && fn.resultType.isVoid:
+    case .function(let fn):
+      let (loweredTy, conversion) = try lowerFunctionType(fn)
       return LoweredParameter(
         cdeclParameters: [
           SwiftParameter(
             convention: .byValue,
             parameterName: parameterName,
-            type: .function(SwiftFunctionType(convention: .c, parameters: [], resultType: fn.resultType))
+            type: loweredTy
           )
         ],
-        // '@convention(c) () -> ()' is compatible with '() -> Void'.
-        conversion: .placeholder
+        conversion: conversion
       )
 
-    case .function, .optional:
-      // FIXME: Support other function types than '() -> Void'.
+    case .optional:
       throw LoweringError.unhandledType(type)
     }
   }
 
+  func lowerFunctionType(
+    _ fn: SwiftFunctionType
+  ) throws -> (type: SwiftType, conversion: ConversionStep) {
+    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))
+      }
+    }
+
+    let resultType: SwiftType
+    let resultConversion: ConversionStep
+    if let _ = try? CType(cdeclType: fn.resultType) {
+      resultType = fn.resultType
+      resultConversion = .placeholder
+    } else {
+      // Non-trivial types are not yet supported.
+      throw LoweringError.unhandledType(.function(fn))
+    }
+
+    // Ignore the conversions for now, since we don't support non-trivial types yet.
+    _ = (parameterConversions, resultConversion)
+
+    return (
+      type: .function(SwiftFunctionType(convention: .c, parameters: parameters, resultType: resultType)),
+      conversion: .placeholder
+    )
+  }
+
   /// Lower a Swift result type to cdecl out parameters and return type.
   ///
   /// - Parameters:

Sources/JExtractSwift/Swift2JavaTranslator+JavaBindingsPrinting.swift

@@ -19,7 +19,7 @@ extension Swift2JavaTranslator {
     _ printer: inout CodePrinter,
     _ decl: ImportedFunc
   ) {
-    guard let _ = translatedSignature(for: decl) else {
+    guard let _ = translatedDecl(for: decl) else {
       // Failed to translate. Skip.
       return
     }
@@ -28,6 +28,8 @@ extension Swift2JavaTranslator {
 
     printJavaBindingDescriptorClass(&printer, decl)
 
+    printJavaBindingWrapperHelperClass(&printer, decl)
+
     // Render the "make the downcall" functions.
     printJavaBindingWrapperMethod(&printer, decl)
   }
@@ -38,9 +40,9 @@ extension Swift2JavaTranslator {
     _ decl: ImportedFunc
   ) {
     let thunkName = thunkNameRegistry.functionThunkName(decl: decl)
-    let translatedSignature = self.translatedSignature(for: decl)!
+    let translated = self.translatedDecl(for: decl)!
     // 'try!' because we know 'loweredSignature' can be described with C.
-    let cFunc = try! translatedSignature.loweredSignature.cFunctionDecl(cName: thunkName)
+    let cFunc = try! translated.loweredSignature.cFunctionDecl(cName: thunkName)
 
     printer.printBraceBlock(
       """
@@ -52,37 +54,39 @@ extension Swift2JavaTranslator {
       private static class \(cFunc.name)
       """
     ) { printer in
-      printFunctionDescriptorValue(&printer, cFunc)
+      printFunctionDescriptorDefinition(&printer, cFunc.resultType, cFunc.parameters)
       printer.print(
         """
-        public static final MemorySegment ADDR =
+        private static final MemorySegment ADDR =
           \(self.swiftModuleName).findOrThrow("\(cFunc.name)");
-        public static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC);
+        private static final MethodHandle HANDLE = Linker.nativeLinker().downcallHandle(ADDR, DESC);
         """
       )
       printJavaBindingDowncallMethod(&printer, cFunc)
+      printParameterDescriptorClasses(&printer, cFunc)
     }
   }
 
   /// Print the 'FunctionDescriptor' of the lowered cdecl thunk.
-  func printFunctionDescriptorValue(
+  func printFunctionDescriptorDefinition(
     _ printer: inout CodePrinter,
-    _ cFunc: CFunction
+    _ resultType: CType,
+    _ parameters: [CParameter]
   ) {
-    printer.start("public static final FunctionDescriptor DESC = ")
+    printer.start("private static final FunctionDescriptor DESC = ")
 
-    let isEmptyParam = cFunc.parameters.isEmpty
-    if cFunc.resultType.isVoid {
+    let isEmptyParam = parameters.isEmpty
+    if resultType.isVoid {
       printer.print("FunctionDescriptor.ofVoid(", isEmptyParam ? .continue : .newLine)
       printer.indent()
     } else {
       printer.print("FunctionDescriptor.of(")
       printer.indent()
       printer.print("/* -> */", .continue)
-      printer.print(cFunc.resultType.foreignValueLayout, .parameterNewlineSeparator(isEmptyParam))
+      printer.print(resultType.foreignValueLayout, .parameterNewlineSeparator(isEmptyParam))
     }
 
-    for (param, isLast) in cFunc.parameters.withIsLast {
+    for (param, isLast) in parameters.withIsLast {
       printer.print("/* \(param.name ?? "_"): */", .continue)
       printer.print(param.type.foreignValueLayout, .parameterNewlineSeparator(isLast))
     }
@@ -124,16 +128,143 @@ extension Swift2JavaTranslator {
     )
   }
 
+  func printParameterDescriptorClasses(
+    _ printer: inout CodePrinter,
+    _ cFunc: CFunction
+  ) {
+    for param in cFunc.parameters {
+      switch param.type {
+      case .pointer(.function):
+        let name = "$\(param.name!)"
+        printFunctionPointerParameterDescriptorClass(&printer, name, param.type)
+      default:
+        continue
+      }
+    }
+  }
+
+  /// Print a class describing a closure parameter type.
+  ///   ```
+  ///   class <paramter-name> {
+  ///     interface Function {
+  ///       <return-type> apply(<parameters>);
+  ///     }
+  ///     static final MethodDescriptor DESC = FunctionDescriptor.of(...);s
+  ///     static final MethodHandle HANDLE = SwiftKit.upcallHandle(Function.class, "apply", DESC);
+  ///     static MemorySegment toUpcallStub(Function fi, Arena arena) {
+  ///       return Linker.nativeLinker().upcallStub(HANDLE.bindTo(fi), DESC, arena);
+  ///     }
+  ///   }
+  ///   ```
+  func printFunctionPointerParameterDescriptorClass(
+    _ printer: inout CodePrinter,
+    _ name: String,
+    _ cType: CType
+  ) {
+    guard case .pointer(.function(let cResultType, let cParameterTypes, variadic: false)) = cType else {
+      preconditionFailure("must be a C function pointer type")
+    }
+
+    let cParams = cParameterTypes.enumerated().map { i, ty in
+      CParameter(name: "_\(i)", type: ty)
+    }
+    let paramDecls = cParams.map({"\($0.type.javaType) \($0.name!)"})
+
+    printer.printBraceBlock(
+      """
+      /**
+       * {snippet lang=c :
+       * \(cType)
+       * }
+       */
+      private static class \(name)
+      """
+    ) { printer in
+      printer.print(
+        """
+        public interface Function {
+          \(cResultType.javaType) apply(\(paramDecls.joined(separator: ", ")));
+        }
+        """
+      )
+      printFunctionDescriptorDefinition(&printer, cResultType, cParams)
+      printer.print(
+        """
+        private static final MethodHandle HANDLE = SwiftKit.upcallHandle(Function.class, "apply", DESC);
+        private static MemorySegment toUpcallStub(Function fi, Arena arena) {
+          return Linker.nativeLinker().upcallStub(HANDLE.bindTo(fi), DESC, arena);
+        }
+        """
+      )
+    }
+  }
+
+  func printJavaBindingWrapperHelperClass(
+    _ printer: inout CodePrinter,
+    _ decl: ImportedFunc
+  ) {
+    let translated = self.translatedDecl(for: decl)!
+    let bindingDescriptorName = self.thunkNameRegistry.functionThunkName(decl: decl)
+    if translated.functionTypes.isEmpty {
+      return
+    }
+
+    printer.printBraceBlock(
+      """
+      private static class \(translated.name)
+      """
+    ) { printer in
+      for functionType in translated.functionTypes {
+        printJavaBindingWrapperFunctionTypeHelper(&printer, functionType, bindingDescriptorName)
+      }
+    }
+  }
+
+  func printJavaBindingWrapperFunctionTypeHelper(
+    _ printer: inout CodePrinter,
+    _ functionType: TranslatedFunctionType,
+    _ bindingDescriptorName: String
+  ) {
+    let cdeclDescritor = "\(bindingDescriptorName).$\(functionType.name)"
+    if functionType.isTrivial {
+      printer.print(
+        """
+        public interface \(functionType.name) extends \(cdeclDescritor).Function {
+          default MemorySegment toUpcallStub(Arena arena) {
+            return \(bindingDescriptorName).$\(functionType.name).toUpcallStub(this, arena);
+          }
+        }
+        """
+      )
+    } else {
+      assertionFailure("should be unreachable at this point")
+      let apiParams = functionType.parameters.flatMap {
+        $0.javaParameters.map { param in "\(param.type) \(param.name)" }
+      }
+
+      printer.print(
+        """
+        public interface \(functionType.name) {
+          \(functionType.result.javaResultType) apply(\(apiParams.joined(separator: ", ")));
+          private default MemorySegment toUpcallStub(Arena arena) {
+            return \(cdeclDescritor).toUpcallStub((<cdecl-params>) -> {
+              <maybe-return> fi(<converted-args>)
+            }, arena);
+          }
+        }
+        """
+      )
+    }
+  }
+
   /// Print the calling body that forwards all the parameters to the `methodName`,
   /// with adding `SwiftArena.ofAuto()` at the end.
   public func printJavaBindingWrapperMethod(
     _ printer: inout CodePrinter,
-    _ decl: ImportedFunc) {
-    let methodName: String = switch decl.apiKind {
-    case .getter: "get\(decl.name.toCamelCase)"
-    case .setter: "set\(decl.name.toCamelCase)"
-    case .function, .initializer: decl.name
-    }
+    _ decl: ImportedFunc
+  ) {
+    let translated = self.translatedDecl(for: decl)!
+    let methodName = translated.name
 
     var modifiers = "public"
     switch decl.functionSignature.selfParameter {
@@ -143,7 +274,7 @@ extension Swift2JavaTranslator {
       break
     }
 
-    let translatedSignature = self.translatedSignature(for: decl)!
+    let translatedSignature = translated.translatedSignature
     let returnTy = translatedSignature.result.javaResultType
 
     var paramDecls = translatedSignature.parameters
@@ -182,7 +313,7 @@ extension Swift2JavaTranslator {
     _ decl: ImportedFunc
   ) {
     //===  Part 1: prepare temporary arena if needed.
-    let translatedSignature = self.translatedSignature(for: decl)!
+    let translatedSignature = self.translatedDecl(for: decl)!.translatedSignature
 
     if translatedSignature.requiresTemporaryArena {
       printer.print("try(var arena$ = Arena.ofConfined()) {")
@@ -273,7 +404,7 @@ extension JavaConversionStep {
   /// Whether the conversion uses SwiftArena.
   var requiresSwiftArena: Bool {
     switch self {
-    case .pass, .swiftValueSelfSegment, .construct, .cast, .call:
+    case .pass, .swiftValueSelfSegment, .construct, .cast, .call, .method:
       return false
     case .constructSwiftValue:
       return true
@@ -285,7 +416,7 @@ extension JavaConversionStep {
     switch self {
     case .pass, .swiftValueSelfSegment, .construct, .constructSwiftValue, .cast:
       return false
-    case .call(_, let withArena):
+    case .call(_, let withArena), .method(_, _, let withArena):
       return withArena
     }
   }
@@ -297,7 +428,7 @@ extension JavaConversionStep {
     switch self {
     case .pass, .swiftValueSelfSegment:
       return true
-    case .cast, .construct, .constructSwiftValue, .call:
+    case .cast, .construct, .constructSwiftValue, .call, .method:
       return false
     }
   }
@@ -317,6 +448,10 @@ extension JavaConversionStep {
       let arenaArg = withArena ? ", arena$" : ""
       return "\(function)(\(placeholder)\(arenaArg))"
 
+    case .method(let methodName, let arguments, let withArena):
+      let argsStr = (arguments + (withArena ? ["arena$"] : [])).joined(separator: " ,")
+      return "\(placeholder).\(methodName)(\(argsStr))"
+
     case .constructSwiftValue(let javaType):
       return "new \(javaType.className!)(\(placeholder), swiftArena$)"