final boilerplate additions for ffm array returns

Author: ktoso

Samples/SwiftJavaExtractFFMSampleApp/src/test/java/com/example/swift/FFMArraysTest.java

@@ -41,8 +41,6 @@ void test_sumAllByteArrayElements_throughMemorySegment() {
             var bytesCopy = arena.allocateFrom(ValueLayout.JAVA_BYTE, bytes);
             var swiftSideSum = MySwiftLibrary.sumAllByteArrayElements(bytesCopy, bytes.length);
 
-            System.out.println("swiftSideSum = " + swiftSideSum);
-
             int javaSideSum = IntStream.range(0, bytes.length).map(i -> bytes[i]).sum();
             assertEquals(javaSideSum, swiftSideSum);
         }
@@ -55,9 +53,15 @@ void test_sumAllByteArrayElements_arrayCopy() {
 
         var swiftSideSum = MySwiftLibrary.sumAllByteArrayElements(bytes);
 
-        System.out.println("swiftSideSum = " + swiftSideSum);
-
         int javaSideSum = IntStream.range(0, bytes.length).map(i -> bytes[i]).sum();
         assertEquals(javaSideSum, swiftSideSum);
     }
+
+    @Test
+    void test_getArray() {
+        AtomicLong bufferSize = new AtomicLong();
+        byte[] javaBytes = MySwiftLibrary.getArray(); // automatically converted [UInt8] to byte[]
+
+        assertArrayEquals(new byte[]{1, 2, 3}, javaBytes);
+    }
 }

Samples/SwiftJavaExtractFFMSampleApp/src/test/java/com/example/swift/WithBufferTest.java

@@ -39,11 +39,4 @@ void test_withBuffer() {
         assertEquals(124, bufferSize.get());
     }
 
