[JExtract/JNI] Add support for primitive non-escaping closures.

Samples/JExtractJNISampleApp/Sources/MySwiftLibrary/Closures.swift

@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+public func emptyClosure(closure: () -> ()) {
+  closure()
+}
+
+public func closureWithInt(input: Int64, closure: (Int64) -> Int64) -> Int64 {
+  return closure(input)
+}
+
+public func closureMultipleArguments(
+  input1: Int64,
+  input2: Int64,
+  closure: (Int64, Int64) -> Int64
+) -> Int64 {
+  return closure(input1, input2)
+}
+
+

Samples/JExtractJNISampleApp/src/test/java/com/example/swift/ClosuresTest.java

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 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
+//
+//===----------------------------------------------------------------------===//
+
+package com.example.swift;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ClosuresTest {
+    @Test
+    void emptyClosure() {
+        AtomicBoolean closureCalled = new AtomicBoolean(false);
+        MySwiftLibrary.emptyClosure(() -> {
+            closureCalled.set(true);
+        });
+        assertTrue(closureCalled.get());
+    }
+
+    @Test
+    void closureWithInt() {
+        long result = MySwiftLibrary.closureWithInt(10, (value) -> value * 2);
+        assertEquals(20, result);
+    }
+
+    @Test
+    void closureMultipleArguments() {
+        long result = MySwiftLibrary.closureMultipleArguments(5, 10, (a, b) -> a + b);
+        assertEquals(15, result);
+    }
+}

Sources/JExtractSwiftLib/Convenience/JavaType+Extensions.swift

@@ -17,21 +17,22 @@ import JavaTypes
 extension JavaType {
   var jniTypeSignature: String {
     switch self {
-    case .boolean: "Z"
-    case .byte: "B"
-    case .char: "C"
-    case .short: "S"
-    case .int: "I"
-    case .long: "J"
-    case .float: "F"
-    case .double: "D"
+    case .boolean: return "Z"
+    case .byte: return "B"
+    case .char: return "C"
+    case .short: return "S"
+    case .int: return "I"
+    case .long: return "J"
+    case .float: return "F"
+    case .double: return "D"
     case .class(let package, let name):
+      let nameWithInnerClasses = name.replacingOccurrences(of: ".", with: "$")
       if let package {
-        "L\(package.replacingOccurrences(of: ".", with: "/"))/\(name);"
+        return "L\(package.replacingOccurrences(of: ".", with: "/"))/\(nameWithInnerClasses);"
       } else {
-        "L\(name);"
+        return "L\(nameWithInnerClasses);"
       }
-    case .array(let javaType): "[\(javaType.jniTypeSignature)"
+    case .array(let javaType): return  "[\(javaType.jniTypeSignature)"
     case .void: fatalError("There is no type signature for 'void'")
     }
   }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -76,12 +76,12 @@ extension JNISwift2JavaGenerator {
 
       for decl in analysis.importedGlobalFuncs {
         self.logger.trace("Print global function: \(decl)")
-        printFunctionBinding(&printer, decl)
+        printFunctionDowncallMethods(&printer, decl)
         printer.println()
       }
 
       for decl in analysis.importedGlobalVariables {
-        printFunctionBinding(&printer, decl)
+        printFunctionDowncallMethods(&printer, decl)
         printer.println()
       }
     }
@@ -117,17 +117,17 @@ extension JNISwift2JavaGenerator {
       printer.println()
 
       for initializer in decl.initializers {
-        printFunctionBinding(&printer, initializer)
+        printFunctionDowncallMethods(&printer, initializer)
         printer.println()
       }
 
       for method in decl.methods {
-        printFunctionBinding(&printer, method)
+        printFunctionDowncallMethods(&printer, method)
         printer.println()
       }
 
       for variable in decl.variables {
-        printFunctionBinding(&printer, variable)
+        printFunctionDowncallMethods(&printer, variable)
         printer.println()
       }
 
@@ -175,12 +175,67 @@ extension JNISwift2JavaGenerator {
     }
   }
 
-  private func printFunctionBinding(_ printer: inout CodePrinter, _ decl: ImportedFunc) {
-    guard let translatedDecl = translatedDecl(for: decl) else {
+  private func printFunctionDowncallMethods(
+    _ printer: inout CodePrinter,
+    _ decl: ImportedFunc
+  ) {
+    guard translatedDecl(for: decl) != nil else {
       // Failed to translate. Skip.
       return
     }
 
+    printer.printSeparator(decl.displayName)
+
+    printJavaBindingWrapperHelperClass(&printer, decl)
+
+    printJavaBindingWrapperMethod(&printer, decl)
+  }
+
+  /// Print the helper type container for a user-facing Java API.
+  ///
+  /// * User-facing functional interfaces.
+  private func printJavaBindingWrapperHelperClass(
+    _ printer: inout CodePrinter,
+    _ decl: ImportedFunc
+  ) {
+    let translated = self.translatedDecl(for: decl)!
+    if translated.functionTypes.isEmpty {
+      return
+    }
+
+    printer.printBraceBlock(
+      """
+      public static class \(translated.name)
+      """
+    ) { printer in
+      for functionType in translated.functionTypes {
+        printJavaBindingWrapperFunctionTypeHelper(&printer, functionType)
+      }
+    }
+  }
+
+  /// Print "wrapper" functional interface representing a Swift closure type.
+  func printJavaBindingWrapperFunctionTypeHelper(
+    _ printer: inout CodePrinter,
+    _ functionType: TranslatedFunctionType
+  ) {
+    let apiParams = functionType.parameters.map(\.parameter.asParameter)
+
+    printer.print(
+        """
+        @FunctionalInterface
+        public interface \(functionType.name) {
+          \(functionType.result.javaType) apply(\(apiParams.joined(separator: ", ")));
+        }
+        """
+    )
+  }
+
+  private func printJavaBindingWrapperMethod(_ printer: inout CodePrinter, _ decl: ImportedFunc) {
+    guard let translatedDecl = translatedDecl(for: decl) else {
+      fatalError("Decl was not translated, \(decl)")
+    }
+
     var modifiers = ["public"]
     if decl.isStatic || decl.isInitializer || !decl.hasParent {
       modifiers.append("static")
@@ -215,7 +270,7 @@ extension JNISwift2JavaGenerator {
     if let selfParameter = nativeSignature.selfParameter {
       parameters.append(selfParameter)
     }
-    let renderedParameters = parameters.map { "\($0.javaParameter.type) \($0.javaParameter.name)"}.joined(separator: ", ")
+    let renderedParameters = parameters.map { "\($0.javaType) \($0.name)"}.joined(separator: ", ")
 
     printer.print("private static native \(resultType) \(translatedDecl.nativeFunctionName)(\(renderedParameters));")
   }