Tuple support in jextract/jni

Author: ktoso

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/Tuples.swift

@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 returnPair() -> (Int64, String) {
+  (42, "hello")
+}
+
+public func takePair(pair: (Int64, String)) -> String {
+  "\(pair.0):\(pair.1)"
+}
+
+public func labeledTuple() -> (x: Int32, y: Int32) {
+  (x: 10, y: 20)
+}
+
+public func echoTriple(triple: (Bool, Double, Int64)) -> (Bool, Double, Int64) {
+  triple
+}

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

@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+package com.example.swift;
+
+import com.example.swift.MySwiftLibrary;
+import org.junit.jupiter.api.Test;
+import org.swift.swiftkit.core.tuple.Tuple2;
+import org.swift.swiftkit.core.tuple.Tuple3;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TupleTest {
+    @Test
+    void returnPair() {
+        Tuple2<Long, String> result = MySwiftLibrary.returnPair();
+        assertEquals(42L, result.$0());
+        assertEquals("hello", result.$1());
+    }
+
+    @Test
+    void takePair() {
+        String result = MySwiftLibrary.takePair(new Tuple2<>(99L, "world"));
+        assertEquals("99:world", result);
+    }
+
+    @Test
+    void labeledTuple() {
+        Tuple2<Integer, Integer> result = MySwiftLibrary.labeledTuple();
+        assertEquals(10, result.$0());
+        assertEquals(20, result.$1());
+    }
+
+    @Test
+    void echoTriple() {
+        Tuple3<Boolean, Double, Long> input = new Tuple3<>(true, 3.14, 100L);
+        Tuple3<Boolean, Double, Long> result = MySwiftLibrary.echoTriple(input);
+        assertEquals(true, result.$0());
+        assertEquals(3.14, result.$1(), 0.001);
+        assertEquals(100L, result.$2());
+    }
+}

Sources/JExtractSwiftLib/Convenience/JavaType+Extensions.swift

@@ -102,6 +102,20 @@ extension JavaType {
     }
   }
 
+  var jniSetArrayRegionMethodName: String {
+    switch self {
+    case .boolean: "SetBooleanArrayRegion"
+    case .byte: "SetByteArrayRegion"
+    case .char: "SetCharArrayRegion"
+    case .short: "SetShortArrayRegion"
+    case .int: "SetIntArrayRegion"
+    case .long: "SetLongArrayRegion"
+    case .float: "SetFloatArrayRegion"
+    case .double: "SetDoubleArrayRegion"
+    default: fatalError("Set*ArrayRegion is only available for JNI primitive types, was: \(self)")
+    }
+  }
+
   /// Returns whether this type returns `JavaValue` from SwiftJava
   var implementsJavaValue: Bool {
     switch self {
@@ -146,4 +160,22 @@ extension JavaType {
       false
     }
   }
+
+  /// The boxed class name for this type, suitable for use as a generic type argument.
+  var boxedName: String {
+    switch self {
+    case .boolean: "Boolean"
+    case .byte: "Byte"
+    case .char: "Character"
+    case .short: "Short"
+    case .int: "Integer"
+    case .long: "Long"
+    case .float: "Float"
+    case .double: "Double"
+    case .void: "Void"
+    case .javaLangString: "String"
+    case .class(_, let name, _): name
+    case .array: description
+    }
+  }
 }

Sources/JExtractSwiftLib/FFM/CDeclLowering/FFMSwift2JavaGenerator+FunctionLowering.swift

@@ -325,7 +325,7 @@ struct CdeclLowering {
     case .tuple(let tuple):
       if tuple.count == 1 {
         return try lowerParameter(
-          tuple[0],
+          tuple[0].type,
           convention: convention,
           parameterName: parameterName,
           genericParameters: genericParameters,
@@ -341,7 +341,7 @@ struct CdeclLowering {
         // FIXME: Use tuple element label.
         let cdeclName = "\(parameterName)_\(idx)"
         let lowered = try lowerParameter(
-          element,
+          element.type,
           convention: convention,
           parameterName: cdeclName,
           genericParameters: genericParameters,
@@ -518,7 +518,7 @@ struct CdeclLowering {
     case .tuple(let tuple):
       if tuple.count == 1 {
         return try lowerOptionalParameter(
-          tuple[0],
+          tuple[0].type,
           convention: convention,
           parameterName: parameterName,
           genericParameters: genericParameters,
@@ -697,8 +697,8 @@ struct CdeclLowering {
           let isMutable = knownType == .unsafeMutableBufferPointer
           return try lowerResult(
             .tuple([
-              isMutable ? knownTypes.unsafeMutableRawPointer : knownTypes.unsafeRawPointer,
-              knownTypes.int,
+              SwiftTupleElement(label: nil, type: isMutable ? knownTypes.unsafeMutableRawPointer : knownTypes.unsafeRawPointer),
+              SwiftTupleElement(label: nil, type: knownTypes.int),
             ]),
             outParameterName: outParameterName
           )
@@ -755,14 +755,14 @@ struct CdeclLowering {
 
     case .tuple(let tuple):
       if tuple.count == 1 {
-        return try lowerResult(tuple[0], outParameterName: outParameterName)
+        return try lowerResult(tuple[0].type, outParameterName: outParameterName)
       }
 
       var parameters: [SwiftParameter] = []
       var conversions: [ConversionStep] = []
       for (idx, element) in tuple.enumerated() {
         let outName = "\(outParameterName)_\(idx)"
-        let lowered = try lowerResult(element, outParameterName: outName)
+        let lowered = try lowerResult(element.type, outParameterName: outName)
 
         // Convert direct return values to typed mutable pointers.
         // E.g. (Int8, Int8) is lowered to '_ result_0: UnsafePointer<Int8>, _ result_1: UnsafePointer<Int8>'

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaTranslation.swift

@@ -585,7 +585,7 @@ extension FFMSwift2JavaGenerator {
       case .tuple(let tuple):
         if tuple.count == 1 {
           return try translateOptionalParameter(
-            wrappedType: tuple[0],
+            wrappedType: tuple[0].type,
             convention: convention,
             parameterName: parameterName,
             loweredParam: loweredParam,

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -579,11 +579,68 @@ extension JNISwift2JavaGenerator {
           conversion: .typeMetadataAddress(.placeholder)
         )
 
+      case .tuple(let elements) where !elements.isEmpty:
+        return try translateTupleParameter(
+          elements: elements,
+          parameterName: parameterName,
+          methodName: methodName,
+          parentName: parentName,
+          genericParameters: genericParameters,
+          genericRequirements: genericRequirements,
+          parameterPosition: parameterPosition
+        )
+
       case .tuple, .composite:
         throw JavaTranslationError.unsupportedSwiftType(swiftType)
       }
     }
 
+    func translateTupleParameter(
+      elements: [SwiftTupleElement],
+      parameterName: String,
+      methodName: String,
+      parentName: String,
+      genericParameters: [SwiftGenericParameterDeclaration],
+      genericRequirements: [SwiftGenericRequirement],
+      parameterPosition: Int?
+    ) throws -> TranslatedParameter {
+      let arity = elements.count
+      var elementBoxedTypes: [String] = []
+
+      // Generate a conversion that extracts each element from the Tuple record
+      var elementConversions: [JavaNativeConversionStep] = []
+      for (idx, element) in elements.enumerated() {
+        let elementTranslated = try translateParameter(
+          swiftType: element.type,
+          parameterName: "\(parameterName)_\(idx)",
+          methodName: methodName,
+          parentName: parentName,
+          genericParameters: genericParameters,
+          genericRequirements: genericRequirements,
+          parameterPosition: parameterPosition
+        )
+
+        // Extract the element from the tuple using .$N() accessor
+        let extraction = JavaNativeConversionStep.replacingPlaceholder(
+          elementTranslated.conversion,
+          placeholder: "\(parameterName).$\(idx)()"
+        )
+        elementConversions.append(extraction)
+        elementBoxedTypes.append(elementTranslated.parameter.type.javaType.boxedName)
+      }
+
+      let genericParams = elementBoxedTypes.joined(separator: ", ")
+      let javaType: JavaType = .class(package: "org.swift.swiftkit.core.tuple", name: "Tuple\(arity)<\(genericParams)>")
+
+      return TranslatedParameter(
+        parameter: JavaParameter(
+          name: parameterName,
+          type: javaType
+        ),
+        conversion: .commaSeparated(elementConversions)
+      )
+    }
+
     func convertToAsync(
       translatedFunctionSignature: inout TranslatedFunctionSignature,
       nativeFunctionSignature: inout NativeFunctionSignature,
@@ -887,11 +944,83 @@ extension JNISwift2JavaGenerator {
           elementType: elementType
         )
 
+      case .tuple(let elements) where !elements.isEmpty:
+        return try translateTupleResult(elements: elements, resultName: resultName)
+
       case .metatype, .tuple, .function, .existential, .opaque, .genericParameter, .composite:
         throw JavaTranslationError.unsupportedSwiftType(swiftType)
       }
     }
 
+    func translateTupleResult(
+      elements: [SwiftTupleElement],
+      resultName: String = "result"
+    ) throws -> TranslatedResult {
+      let arity = elements.count
+      var outParameters: [OutParameter] = []
+      var elementOutParamNames: [String] = []
+      var elementConversions: [JavaNativeConversionStep] = []
+      var elementBoxedTypes: [String] = []
+
+      for (idx, element) in elements.enumerated() {
+        let outParamName = "\(resultName)_\(idx)$"
+
+        // Determine the Java type for this element
+        let (javaType, elementConversion) = try translateTupleElementResult(type: element.type)
+        let arrayType: JavaType = .array(javaType)
+
+        outParameters.append(
+          OutParameter(name: outParamName, type: arrayType, allocation: .newArray(javaType, size: 1))
+        )
+        elementOutParamNames.append(outParamName)
+        elementConversions.append(elementConversion)
+        elementBoxedTypes.append(javaType.boxedName)
+      }
+
+      let genericParams = elementBoxedTypes.joined(separator: ", ")
+      let tupleClassName = "Tuple\(arity)<\(genericParams)>"
+      let fullTupleClassName = "org.swift.swiftkit.core.tuple.Tuple\(arity)"
+      let javaResultType: JavaType = .class(package: "org.swift.swiftkit.core.tuple", name: tupleClassName)
+
+      let tupleElements: [(outParamName: String, elementConversion: JavaNativeConversionStep)] =
+        zip(elementOutParamNames, elementConversions).map { ($0, $1) }
+
+      return TranslatedResult(
+        javaType: javaResultType,
+        outParameters: outParameters,
+        conversion: .tupleFromOutParams(
+          tupleClassName: "new \(fullTupleClassName)<>",
+          elements: tupleElements
+        )
+      )
+    }
+
+    /// Translate a single element type for tuple results on the Java side.
+    private func translateTupleElementResult(type: SwiftType) throws -> (JavaType, JavaNativeConversionStep) {
+      switch type {
+      case .nominal(let nominalType):
+        if let knownType = nominalType.nominalTypeDecl.knownTypeKind {
+          guard let javaType = JNIJavaTypeTranslator.translate(knownType: knownType, config: self.config) else {
+            throw JavaTranslationError.unsupportedSwiftType(type)
+          }
+          // Primitives: just read from array
+          return (javaType, .placeholder)
+        }
+
+        let nominalTypeName = nominalType.nominalTypeDecl.name
+        guard !nominalType.isSwiftJavaWrapper else {
+          throw JavaTranslationError.unsupportedSwiftType(type)
+        }
+
+        // JExtract class: wrap memory address
+        let javaType: JavaType = .class(package: nil, name: nominalTypeName)
+        return (.long, .constructSwiftValue(.placeholder, javaType))
+
+      default:
+        throw JavaTranslationError.unsupportedSwiftType(type)
+      }
+    }
+
     func translateOptionalResult(
       wrappedType swiftType: SwiftType,
       resultName: String = "result"
@@ -1323,6 +1452,10 @@ extension JNISwift2JavaGenerator {
 
     indirect case requireNonNull(JavaNativeConversionStep, message: String)
 
+    /// Constructs a TupleN from out-parameter arrays.
+    /// E.g. `new Tuple2<>(result_0$[0], result_1$[0])`
+    case tupleFromOutParams(tupleClassName: String, elements: [(outParamName: String, elementConversion: JavaNativeConversionStep)])
+
     /// `Arrays.stream(args)`
     static func arraysStream(_ argument: JavaNativeConversionStep) -> JavaNativeConversionStep {
       .method(.constant("Arrays"), function: "stream", arguments: [argument])
@@ -1473,6 +1606,16 @@ extension JNISwift2JavaGenerator {
       case .requireNonNull(let inner, let message):
         let inner = inner.render(&printer, placeholder)
         return #"Objects.requireNonNull(\#(inner), "\#(message)")"#
+
+      case .tupleFromOutParams(let tupleClassName, let elements):
+        // Execute the native call first (the placeholder is the downcall expression)
+        printer.print("\(placeholder);")
+        var args: [String] = []
+        for element in elements {
+          let converted = element.elementConversion.render(&printer, "\(element.outParamName)[0]")
+          args.append(converted)
+        }
+        return "\(tupleClassName)(\(args.joined(separator: ", ")))"
       }
     }
 
@@ -1535,6 +1678,9 @@ extension JNISwift2JavaGenerator {
 
       case .requireNonNull(let inner, _):
         return inner.requiresSwiftArena
+
+      case .tupleFromOutParams(_, let elements):
+        return elements.contains(where: { $0.elementConversion.requiresSwiftArena })
       }
     }
   }