-    @Test
-    void test_getArray() {
-        AtomicLong bufferSize = new AtomicLong();
-        byte[] javaBytes = MySwiftLibrary.getArray()
-
-        assertEquals({1, 2, 3}, bufferSize.get());
-    }
 }

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -182,8 +182,7 @@ extension FFMSwift2JavaGenerator {
   ///   }
   ///   ```
   /// 
-  /// If a `functionBody` is provided the `Function` becomes a `final static class`,
-  /// with the specified implementation as the implementation of the `apply` method.
+  /// If a `functionBody` is provided, a `Function$Impl` class will be emitted as well.
   func printFunctionPointerParameterDescriptorClass(
     _ printer: inout CodePrinter,
     _ name: String,
@@ -217,27 +216,28 @@ extension FFMSwift2JavaGenerator {
       private static class \(name)
       """
     ) { printer in
+      printer.print(
+        """
+        @FunctionalInterface
+        public interface Function {
+          \(cResultType.javaType) apply(\(paramDecls.joined(separator: ", ")));
+        }
+        """
+      )
+      
       if let impl {
         printer.print(
           """
-          public final static class Function {
+          public final static class Function$Impl implements Function {
             \(impl.members.joinedJavaStatements(indent: 2))
-            \(cResultType.javaType) apply(\(paramDecls.joined(separator: ", "))) {
+            public \(cResultType.javaType) apply(\(paramDecls.joined(separator: ", "))) {
               \(impl.body)
             }
           }
           """
         )
-      } else {
-        printer.print(
-          """
-          @FunctionalInterface
-          public interface Function {
-            \(cResultType.javaType) apply(\(paramDecls.joined(separator: ", ")));
-          }
-          """
-        )
-      }
+      } 
+
       printFunctionDescriptorDefinition(&printer, cResultType, cParams)
       printer.print(
         """
@@ -456,19 +456,20 @@ extension FFMSwift2JavaGenerator {
       downCallArguments.append(varName)
     }
 
+    let thunkName = thunkNameRegistry.functionThunkName(decl: decl)
+    
     if let outCallback = translatedSignature.result.outCallback {
       let funcName = outCallback.name
       assert(funcName.first == "$", "OutCallback names must start with $")
       let varName = funcName.dropFirst()
       downCallArguments.append(
         """
-        swiftjava_SwiftModule_returnArray.\(outCallback.name).toUpcallStub(\(varName), arena$)
+        \(thunkName).\(outCallback.name).toUpcallStub(\(varName), arena$)
         """
       )
     }
 
     //=== Part 3: Downcall.
-    let thunkName = thunkNameRegistry.functionThunkName(decl: decl)
     let downCall = "\(thunkName).call(\(downCallArguments.joined(separator: ", ")))"
 
     //=== Part 4: Convert the return value.
@@ -527,7 +528,9 @@ extension FFMSwift2JavaGenerator.JavaConversionStep {
   /// Whether the conversion uses SwiftArena.
   var requiresSwiftArena: Bool {
     switch self {
-    case .placeholder, .placeholderForDowncall, .explodedName, .constant, .readMemorySegment:
+    case .placeholder, .placeholderForDowncall, .placeholderForSwiftThunkName:
+      return false
+    case .explodedName, .constant, .readMemorySegment, .javaNew:
       return false
     case .constructSwiftValue, .wrapMemoryAddressUnsafe:
       return true
@@ -536,6 +539,8 @@ extension FFMSwift2JavaGenerator.JavaConversionStep {
 
     case .initializeResultWithUpcall(let steps, let result):
       return steps.contains { $0.requiresSwiftArena } || result.requiresSwiftArena
+    case .introduceVariable(_, let value):
+      return value.requiresSwiftArena
 
     case .call(let inner, let base, _, _):
       return inner.requiresSwiftArena || (base?.requiresSwiftArena == true)
@@ -547,22 +552,26 @@ extension FFMSwift2JavaGenerator.JavaConversionStep {
          .swiftValueSelfSegment(let inner):
       return inner.requiresSwiftArena
 
-    case .commaSeparated(let list):
+    case .commaSeparated(let list, _):
       return list.contains(where: { $0.requiresSwiftArena })
     }
   }
 
   /// Whether the conversion uses temporary Arena.
   var requiresTemporaryArena: Bool {
     switch self {
-    case .placeholder, .placeholderForDowncall, .explodedName, .constant:
+    case .placeholder, .placeholderForDowncall, .placeholderForSwiftThunkName:
+      return false
+    case .explodedName, .constant, .javaNew:
       return false
     case .temporaryArena:
       return true
     case .readMemorySegment:
       return true
     case .initializeResultWithUpcall:
       return true
+    case .introduceVariable(_, let value):
+      return value.requiresTemporaryArena
     case .cast(let inner, _), 
          .construct(let inner, _), 
          .constructSwiftValue(let inner, _), 
@@ -575,7 +584,7 @@ extension FFMSwift2JavaGenerator.JavaConversionStep {
       return withArena || inner.requiresTemporaryArena || args.contains(where: { $0.requiresTemporaryArena })
     case .property(let inner, _):
       return inner.requiresTemporaryArena
-    case .commaSeparated(let list):
+    case .commaSeparated(let list, _):
       return list.contains(where: { $0.requiresTemporaryArena })
     }
   }
@@ -594,17 +603,28 @@ extension FFMSwift2JavaGenerator.JavaConversionStep {
       } else {
         return "/*placeholderForDowncall undefined!*/"
       }
+    case .placeholderForSwiftThunkName:
+      if let placeholderForDowncall {
+        let downcall = "\(placeholderForDowncall)"
+        return String(downcall[..<(downcall.firstIndex(of: ".") ?? downcall.endIndex)]) // . separates thunk name from the `.call`
+      } else {
+        return "/*placeholderForDowncall undefined!*/"
+      }
+
+    case .temporaryArena:
+      return "arena$"
 
     case .explodedName(let component):
       return "\(placeholder)_\(component)"
 
     case .swiftValueSelfSegment:
       return "\(placeholder).$memorySegment()"
 
-    case .temporaryArena:
-      return "arena$"
+    case .javaNew(let value):
+      return "new \(value.render(&printer, placeholder, placeholderForDowncall: placeholderForDowncall))"
 
     case .initializeResultWithUpcall(let steps, _):
+      // TODO: could we use the printing to introduce the upcall handle instead?
       return steps.map { step in 
         var printer = CodePrinter()
         var out = ""
@@ -626,33 +646,39 @@ extension FFMSwift2JavaGenerator.JavaConversionStep {
 
     // TODO: deduplicate with 'method'
     case .method(let inner, let methodName, let arguments, let withArena):
-      let inner = inner.render(&printer, placeholder)
-      let args = arguments.map { $0.render(&printer, placeholder) }
+      let inner = inner.render(&printer, placeholder, placeholderForDowncall: placeholderForDowncall)
+      let args = arguments.map { $0.render(&printer, placeholder, placeholderForDowncall: placeholderForDowncall) }
       let argsStr = (args + (withArena ? ["arena$"] : [])).joined(separator: " ,")
       return "\(inner).\(methodName)(\(argsStr))"
 
     case .property(let inner, let propertyName):
-      let inner = inner.render(&printer, placeholder)
+      let inner = inner.render(&printer, placeholder, placeholderForDowncall: placeholderForDowncall)
       return "\(inner).\(propertyName)"
 
     case .constructSwiftValue(let inner, let javaType):
-      let inner = inner.render(&printer, placeholder)
+      let inner = inner.render(&printer, placeholder, placeholderForDowncall: placeholderForDowncall)
       return "new \(javaType.className!)(\(inner), swiftArena$)"
 
     case .wrapMemoryAddressUnsafe(let inner, let javaType):
-      let inner = inner.render(&printer, placeholder)
+      let inner = inner.render(&printer, placeholder, placeholderForDowncall: placeholderForDowncall)
       return "\(javaType.className!).wrapMemoryAddressUnsafe(\(inner), swiftArena$)"
 
     case .construct(let inner, let javaType):
-      let inner = inner.render(&printer, placeholder)
+      let inner = inner.render(&printer, placeholder, placeholderForDowncall: placeholderForDowncall)
       return "new \(javaType)(\(inner))"
+    
+    case .introduceVariable(let name, let value):
+      let value = value.render(&printer, placeholder, placeholderForDowncall: placeholderForDowncall)
+      return "var \(name) = \(value);"
 
     case .cast(let inner, let javaType):
-      let inner = inner.render(&printer, placeholder)
+      let inner = inner.render(&printer, placeholder, placeholderForDowncall: placeholderForDowncall)
       return "(\(javaType)) \(inner)"
 
-    case .commaSeparated(let list):
-      return list.map({ $0.render(&printer, placeholder)}).joined(separator: ", ")
+    case .commaSeparated(let list, let separator):
+      return list.map({ 
+        $0.render(&printer, placeholder, placeholderForDowncall: placeholderForDowncall) 
+      }).joined(separator: separator)
 
     case .constant(let value):
       return value

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaTranslation.swift

@@ -753,7 +753,15 @@ extension FFMSwift2JavaGenerator {
               body: "this.result = _0.reinterpret(_1).toArray(ValueLayout.JAVA_BYTE); // copy native Swift array to Java heap array"
             ),
             conversion: .initializeResultWithUpcall([
-              .constant("var _result_initialize = new swiftjava_SwiftModule_returnArray.$_result_initialize.Function()"),
+              .introduceVariable(
+                name: "_result_initialize", 
+                initializeWith: .javaNew(.commaSeparated([
+                  // We need to refer to the nested class that is created for this function.
+                  // The class that contains all the related functional interfaces is called the same
+                  // as the downcall function, so we use the thunk name to find this class/
+                  .placeholderForSwiftThunkName, .constant("$_result_initialize.Function$Impl()")
+                ], separator: "."))),
+              // .constant("var  = new \(.placeholderForDowncallThunkName).."),
               .placeholderForDowncall, // perform the downcall here
             ],
             extractResult: .property(.constant("_result_initialize"), propertyName: "result"))
@@ -783,8 +791,16 @@ extension FFMSwift2JavaGenerator {
     /// The "downcall", e.g. `swiftjava_SwiftModule_returnArray.call(...)`.
     /// This can be used in combination with aggregate conversion steps to prepare a setup and processing of the downcall.
     case placeholderForDowncall
+    
+    /// Placeholder for Swift thunk name, e.g. "swiftjava_SwiftModule_returnArray".
+    /// 
+    /// This is derived from the placeholderForDowncall substitution - could be done more cleanly, 
+    /// however this has the benefit of not needing to pass the name substituion separately.
+    case placeholderForSwiftThunkName
 
     /// The temporary `arena$` that is necessary to complete the conversion steps.
+    /// 
+    /// This is distinct from just a constant 'arena$' string, since it forces the creation of a temporary arena.
     case temporaryArena
 
     /// The input exploded into components.
@@ -814,7 +830,7 @@ extension FFMSwift2JavaGenerator {
       .call(step, base: nil, function: function, withArena: withArena)
     }
 
-    // TODO: just use call instead?
+    // TODO: just use make call more powerful and use it instead?
     /// Apply a method on the placeholder.
     /// If `withArena` is true, `arena$` argument is added.
     indirect case method(JavaConversionStep, methodName: String, arguments: [JavaConversionStep] = [], withArena: Bool)
@@ -826,17 +842,27 @@ extension FFMSwift2JavaGenerator {
     /// Call 'new \(Type)(\(placeholder), swiftArena$)'.
     indirect case constructSwiftValue(JavaConversionStep, JavaType)
 
+    /// Construct the type using the placeholder as arguments.
+    indirect case construct(JavaConversionStep, JavaType)
+    
     /// Call the `MyType.wrapMemoryAddressUnsafe` in order to wrap a memory address using the Java binding type
     indirect case wrapMemoryAddressUnsafe(JavaConversionStep, JavaType)
 
-    /// Construct the type using the placeholder as arguments.
-    indirect case construct(JavaConversionStep, JavaType)
+    /// Introduce a local variable, e.g. `var result = new Something()`
+    indirect case introduceVariable(name: String, initializeWith: JavaConversionStep)
 
     /// Casting the placeholder to the certain type.
     indirect case cast(JavaConversionStep, JavaType)
+    
+    /// Prefix the conversion step with a java `new`.
+    /// 
+    /// This is useful if constructing the value is complex and we use
+    /// a combination of separated values and constants to do so; Generally prefer using `construct`
+    /// if you only want to construct a "wrapper" for the current `.placeholder`.
+    indirect case javaNew(JavaConversionStep)
 
     /// Convert the results of the inner steps to a comma separated list.
-    indirect case commaSeparated([JavaConversionStep])
+    indirect case commaSeparated([JavaConversionStep], separator: String = ", ")
 
     /// Refer an exploded argument suffixed with `_\(name)`.
     indirect case readMemorySegment(JavaConversionStep, as: JavaType)