work on importing closures

Author: madsodgaard

Samples/JExtractJNISampleApp/Sources/MySwiftLibrary/Closures.swift

@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// 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)
+}
+
+

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

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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);
+    }
+}

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,13 +175,68 @@ extension JNISwift2JavaGenerator {
     }
   }
 
-  private func printFunctionBinding(_ printer: inout CodePrinter, _ decl: ImportedFunc) {
+  private func printFunctionDowncallMethods(
+    _ printer: inout CodePrinter,
+    _ decl: ImportedFunc
+  ) {
     guard let translatedDecl = translatedDecl(for: decl) else {
       // Failed to translate. Skip.
       return
     }
 
-    var modifiers = ["public"]
+    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));")
   }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -24,7 +24,7 @@ extension JNISwift2JavaGenerator {
 
     let translated: TranslatedFunctionDecl?
     do {
-      let translation = JavaTranslation(swiftModuleName: swiftModuleName)
+      let translation = JavaTranslation(swiftModuleName: swiftModuleName, javaPackage: self.javaPackage)
       translated = try translation.translate(decl)
     } catch {
       self.logger.debug("Failed to translate: '\(decl.swiftDecl.qualifiedNameForDebug)'; \(error)")
@@ -37,17 +37,10 @@ extension JNISwift2JavaGenerator {
 
   struct JavaTranslation {
     let swiftModuleName: String
+    let javaPackage: String
 
     func translate(_ decl: ImportedFunc) throws -> TranslatedFunctionDecl {
-      let nativeTranslation = NativeJavaTranslation()
-
-      // Swift -> Java
-      let translatedFunctionSignature = try translate(functionSignature: decl.functionSignature)
-      // Java -> Java (native)
-      let nativeFunctionSignature = try nativeTranslation.translate(
-        functionSignature: decl.functionSignature,
-        translatedFunctionSignature: translatedFunctionSignature
-      )
+      let nativeTranslation = NativeJavaTranslation(javaPackage: self.javaPackage)
 
       // Types with no parent will be outputted inside a "module" class.
       let parentName = decl.parentType?.asNominalType?.nominalTypeDecl.qualifiedName ?? swiftModuleName
@@ -59,27 +52,91 @@ extension JNISwift2JavaGenerator {
       case .function, .initializer: decl.name
       }
 
+      // Swift -> Java
+      let translatedFunctionSignature = try translate(
+        functionSignature: decl.functionSignature,
+        methodName: javaName,
+        parentName: parentName
+      )
+      // Java -> Java (native)
+      let nativeFunctionSignature = try nativeTranslation.translate(
+        functionSignature: decl.functionSignature,
+        translatedFunctionSignature: translatedFunctionSignature,
+        methodName: javaName,
+        parentName: parentName
+      )
+
+      // Closures.
+      var funcTypes: [TranslatedFunctionType] = []
+      for (idx, param) in decl.functionSignature.parameters.enumerated() {
+        let parameterName = param.parameterName ?? "_\(idx)"
+
+        switch param.type {
+        case .function(let funcTy):
+          let translatedClosure = try translateFunctionType(
+            name: parameterName,
+            swiftType: funcTy,
+            parentName: parentName
+          )
+          funcTypes.append(translatedClosure)
+        default:
+          break
+        }
+      }
+
       return TranslatedFunctionDecl(
         name: javaName,
         nativeFunctionName: "$\(javaName)",
         parentName: parentName,
+        functionTypes: funcTypes,
         translatedFunctionSignature: translatedFunctionSignature,
         nativeFunctionSignature: nativeFunctionSignature
       )
     }
 
-    func translate(functionSignature: SwiftFunctionSignature) throws -> TranslatedFunctionSignature {
+    /// Translate Swift closure type to Java functional interface.
+    func translateFunctionType(
+      name: String,
+      swiftType: SwiftFunctionType,
+      parentName: String
+    ) throws -> TranslatedFunctionType {
+      var translatedParams: [TranslatedParameter] = []
+
+      for (i, param) in swiftType.parameters.enumerated() {
+        let paramName = param.parameterName ?? "_\(i)"
+        translatedParams.append(
+          try translateParameter(swiftType: param.type, parameterName: paramName, methodName: name, parentName: parentName)
+        )
+      }
+
+      let transltedResult = try translate(swiftResult: SwiftResult(convention: .direct, type: swiftType.resultType))
+
+      return TranslatedFunctionType(
+        name: name,
+        parameters: translatedParams,
+        result: transltedResult,
+        swiftType: swiftType
+      )
+    }
+
+    func translate(
+      functionSignature: SwiftFunctionSignature,
+      methodName: String,
+      parentName: String
+    ) throws -> TranslatedFunctionSignature {
       let parameters = try functionSignature.parameters.enumerated().map { idx, param in
         let parameterName = param.parameterName ?? "arg\(idx))"
-        return try translateParameter(swiftType: param.type, parameterName: parameterName)
+        return try translateParameter(swiftType: param.type, parameterName: parameterName, methodName: methodName, parentName: parentName)
       }
 
       // 'self'
       let selfParameter: TranslatedParameter?
       if case .instance(let swiftSelf) = functionSignature.selfParameter {
         selfParameter = try self.translateParameter(
           swiftType: swiftSelf.type,
-          parameterName: swiftSelf.parameterName ?? "self"
+          parameterName: swiftSelf.parameterName ?? "self",
+          methodName: methodName,
+          parentName: parentName
         )
       } else {
         selfParameter = nil
@@ -92,7 +149,12 @@ extension JNISwift2JavaGenerator {
       )
     }
 
-    func translateParameter(swiftType: SwiftType, parameterName: String) throws -> TranslatedParameter {
+    func translateParameter(
+      swiftType: SwiftType,
+      parameterName: String,
+      methodName: String,
+      parentName: String
+    ) throws -> TranslatedParameter {
       switch swiftType {
       case .nominal(let nominalType):
         if let knownType = nominalType.nominalTypeDecl.knownTypeKind {
@@ -121,7 +183,16 @@ extension JNISwift2JavaGenerator {
           conversion: .placeholder
         )
 
-      case .metatype, .optional, .tuple, .function, .existential, .opaque:
+      case .function:
+        return TranslatedParameter(
+          parameter: JavaParameter(
+            name: parameterName,
+            type: .class(package: javaPackage, name: "\(parentName).\(methodName).\(parameterName)")
+          ),
+          conversion: .placeholder
+        )
+
+      case .metatype, .optional, .tuple, .existential, .opaque:
         throw JavaTranslationError.unsupportedSwiftType(swiftType)
       }
     }
@@ -168,6 +239,9 @@ extension JNISwift2JavaGenerator {
     /// The name of the Java parent scope this function is declared in
     let parentName: String
 
+    /// Functional interfaces required for the Java method.
+    let functionTypes: [TranslatedFunctionType]
+
     /// Function signature of the Java function the user will call
     let translatedFunctionSignature: TranslatedFunctionSignature
 
@@ -220,6 +294,16 @@ extension JNISwift2JavaGenerator {
     let conversion: JavaNativeConversionStep
   }
 
+  /// Represent a Swift closure type in the user facing Java API.
+  ///
+  /// Closures are translated to named functional interfaces in Java.
+  struct TranslatedFunctionType {
+    var name: String
+    var parameters: [TranslatedParameter]
+    var result: TranslatedResult
+    var swiftType: SwiftFunctionType
+  }
+
   /// Describes how to convert values between Java types and the native Java function
   enum JavaNativeConversionStep {
     /// The value being converted