jextract: Organize java known functional interfaces

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -255,21 +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
-      }
+      let (interfaceName, methodName) =
+        if let known = KnownJavaFunctionalInterface.find(parameters: cParameterTypes, result: cResultType) {
+          (known.javaType.description, known.method)
+        } else {
+          ("Function", "apply")
+        }
+
       printer.print(
         """
-        private static final MethodHandle HANDLE = SwiftRuntime.upcallHandle(Function.class, "apply", DESC);
-        private static MemorySegment toUpcallStub(Function fi, Arena arena) {
+        private static final MethodHandle HANDLE = SwiftRuntime.upcallHandle(\(interfaceName).class, "\(methodName)", DESC);
+        private static MemorySegment toUpcallStub(\(interfaceName) fi, Arena arena) {
           return Linker.nativeLinker().upcallStub(HANDLE.bindTo(fi), DESC, arena);
         }
         """

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+NativeTranslation.swift

@@ -1689,9 +1689,10 @@ extension JNISwift2JavaGenerator {
           $0.conversion.render(&printer, $0.parameters.first!.name)
         }
 
+
         let methodName =
-          if parameters.isEmpty && nativeResult.javaType.isVoid {
-            "run"
+          if let known = KnownJavaFunctionalInterface.find(methodSignature) {
+            known.method
           } else {
             "apply"
           }

Sources/JExtractSwiftLib/KnownFunctionalInterfaces.swift

@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift.org project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift.org project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftJavaJNICore
+
+/// Describes a known functional interface such as `Runnable.run()` and similar.
+struct KnownJavaFunctionalInterface: Sendable {
+  let javaType: JavaType
+  let method: String
+  let parameters: [JavaType]
+  let result: JavaType
+
+  static let runnable = KnownJavaFunctionalInterface(
+    JavaType.javaLangRunnable,
+    method: "run",
+    parameters: [],
+    result: .void
+  )
+
+  static let all: [KnownJavaFunctionalInterface] = [
+    .runnable
+  ]
+
+  static func find(parameters: [JavaType], result: JavaType) -> KnownJavaFunctionalInterface? {
+    all.first { $0.parameters == parameters && $0.result == result }
+  }
+
+  static func find(parameters: [CType], result: CType) -> KnownJavaFunctionalInterface? {
+    find(parameters: parameters.map(\.javaType), result: result.javaType)
+  }
+
+  static func find(_ methodSignature: MethodSignature) -> KnownJavaFunctionalInterface? {
+    find(parameters: methodSignature.parameterTypes, result: methodSignature.resultType)
+  }
+
+  init(_ javaType: JavaType, method: String, parameters: [JavaType], result: JavaType) {
+    self.javaType = javaType
+    self.method = method
+    self.parameters = parameters
+    self.result = result
+  }
+
+}