jextract: Translate Swift () -> () to java Runnable

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -255,6 +255,17 @@ extension FFMSwift2JavaGenerator {
       }
 
       printFunctionDescriptorDefinition(&printer, cResultType, cParams)
+      if cParameterTypes.isEmpty && cResultType.isVoid {
+        printer.print(
+          """
+          private static final MethodHandle HANDLE = SwiftRuntime.upcallHandle(java.lang.Runnable.class, "run", DESC);
+          private static MemorySegment toUpcallStub(java.lang.Runnable fi, Arena arena) {
+            return Linker.nativeLinker().upcallStub(HANDLE.bindTo(fi), DESC, arena);
+          }
+          """
+        )
+        return
+      }
       printer.print(
         """
         private static final MethodHandle HANDLE = SwiftRuntime.upcallHandle(Function.class, "apply", DESC);
@@ -296,6 +307,16 @@ extension FFMSwift2JavaGenerator {
   ) {
     let cdeclDescriptor = "\(bindingDescriptorName).$\(functionType.name)"
     if functionType.isCompatibleWithC {
+      if !functionType.swiftType.isEscaping && functionType.parameters.isEmpty && functionType.swiftType.resultType.isVoid {
+        printer.print(
+          """
+          private static MemorySegment $toUpcallStub(java.lang.Runnable fi, Arena arena) {
+            return \(bindingDescriptorName).$\(functionType.name).toUpcallStub(fi, arena);
+          }
+          """
+        )
+        return
+      }
       // If the user-facing functional interface is C ABI compatible, just extend
       // the lowered function pointer parameter interface.
       printer.print(

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaTranslation.swift

@@ -489,13 +489,11 @@ extension FFMSwift2JavaGenerator {
           genericRequirements: genericRequirements
         )
 
-      case .function:
-        return TranslatedParameter(
-          parameter: JavaParameter(
-            name: parameterName,
-            type: JavaType.class(package: nil, name: "\(methodName).\(parameterName)")
-          ),
-          conversion: .call(.placeholder, function: "\(methodName).$toUpcallStub", withArena: true)
+      case .function(let functionType):
+        return translateFunctionParameter(
+          functionType: functionType,
+          parameterName: parameterName,
+          methodName: methodName
         )
 
       case .existential, .opaque, .genericParameter:
@@ -568,6 +566,35 @@ extension FFMSwift2JavaGenerator {
       )
     }
 
+    // Extract Java known functional interface type or null if not exists
+    func extractKnownJavaFunctionalInterfaceType(
+      functionType: SwiftFunctionType,
+    ) -> JavaType? {
+      if functionType.parameters.isEmpty && functionType.resultType.isVoid {
+        JavaType.javaLangRunnable
+      } else {
+        nil
+      }
+    }
+
+    /// Translate a Swift Function parameter to the Java interface.
+    func translateFunctionParameter(
+      functionType: SwiftFunctionType,
+      parameterName: String,
+      methodName: String,
+    ) -> TranslatedParameter {
+      let parameterType =
+        extractKnownJavaFunctionalInterfaceType(functionType: functionType) ?? JavaType.class(package: nil, name: "\(methodName).\(parameterName)")
+
+      return TranslatedParameter(
+        parameter: JavaParameter(
+          name: parameterName,
+          type: parameterType
+        ),
+        conversion: .call(.placeholder, function: "\(methodName).$toUpcallStub", withArena: true)
+      )
+    }
+
     /// Translate an Optional Swift API parameter to the user-facing Java API parameter.
     func translateOptionalParameter(
       wrappedType swiftType: SwiftType,

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -516,17 +516,14 @@ extension JNISwift2JavaGenerator {
           conversion: .placeholder,
         )
 
-      case .function:
-        return TranslatedParameter(
-          parameter: JavaParameter(
-            name: parameterName,
-            type: .class(
-              package: javaPackage,
-              name: String.javaQualifiedName(parentName.fullName, methodName, parameterName)
-            ),
-            annotations: parameterAnnotations,
-          ),
-          conversion: .placeholder,
+      case .function(let functionType):
+        return translateFunctionParameter(
+          swiftType: swiftType,
+          functionType: functionType,
+          parameterName: parameterName,
+          methodName: methodName,
+          parentName: parentName,
+          parameterAnnotations: parameterAnnotations
         )
 
       case .opaque(let proto), .existential(let proto):
@@ -699,6 +696,52 @@ extension JNISwift2JavaGenerator {
       nativeFunctionSignature.result.outParameters.append(.init(name: "result_future", type: nativeFutureType))
     }
 
+    func extractKnownJavaFunctionalInterfaceType(
+      swiftType: SwiftType,
+      functionType: SwiftFunctionType,
+      parameterName: String,
+      parameterAnnotations: [JavaAnnotation]
+    ) -> TranslatedParameter? {
+      if !functionType.isEscaping && functionType.parameters.isEmpty && functionType.resultType.isVoid {
+        return TranslatedParameter(
+          parameter: JavaParameter(
+            name: parameterName,
+            type: JavaType.javaLangRunnable,
+            annotations: parameterAnnotations,
+          ),
+          conversion: .placeholder,
+        )
+      }
+      return nil
+    }
+
+    func translateFunctionParameter(
+      swiftType: SwiftType,
+      functionType: SwiftFunctionType,
+      parameterName: String,
+      methodName: String,
+      parentName: SwiftQualifiedTypeName,
+      parameterAnnotations: [JavaAnnotation]
+    ) -> TranslatedParameter {
+      extractKnownJavaFunctionalInterfaceType(
+        swiftType: swiftType,
+        functionType: functionType,
+        parameterName: parameterName,
+        parameterAnnotations: parameterAnnotations
+      )
+        ?? TranslatedParameter(
+          parameter: JavaParameter(
+            name: parameterName,
+            type: .class(
+              package: javaPackage,
+              name: String.javaQualifiedName(parentName.fullName, methodName, parameterName)
+            ),
+            annotations: parameterAnnotations,
+          ),
+          conversion: .placeholder,
+        )
+    }
+
     func translateProtocolParameter(
       protocolType: SwiftType,
       parameterName: String,