[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/SwiftAndJavaJarSampleLib/src/test/java/com/example/swift/MySwiftLibraryTest.java

@@ -43,9 +43,9 @@ void call_globalTakeInt() {
     void call_globalCallMeRunnable() {
         CountDownLatch countDownLatch = new CountDownLatch(3);
 
-        MySwiftLibrary.globalCallMeRunnable(new Runnable() {
+        MySwiftLibrary.globalCallMeRunnable(new MySwiftLibrary.globalCallMeRunnable.run() {
             @Override
-            public void run() {
+            public void apply() {
                 countDownLatch.countDown();
             }
         });

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,9 +64,9 @@ void call_writeString_jni() {
     void call_globalCallMeRunnable() {
         CountDownLatch countDownLatch = new CountDownLatch(3);
 
-        MySwiftLibrary.globalCallMeRunnable(new Runnable() {
+        MySwiftLibrary.globalCallMeRunnable(new MySwiftLibrary.globalCallMeRunnable.run() {
             @Override
-            public void run() {
+            public void apply() {
                 countDownLatch.countDown();
             }
         });

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

@@ -116,7 +116,7 @@ struct CdeclLowering {
     )
   }
 
-  /// Lower a Swift function parameter type to cdecl parameters.
+  /// Lower a Swift function parameter to cdecl parameters.
   ///
   /// For example, Swift parameter `arg value: inout Int` can be lowered with
   /// `lowerParameter(intTy, .inout, "value")`.
@@ -276,25 +276,63 @@ 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)
     }
   }
 
+  /// Lower a Swift function type (i.e. closure) to cdecl function type.
+  ///
+  /// - Parameters:
+  ///   - fn: the Swift function type to lower.
+  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: