jextract/jni: handle UnsafeRawBufferPointer params and returns

This allows passing a Java byte array to an `UnsafeRawBufferPointer` accepting API in Swift. This conversion needs to copy a bunch but makes pretty much sense. This is in JNI mode specifically.

In FFM mode we could do better by allocating and passing a MemorySegment but this is to unblock APIs in JNI mode specifically.

We do allow returning an URBP to Java as well, but this is very dubious and scary, so we don't make anything sneaky here and literarily return this as an `SwiftUnsafeRawBufferPointer` that you may be able to do "something" with in java...

Author: ktoso

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/UnsafeRawBufferPointer.swift

@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2026 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
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftJava
+
+/// Sum all bytes in the buffer
+public func sumOfBytes(data: UnsafeRawBufferPointer) -> Int64 {
+  var sum: Int64 = 0
+  for byte in data {
+    sum += Int64(byte)
+  }
+  return sum
+}
+
+/// Return the count of bytes in the buffer
+public func bufferCount(data: UnsafeRawBufferPointer) -> Int64 {
+  Int64(data.count)
+}
+

Samples/SwiftJavaExtractJNISampleApp/src/test/java/com/example/swift/UnsafeRawBufferPointerTest.java

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2026 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 static org.junit.jupiter.api.Assertions.*;
+
+public class UnsafeRawBufferPointerTest {
+    @Test
+    void sumOfBytes() {
+        byte[] input = new byte[] { 1, 2, 3, 4, 5 };
+        assertEquals(15, MySwiftLibrary.sumOfBytes(input));
+    }
+
+    @Test
+    void sumOfBytes_empty() {
+        byte[] input = new byte[] {};
+        assertEquals(0, MySwiftLibrary.sumOfBytes(input));
+    }
+
+    @Test
+    void bufferCount() {
+        byte[] input = new byte[] { 10, 20, 30, 40 };
+        assertEquals(4, MySwiftLibrary.bufferCount(input));
+    }
+
+    @Test
+    void bufferCount_empty() {
+        byte[] input = new byte[] {};
+        assertEquals(0, MySwiftLibrary.bufferCount(input));
+    }
+}

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -242,7 +242,7 @@ extension JNISwift2JavaGenerator {
       let javaName = javaIdentifiers.makeJavaMethodName(decl)
 
       // Swift -> Java
-      var translatedFunctionSignature = try translate(
+      var translatedFunctionSignature = try self.translate(
         functionSignature: decl.functionSignature,
         methodName: javaName,
         parentName: parentName,
@@ -509,6 +509,12 @@ extension JNISwift2JavaGenerator {
           case .foundationData, .essentialsData:
             break // Handled as wrapped struct
 
+          case .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer:
+            return TranslatedParameter(
+              parameter: JavaParameter(name: parameterName, type: .array(.byte)),
+              conversion: .placeholder
+            )
+
           case .foundationUUID, .essentialsUUID:
             return TranslatedParameter(
               parameter: JavaParameter(name: parameterName, type: .javaUtilUUID),

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+NativeTranslation.swift

@@ -125,6 +125,16 @@ extension JNISwift2JavaGenerator {
               parameterName: parameterName
             )
 
+          case .unsafeRawBufferPointer, .unsafeMutableRawBufferPointer:
+            return NativeParameter(
+              parameters: [
+                JavaParameter(name: parameterName, type: .array(.byte))
+              ],
+              conversion: .jniByteArrayToUnsafeRawBufferPointer(.placeholder, name: parameterName),
+              indirectConversion: nil,
+              conversionCheck: nil
+            )
+
           case .foundationDate, .essentialsDate, .foundationData, .essentialsData:
             // Handled as wrapped struct
             break
@@ -1154,6 +1164,9 @@ extension JNISwift2JavaGenerator {
     /// `SwiftType(inner)`
     indirect case labelessInitializer(NativeSwiftConversionStep, swiftType: SwiftType)
 
+    /// Converts a jbyteArray to UnsafeRawBufferPointer via GetByteArrayElements + defer
+    indirect case jniByteArrayToUnsafeRawBufferPointer(NativeSwiftConversionStep, name: String)
+
     /// Constructs a Swift tuple from individually-converted elements.
     /// E.g. `(label0: conv0, conv1)` for `(label0: Int, String)`
     indirect case tupleConstruct(elements: [(label: String?, conversion: NativeSwiftConversionStep)])
@@ -1713,6 +1726,21 @@ extension JNISwift2JavaGenerator {
         let inner = inner.render(&printer, placeholder)
         return "\(swiftType)(\(inner))"
 
+      case .jniByteArrayToUnsafeRawBufferPointer(let inner, let name):
+        let inner = inner.render(&printer, placeholder)
+        let countVar = "\(name)$count"
+        let ptrVar = "\(name)$ptr"
+        let rbpVar = "\(name)$rbp"
+        printer.print(
+          """
+          let \(countVar) = Int(environment.interface.GetArrayLength(environment, \(inner)))
+          let \(ptrVar) = environment.interface.GetByteArrayElements(environment, \(inner), nil)!
+          defer { environment.interface.ReleaseByteArrayElements(environment, \(inner), \(ptrVar), jint(JNI_ABORT)) }
+          let \(rbpVar) = UnsafeRawBufferPointer(start: \(ptrVar), count: \(countVar))
+          """
+        )
+        return rbpVar
+
       case .tupleConstruct(let elements):
         let parts = elements.enumerated().map { idx, element in
           let converted = element.conversion.render(&printer, "\(placeholder)_\(idx)")

Sources/JExtractSwiftLib/JavaTypes/JavaType+JDK.swift

@@ -58,4 +58,5 @@ extension JavaType {
   static var javaUtilUUID: JavaType {
     .class(package: "java.util", name: "UUID")
   }
+
 }

Tests/JExtractSwiftTests/ByteArrayTests.swift

@@ -183,4 +183,75 @@ final class ByteArrayTests {
       expectedChunks: expectedSwiftChunks
     )
   }
+
+  // ==== -----------------------------------------------------------------------
+  // MARK: JNI mode tests
+
+  @Test("Import: accept [UInt8] array (JNI)")
+  func func_accept_array_uint8_jni() throws {
+    let text = "public func acceptArray(array: [UInt8])"
+    try assertOutput(input: text, .jni, .swift, detectChunkByInitialLines: 2, expectedChunks: [
+      """
+      @_cdecl("Java_com_example_swift_SwiftModule__00024acceptArray___3B")
+      public func Java_com_example_swift_SwiftModule__00024acceptArray___3B(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, array: jbyteArray?) {
+        SwiftModule.acceptArray(array: [UInt8](fromJNI: array, in: environment))
+      }
+      """
+    ])
+    try assertOutput(input: text, .jni, .java, detectChunkByInitialLines: 2, expectedChunks: [
+      """
+      public static void acceptArray(@Unsigned byte[] array) {
+        SwiftModule.$acceptArray(Objects.requireNonNull(array, "array must not be null"));
+      }
+      """,
+      "private static native void $acceptArray(byte[] array);",
+    ])
+  }
+
+  @Test("Import: return [UInt8] array (JNI)")
+  func func_return_array_uint8_jni() throws {
+    let text = "public func returnArray() -> [UInt8]"
+    try assertOutput(input: text, .jni, .swift, detectChunkByInitialLines: 2, expectedChunks: [
+      """
+      @_cdecl("Java_com_example_swift_SwiftModule__00024returnArray__")
+      public func Java_com_example_swift_SwiftModule__00024returnArray__(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass) -> jbyteArray? {
+        return SwiftModule.returnArray().getJNILocalRefValue(in: environment)
+      }
+      """
+    ])
+    try assertOutput(input: text, .jni, .java, detectChunkByInitialLines: 2, expectedChunks: [
+      """
+      @Unsigned
+      public static byte[] returnArray() {
+        return SwiftModule.$returnArray();
+      }
+      """,
+      "private static native byte[] $returnArray();",
+    ])
+  }
+
+  @Test("Import: accept UnsafeRawBufferPointer (JNI)")
+  func func_accept_unsafeRawBufferPointer_jni() throws {
+    let text = "public func receiveBuffer(data: UnsafeRawBufferPointer)"
+    try assertOutput(input: text, .jni, .swift, detectChunkByInitialLines: 2, expectedChunks: [
+      """
+      @_cdecl("Java_com_example_swift_SwiftModule__00024receiveBuffer___3B")
+      public func Java_com_example_swift_SwiftModule__00024receiveBuffer___3B(environment: UnsafeMutablePointer<JNIEnv?>!, thisClass: jclass, data: jbyteArray?) {
+        let data$count = Int(environment.interface.GetArrayLength(environment, data))
+        let data$ptr = environment.interface.GetByteArrayElements(environment, data, nil)!
+        defer { environment.interface.ReleaseByteArrayElements(environment, data, data$ptr, jint(JNI_ABORT)) }
+        let data$rbp = UnsafeRawBufferPointer(start: data$ptr, count: data$count)
+        SwiftModule.receiveBuffer(data: data$rbp)
+      }
+      """
+    ])
+    try assertOutput(input: text, .jni, .java, detectChunkByInitialLines: 2, expectedChunks: [
+      """
+      public static void receiveBuffer(byte[] data) {
+        SwiftModule.$receiveBuffer(data);
+      }
+      """,
+      "private static native void $receiveBuffer(byte[] data);",
+    ])
+  }
 }