JNI: closures returning arrays of jextracted types, optional or not

A closure implemented in Java that returns `[Item]` generated a wrapper method declared `-> [Item]`,
which doesn't compile (`Item` isn't a Java value), and one returning `[Item]?` was skipped.

The wrapper method now returns the elements' Java objects, `[JavaItem?]`, for an array, and the Java
`Optional` holding the array, `JavaOptional<JavaObject>`, for an optional array, which Swift reads back
as `[JavaItem?]`. Each element is then converted to the Swift value it wraps.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: piercifani

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+EscapingClosureWrapJava.swift

@@ -104,11 +104,17 @@ extension JNISwift2JavaGenerator {
       }
     }
     // Arrays of jextracted values cross as arrays of their Java objects.
-    if !isResult, case .nominal(let array) = type, case .array(let element) = array.asKnownType,
+    if case .nominal(let array) = type, case .array(let element) = array.asKnownType,
       let nominal = jextractedNominal(element)
     {
       return "[\(nominal.generatedJavaClassMacroName)?]"
     }
+    // An optional array is returned in a Java `Optional`, which holds the array as an object.
+    if isResult, let wrapped = optionalWrapped(type), case .nominal(let array) = wrapped,
+      case .array(let element) = array.asKnownType, jextractedNominal(element) != nil
+    {
+      return "JavaOptional<JavaObject>!"
+    }
     return type.description
   }
 

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+InterfaceWrapperGeneration.swift

@@ -352,6 +352,19 @@ extension JNISwift2JavaGenerator {
     }
 
     private func translateOptionalResult(wrappedType: SwiftType, methodName: String) throws -> UpcallConversionStep {
+      // The Java `Optional` holds an array as an object: read it back as an array of the elements' Java objects.
+      if case .nominal(let nominal) = wrappedType, case .array(let element) = nominal.asKnownType {
+        guard case .nominal(let elementType) = element, elementType.nominalTypeDecl.knownTypeKind == nil,
+          case .map(_, let elementConversion) = try translateArrayResult(elementType: element)
+        else {
+          throw JavaTranslationError.unsupportedSwiftType(wrappedType)
+        }
+        let javaArray = UpcallConversionStep.javaObjectArray(
+          .placeholder,
+          elementJavaClass: elementType.nominalTypeDecl.generatedJavaClassMacroName
+        )
+        return .map(.fromJavaOptional(.placeholder), body: .map(javaArray, body: elementConversion))
+      }
       // The `fromJavaOptional` will handle the nullability
       let wrappedConversion = try translateResult(
         type: wrappedType,
@@ -392,6 +405,10 @@ enum UpcallConversionStep {
 
   indirect case map(UpcallConversionStep, body: UpcallConversionStep)
 
+  /// A Java array held as a plain Java object, as the Swift array of its elements' Java objects.
+  indirect case javaObjectArray(UpcallConversionStep, elementJavaClass: String)
+
+
   /// Returns the conversion string applied to the placeholder.
   func render(_ printer: inout SwiftPrinter, _ placeholder: String) -> String {
     switch self {
@@ -447,6 +464,10 @@ enum UpcallConversionStep {
       let inner = inner.render(&printer, placeholder)
       return "Optional(javaOptional: \(inner))"
 
+    case .javaObjectArray(let inner, let elementJavaClass):
+      let inner = inner.render(&printer, placeholder)
+      return "[\(elementJavaClass)?](fromJNI: \(inner).javaThis, in: \(inner).javaEnvironment)"
+
     case .map(let inner, let body):
       let inner = inner.render(&printer, placeholder)
       var printer = SwiftPrinter()

Tests/JExtractSwiftTests/JNI/JNIEscapingClosureJExtractedTypesTests.swift

@@ -240,4 +240,40 @@ struct JNIEscapingClosureJExtractedTypesTests {
       ]
     )
   }
+
+  @Test
+  func closureReturningArrayOfJextractedType_returnsJavaObjects() throws {
+    try assertOutput(
+      input: itemSource + "\npublic func setSeeds(_ cb: @escaping (String) -> [Item]) {}",
+      .jni,
+      .swift,
+      expectedChunks: [
+        #"@JavaClass("com.example.swift.Item")"#,
+        "public func apply(_ _0: String) -> [JavaItem?]",
+        "let arrayElementPointer = UnsafeMutablePointer<Item>(bitPattern: Int(arrayElementMemoryAddress$))!",
+      ]
+    )
+  }
+
+  @Test
+  func closureReturningOptionalArrayOfJextractedType_readsTheJavaOptional() throws {
+    try assertOutput(
+      input: itemSource + "\npublic func setSeeds(_ cb: @escaping (String) -> [Item]?) {}",
+      .jni,
+      .swift,
+      expectedChunks: [
+        "public func apply(_ _0: String) -> JavaOptional<JavaObject>!",
+        "return Optional(javaOptional: javaInterface_cb$.apply(_0)).map {",
+        "return [JavaItem?](fromJNI: $0.javaThis, in: $0.javaEnvironment).map {",
+      ]
+    )
+    try assertOutput(
+      input: itemSource + "\npublic func setSeeds(_ cb: @escaping (String) -> [Item]?) {}",
+      .jni,
+      .java,
+      expectedChunks: [
+        "java.util.Optional<Item[]> apply(java.lang.String _0);"
+      ]
+    )
+  }
 }