snapshot, new version of swift side for returning array

ktoso · ktoso · commit 67154d5c7f08 · 2025-12-04T21:06:28.000+09:00
diff --git a/Samples/SwiftJavaExtractFFMSampleApp/Sources/MySwiftLibrary/MySwiftLibrary.swift b/Samples/SwiftJavaExtractFFMSampleApp/Sources/MySwiftLibrary/MySwiftLibrary.swift
@@ -76,6 +76,16 @@ public func sumAllByteArrayElements(actuallyAnArray: UnsafeRawPointer, count: In
 public func sumAllByteArrayElements(array: [UInt8]) -> Int {
   return Int(array.reduce(0, { partialResult, element in partialResult + element }))
 }
+public func returnSwiftArray() -> [UInt8] {
+  return [1, 2, 3, 4]
+}
+
+// public func swiftjava_MySwiftLibrary_getArray(_ _result_initialize: (UnsafeMutablePointer<UnsafeRawPointer?>, UnsafeMutablePointer<Int>) -> ()) {
+//   let _result = returnSwiftArray()
+//   _result.withUnsafeBufferPointer { buf in
+//     _result_initialize(buf.baseAddress, buf.count)
+//   }
+// }
 
 public func withArray(body: ([UInt8]) -> Void) {
   body([1, 2, 3])
diff --git a/Samples/SwiftJavaExtractFFMSampleApp/src/test/java/com/example/swift/WithBufferTest.java b/Samples/SwiftJavaExtractFFMSampleApp/src/test/java/com/example/swift/WithBufferTest.java
@@ -20,12 +20,31 @@
 
 import static org.junit.jupiter.api.Assertions.*;
 
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
 import java.lang.foreign.ValueLayout;
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.stream.IntStream;
 
 public class WithBufferTest {
+
+    public static byte[] returnArray() {
+        try (var arena$ = Arena.ofConfined()) {
+            MemorySegment _result_pointer = arena$.allocate(SwiftValueLayout.SWIFT_POINTER);
+            MemorySegment _result_count = arena$.allocate(SwiftValueLayout.SWIFT_INT64);
+            // swiftjava_SwiftModule_returnArray.call(_result_pointer, _result_count);
+//            return _result_pointer
+//                    .get(SwiftValueLayout.SWIFT_POINTER, 0)
+//                    .reinterpret(_result_count.get(SwiftValueLayout.SWIFT_INT64, 0));
+            MemorySegment memorySegment = _result_pointer
+                    .get(SwiftValueLayout.SWIFT_POINTER, 0);
+            long newSize = _result_count.get(SwiftValueLayout.SWIFT_INT64, 0);
+            MemorySegment arraySegment = memorySegment.reinterpret(newSize);
+            return arraySegment.toArray(ValueLayout.JAVA_BYTE);
+        }
+    }
+
     @Test
     void test_withBuffer() {
         AtomicLong bufferSize = new AtomicLong();
diff --git a/Sources/JExtractSwiftLib/FFM/CDeclLowering/FFMSwift2JavaGenerator+FunctionLowering.swift b/Sources/JExtractSwiftLib/FFM/CDeclLowering/FFMSwift2JavaGenerator+FunctionLowering.swift
@@ -363,7 +363,6 @@ struct CdeclLowering {
         ),
       ]
       
-      // Initialize a UnsafeRawBufferPointer using the 'address' and 'count'
       let bufferPointerInit = ConversionStep.initialize(
         knownTypes.unsafeRawBufferPointer,
         arguments: [
@@ -565,6 +564,24 @@ struct CdeclLowering {
     }
   }
 
+  /// Create "out" parameter names when we're returning an array-like result.
+  fileprivate func makeBufferIndirectReturnParameters(_ outParameterName: String, isMutable: Bool) -> [SwiftParameter] {
+    [
+      SwiftParameter(
+        convention: .byValue,
+        parameterName: "\(outParameterName)_pointer",
+        type: knownTypes.unsafeMutablePointer(
+          .optional(isMutable ? knownTypes.unsafeMutableRawPointer : knownTypes.unsafeRawPointer)
+        )
+      ),
+      SwiftParameter(
+        convention: .byValue,
+        parameterName: "\(outParameterName)_count",
+        type: knownTypes.unsafeMutablePointer(knownTypes.int)
+      ),
+    ]
+  }
+
   /// Lower a Swift result type to cdecl out parameters and return type.
   ///
   /// - Parameters:
@@ -620,20 +637,7 @@ struct CdeclLowering {
           let isMutable = knownType == .unsafeMutableRawBufferPointer
           return LoweredResult(
             cdeclResultType: .void,
-            cdeclOutParameters: [
-              SwiftParameter(
-                convention: .byValue,
-                parameterName: "\(outParameterName)_pointer",
-                type: knownTypes.unsafeMutablePointer(
-                  .optional(isMutable ? knownTypes.unsafeMutableRawPointer : knownTypes.unsafeRawPointer)
-                )
-              ),
-              SwiftParameter(
-                convention: .byValue,
-                parameterName: "\(outParameterName)_count",
-                type: knownTypes.unsafeMutablePointer(knownTypes.int)
-              ),
-            ],
+            cdeclOutParameters: makeBufferIndirectReturnParameters(outParameterName, isMutable: isMutable),
             conversion: .aggregate([
               .populatePointer(
                 name: "\(outParameterName)_pointer",
@@ -712,6 +716,41 @@ struct CdeclLowering {
         cdeclOutParameters: parameters,
         conversion: .tupleExplode(conversions, name: outParameterName)
       )
+    
+    case .array(let wrapped) where wrapped == knownTypes.uint8:
+      let resultName = "_result"
+
+      return LoweredResult(
+        cdeclResultType: .void, // we call into the _result_initialize instead
+        cdeclOutParameters: [
+          SwiftParameter(
+            convention: .byValue,
+            parameterName: "\(outParameterName)_initialize",
+            type: knownTypes.functionInitializeByteBuffer
+          )
+        ], 
+        conversion: .aggregate([
+          .method(base: resultName, methodName: "withUnsafeBufferPointer", arguments: [
+            .init(argument: 
+              .closureLowering(
+                parameters: [.placeholder],
+                 result: .method(
+                  base: "\(outParameterName)_initialize", 
+                  methodName: nil, // just `(...)` apply the closure
+                  arguments: [
+                    .init(label: nil, argument: .member(.constant("_0"), member: "baseAddress")),
+                    .init(label: nil, argument: .member(.constant("_0"), member: "count")),
+                  ]
+                  // arguments: [
+                  //   .init(label: nil, argument: .member(.placeholder, member: "baseAddress")),
+                  //   .init(label: nil, argument: .member(.placeholder, member: "count")),
+                  // ]
+                )
+              )
+            )
+          ])
+        ], name: resultName)
+      )
 
     case .genericParameter, .function, .optional, .existential, .opaque, .composite, .array:
       throw LoweringError.unhandledType(type)
diff --git a/Sources/JExtractSwiftLib/FFM/ConversionStep.swift b/Sources/JExtractSwiftLib/FFM/ConversionStep.swift
@@ -21,6 +21,9 @@ import SwiftSyntaxBuilder
 enum ConversionStep: Equatable {
   /// The value being lowered.
   case placeholder
+  
+  /// FIXME: Workaround for picking a specific placeholder value; We should resolve how method() works with lowered closures instead
+  case constant(String)
 
   /// A reference to a component in a value that has been exploded, such as
   /// a tuple element or part of a buffer pointer.
@@ -60,8 +63,12 @@ enum ConversionStep: Equatable {
 
   indirect case closureLowering(parameters: [ConversionStep], result: ConversionStep)
 
+  /// Access a member of the target, e.g. `<target>.member`
   indirect case member(ConversionStep, member: String)
 
+  /// Call a method with provided parameters.
+  indirect case method(base: String?, methodName: String?, arguments: [LabeledArgument<ConversionStep>])
+
   indirect case optionalChain(ConversionStep)
 
   /// Count the number of times that the placeholder occurs within this
@@ -77,8 +84,12 @@ enum ConversionStep: Equatable {
       inner.placeholderCount
     case .initialize(_, arguments: let arguments):
       arguments.reduce(0) { $0 + $1.argument.placeholderCount }
+    case .method(_, _, let arguments):
+      arguments.reduce(0) { $0 + $1.argument.placeholderCount }
     case .placeholder, .tupleExplode, .closureLowering:
       1
+    case .constant:
+      0
     case .tuplify(let elements), .aggregate(let elements, _):
       elements.reduce(0) { $0 + $1.placeholderCount }
     }
@@ -98,6 +109,9 @@ enum ConversionStep: Equatable {
     case .placeholder:
       return "\(raw: placeholder)"
 
+    case .constant(let name):
+      return "\(raw: name)"
+
     case .explodedComponent(let step, component: let component):
       return step.asExprSyntax(placeholder: "\(placeholder)_\(component)", bodyItems: &bodyItems)
 
@@ -162,6 +176,29 @@ enum ConversionStep: Equatable {
       let inner = step.asExprSyntax(placeholder: placeholder, bodyItems: &bodyItems)
       return "\(inner).\(raw: member)"
 
+    case .method(let base, let methodName, let arguments):
+      // TODO: this is duplicated, try to dedupe it a bit 
+      let renderedArguments: [String] = arguments.map { labeledArgument in
+        let argExpr = labeledArgument.argument.asExprSyntax(placeholder: placeholder, bodyItems: &bodyItems)
+        return LabeledExprSyntax(label: labeledArgument.label, expression: argExpr!).description
+      }
+
+      // FIXME: Should be able to use structured initializers here instead of splatting out text.
+      let renderedArgumentList = renderedArguments.joined(separator: ", ")
+
+      let methodApply: String =
+        if let methodName {
+          ".\(methodName)"
+        } else {
+          "" // this is equivalent to calling `base(...)`
+        }
+
+      if let base {
+        return "\(raw: base)\(raw: methodApply)(\(raw: renderedArgumentList))"
+      } else {
+        return "\(raw: methodApply)(\(raw: renderedArgumentList))"
+      }
+
     case .aggregate(let steps, let name):
       let toExplode: String
       if let name {
diff --git a/Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaTranslation.swift b/Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaTranslation.swift
@@ -714,6 +714,33 @@ extension FFMSwift2JavaGenerator {
         // TODO: Implement.
         throw JavaTranslationError.unhandledType(swiftType)
 
+      case .array(let wrapped) where wrapped == knownTypes.uint8:
+        return TranslatedResult(
+          javaResultType: 
+            .array(.byte), 
+            annotations: [.unsigned], 
+            outParameters: [
+              JavaParameter(name: "pointer", type: .javaForeignMemorySegment),
+              JavaParameter(name: "count", type: .long),
+            ], 
+            conversion: 
+              .method(
+                .method(
+                  .readMemorySegment(.explodedName(component: "pointer"), as: .javaForeignMemorySegment),
+                  methodName: "reinterpret",
+                  arguments: [
+                    .readMemorySegment(.explodedName(component: "count"), as: .long)
+                  ],
+                  withArena: false
+                ),
+                methodName: "toArray",
+                arguments: [
+                  .constant("ValueLayout.JAVA_BYTE")
+                ],
+                withArena: false
+              )
+        )
+
       case .genericParameter, .optional, .function, .existential, .opaque, .composite, .array:
         throw JavaTranslationError.unhandledType(swiftType)
       }
diff --git a/Sources/JExtractSwiftLib/SwiftTypes/SwiftKnownTypes.swift b/Sources/JExtractSwiftLib/SwiftTypes/SwiftKnownTypes.swift
@@ -35,11 +35,24 @@ struct SwiftKnownTypes {
   var unsafeRawPointer: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.unsafeRawPointer])) }
   var unsafeRawBufferPointer: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.unsafeRawBufferPointer])) }
   var unsafeMutableRawPointer: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.unsafeMutableRawPointer])) }
-
+  
   var foundationDataProtocol: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.foundationDataProtocol])) }
   var foundationData: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.foundationData])) }
   var essentialsDataProtocol: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.essentialsDataProtocol])) }
   var essentialsData: SwiftType { .nominal(SwiftNominalType(nominalTypeDecl: symbolTable[.essentialsData])) }
+  
+  /// `(UnsafeRawPointer, Long) -> ()` function type.
+  /// 
+  /// Commonly used to initialize a buffer using the passed bytes and length.
+  var functionInitializeByteBuffer: SwiftType { 
+    .function(SwiftFunctionType(
+      convention: .c, 
+      parameters: [
+        SwiftParameter(convention: .byValue, parameterName: nil, type: self.unsafeRawPointer), // array base pointer
+        SwiftParameter(convention: .byValue, parameterName: nil, type: self.int), // array length
+      ], 
+      resultType: .void))
+  }
 
   func unsafePointer(_ pointeeType: SwiftType) -> SwiftType {
     .nominal(
diff --git a/Tests/JExtractSwiftTests/ByteArrayTests.swift b/Tests/JExtractSwiftTests/ByteArrayTests.swift
