jextract: LabeledTuple support!

We now support passing and returing labelled tuples like (a: Int, b:
Stirng) etc.

This is important for being able to quickly port over code from swift to
Java using the same libraries as we don't have to special case the
labelled tuples and move them over to positional use.

These ad hoc tuple types are printed per method.

They would conflict if you use the same shape twice in a method right
now... I'm not seeing much of that use so ignored it for now.

The new tuples inherit from TupleN so Java code can just use them as
positional when necessary, also for passing them along to other methods.

The change is large because I also cleaned up type printing, I think
printing full qualified type names is good here, better nor risk
clashes.

Author: ktoso

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

@@ -14,7 +14,6 @@
 
 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;
@@ -38,9 +37,19 @@ void takePair() {
 
     @Test
     void labeledTuple() {
-        Tuple2<Integer, Integer> result = MySwiftLibrary.labeledTuple();
+        var result = MySwiftLibrary.labeledTuple();
+        // Access via named accessors
+        assertEquals(10, result.x());
+        assertEquals(20, result.y());
+        // Positional access still works (inherited from Tuple2)
         assertEquals(10, result.$0);
         assertEquals(20, result.$1);
+
+        // The labelled tuple is a subclass of Tuple2
+        assertInstanceOf(Tuple2.class, result);
+        // And the generic types match positionally as well
+        @SuppressWarnings("unused")
+        Tuple2<Integer, Integer> check = result;
     }
 
     @Test

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -388,10 +388,10 @@ extension FFMSwift2JavaGenerator {
     // If a Swift function is 'throws' we throw a checked error for the Java side
     // TODO: When we support typed throws on Swift side we'll want to throw the right type here instead
     if translatedSignature.isThrowing {
-      throwsClauses.append(JavaType.swiftJavaErrorException.simpleClassName)
+      throwsClauses.append(JavaType.swiftJavaErrorException.className!)
     }
     if translatedSignature.canThrowSwiftIntegerOverflowException {
-      throwsClauses.append(JavaType.swiftIntegerOverflowException.simpleClassName)
+      throwsClauses.append(JavaType.swiftIntegerOverflowException.className!)
     }
     let throwsClause = throwsClauses.isEmpty ? "" : " throws \(throwsClauses.joined(separator: ", "))"
 
@@ -522,7 +522,7 @@ extension FFMSwift2JavaGenerator {
     func printErrorCheck(_ printer: inout CodePrinter) {
       guard translatedSignature.isThrowing else { return }
       printer.printIfBlock("!result$throws.get(ValueLayout.ADDRESS, 0).equals(MemorySegment.NULL)") { printer in
-        printer.print("throw new \(JavaType.swiftJavaErrorException.simpleClassName)(result$throws.get(ValueLayout.ADDRESS, 0), AllocatingSwiftArena.ofAuto());")
+        printer.print("throw new \(JavaType.swiftJavaErrorException.className!)(result$throws.get(ValueLayout.ADDRESS, 0), AllocatingSwiftArena.ofAuto());")
       }
     }
 

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaTranslation.swift

@@ -335,7 +335,8 @@ extension FFMSwift2JavaGenerator {
       // Result.
       let result = try self.translateResult(
         swiftResult: swiftSignature.result,
-        loweredResult: loweredFunctionSignature.result
+        loweredResult: loweredFunctionSignature.result,
+        methodName: methodName
       )
 
       return TranslatedFunctionSignature(
@@ -620,8 +621,7 @@ extension FFMSwift2JavaGenerator {
           case .char: ("Optional<Character>", "toOptionalSegmentCharacter")
           case .short: ("Optional<Short>", "toOptionalSegmentShort")
           case .float: ("Optional<Float>", "toOptionalSegmentFloat")
-          default:
-            throw JavaTranslationError.unhandledType(known: .optional(swiftType))
+          default: throw JavaTranslationError.unhandledType(known: .optional(swiftType))
           }
         return TranslatedParameter(
           javaParameters: [
@@ -689,7 +689,8 @@ extension FFMSwift2JavaGenerator {
     /// Translate a Swift API result to the user-facing Java API result.
     func translateResult(
       swiftResult: SwiftResult,
-      loweredResult: LoweredResult
+      loweredResult: LoweredResult,
+      methodName: String
     ) throws -> TranslatedResult {
       let swiftType = swiftResult.type
       // If the result type should cause any annotations on the method, include them here.
@@ -844,6 +845,7 @@ extension FFMSwift2JavaGenerator {
 
       case .tuple(let elements):
         return try translateTupleResult(
+          methodName: methodName,
           elements: elements,
           resultAnnotations: resultAnnotations
         )
@@ -856,6 +858,7 @@ extension FFMSwift2JavaGenerator {
 
     /// Tuple results: indirect `MemorySegment` per element, then `new TupleN<…>(…)` (mirrors JNI out-arrays).
     func translateTupleResult(
+      methodName: String,
       elements: [SwiftTupleElement],
       resultAnnotations: [JavaAnnotation]
     ) throws -> TranslatedResult {

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator.swift

@@ -151,7 +151,7 @@ extension FFMSwift2JavaGenerator {
   /// Returns the Java class name for a nominal type, applying known-type overrides
   func javaClassName(for decl: ImportedNominalType) -> String {
     if decl.swiftNominal.knownTypeKind == .swiftJavaError {
-      return JavaType.swiftJavaErrorException.simpleClassName
+      return JavaType.swiftJavaErrorException.className!
     }
     return decl.swiftNominal.name
   }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -524,6 +524,10 @@ extension JNISwift2JavaGenerator {
     printJavaBindingWrapperHelperClass(&printer, decl)
 
     printJavaBindingWrapperMethod(&printer, decl, skipMethodBody: skipMethodBody)
+
+    // Print any additional types we may need to emit, e.g. named tuples are emitted as static classes
+    // right next to the func that is using them.
+    printNecessarySupportTypes(&printer, decl)
   }
 
   /// Print the helper type container for a user-facing Java API.
@@ -566,6 +570,17 @@ extension JNISwift2JavaGenerator {
     )
   }
 
+  private func printNecessarySupportTypes(
+    _ printer: inout CodePrinter,
+    _ decl: ImportedFunc
+  ) {
+    let translatedDecl = translatedDecl(for: decl)!
+
+    for labeledTuple in translatedDecl.usedLabeledTuples {
+      printAdHocLabeledTupleStaticClass(&printer, labeledTuple)
+    }
+  }
+
   private func printJavaBindingWrapperMethod(
     _ printer: inout CodePrinter,
     _ decl: ImportedFunc,

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -115,12 +115,12 @@ extension JNISwift2JavaGenerator {
       let conversions = try enumCase.parameters.enumerated().map { idx, parameter in
         let resultName = parameter.name ?? "arg\(idx)"
         let result = SwiftResult(convention: .direct, type: parameter.type)
-        var translatedResult = try self.translate(swiftResult: result, resultName: resultName)
+        var translatedResult = try self.translate(swiftResult: result, methodName: methodName, resultName: resultName)
         translatedResult.conversion = .replacingPlaceholder(
           translatedResult.conversion,
           placeholder: "$nativeParameters.\(resultName)",
         )
-        let nativeResult = try nativeTranslation.translate(swiftResult: result, resultName: resultName)
+        let nativeResult = try nativeTranslation.translate(swiftResult: result, methodName: methodName, resultName: resultName)
         return (translated: translatedResult, native: nativeResult)
       }
 
@@ -319,7 +319,7 @@ extension JNISwift2JavaGenerator {
         )
       }
 
-      let translatedResult = try translate(swiftResult: SwiftResult(convention: .direct, type: swiftType.resultType))
+      let translatedResult = try translate(swiftResult: SwiftResult(convention: .direct, type: swiftType.resultType), methodName: name)
 
       return TranslatedFunctionType(
         name: name,
@@ -367,6 +367,7 @@ extension JNISwift2JavaGenerator {
 
       let resultType = try translate(
         swiftResult: functionSignature.result,
+        methodName: methodName,
         genericParameters: functionSignature.genericParameters,
         genericRequirements: functionSignature.genericRequirements,
       )
@@ -628,7 +629,9 @@ extension JNISwift2JavaGenerator {
           parameterPosition: parameterPosition,
         )
 
-      case .tuple, .composite:
+      case .tuple:
+        throw JavaTranslationError.emptyTuple()
+      case .composite:
         throw JavaTranslationError.unsupportedSwiftType(swiftType)
       }
     }
@@ -885,6 +888,7 @@ extension JNISwift2JavaGenerator {
 
     func translate(
       swiftResult: SwiftResult,
+      methodName: String,
       resultName: String = "result",
       genericParameters: [SwiftGenericParameterDeclaration] = [],
       genericRequirements: [SwiftGenericRequirement] = [],
@@ -1017,6 +1021,7 @@ extension JNISwift2JavaGenerator {
 
       case .tuple(let elements) where !elements.isEmpty:
         return try translateTupleResult(
+          methodName: methodName,
           elements: elements,
           resultName: resultName,
           genericParameters: genericParameters,
@@ -1149,7 +1154,9 @@ extension JNISwift2JavaGenerator {
       }
     }
 
+    /// - Parameter: methodName is necessary because we may need to form an ad-hoc one off type if e.g. named tuples are used.
     func translateTupleResult(
+      methodName: String,
       elements: [SwiftTupleElement],
       resultName: String = "result",
       genericParameters: [SwiftGenericParameterDeclaration],
@@ -1167,18 +1174,30 @@ extension JNISwift2JavaGenerator {
         // Determine the Java type for this element
         let elementResult = try translate(
           swiftResult: .init(convention: .indirect, type: element.type),
+          methodName: methodName,
           resultName: outParamName,
           genericParameters: genericParameters,
           genericRequirements: genericRequirements,
         )
 
+        // out names are always ...$N, no need to use real named tuple names here, this is just for the thunk
         elementOutParamNames.append(outParamName)
+
         // FIXME: More accurate determination of whether the result is direct or indirect
         if elementResult.outParameters.isEmpty {
-          // Convert direct result to indirect result
-          let arrayType: JavaType = .array(elementResult.javaType)
+          // Convert direct result to indirect result.
+          // For class types (nominal types), the JNI native representation is 'long'
+          // (a memory address), not the wrapper class type
+          let nativeElementType: JavaType
+          switch elementResult.javaType {
+          case .class:
+            nativeElementType = .long
+          default:
+            nativeElementType = elementResult.javaType
+          }
+          let arrayType: JavaType = .array(nativeElementType)
           outParameters.append(
-            OutParameter(name: outParamName, type: arrayType, allocation: .newArray(elementResult.javaType, size: 1))
+            OutParameter(name: outParamName, type: arrayType, allocation: .newArray(nativeElementType, size: 1))
           )
           elementConversions.append(elementResult.conversion)
         } else {
@@ -1188,19 +1207,36 @@ extension JNISwift2JavaGenerator {
         elementJavaTypes.append(elementResult.javaType)
       }
 
-      let javaResultType: JavaType = .tuple(elementTypes: elementJavaTypes)
-      let fullTupleClassName = "org.swift.swiftkit.core.tuple.Tuple\(arity)"
+      let isNamedTuple = elements.contains { $0.label != nil }
+      let names = elements.enumerated().map { idx, element in
+        if let label = element.label {
+          label
+        } else {
+          "$\(idx)"
+        }
+      }
 
       let tupleElements: [(outParamName: String, elementConversion: JavaNativeConversionStep)] =
         zip(elementOutParamNames, elementConversions).map { ($0, $1) }
 
+      let javaResultType: JavaType =
+        if isNamedTuple {
+          .labeledTuple(methodName, names: names, elementTypes: elementJavaTypes)
+        } else {
+          .tuple(elementTypes: elementJavaTypes)
+        }
+
+      let javaNativeConversionStep: JavaNativeConversionStep =
+        .tupleFromOutParams(
+          // try!-safe, because we know the result type is a class here (a Tuple of some form)
+          tupleClassName: "\(javaResultType)",
+          elements: tupleElements
+        )
+
       return TranslatedResult(
         javaType: javaResultType,
         outParameters: outParameters,
-        conversion: .tupleFromOutParams(
-          tupleClassName: fullTupleClassName,
-          elements: tupleElements
-        )
+        conversion: javaNativeConversionStep
       )
     }
 
@@ -1285,6 +1321,7 @@ extension JNISwift2JavaGenerator {
 
         let wrappedValueResult = try translate(
           swiftResult: SwiftResult(convention: .direct, type: swiftType),
+          methodName: "",
           resultName: resultName + "Wrapped$",
           genericParameters: genericParameters,
           genericRequirements: genericRequirements,
@@ -1945,7 +1982,7 @@ extension JNISwift2JavaGenerator {
           let converted = element.elementConversion.render(&printer, "\(element.outParamName)[0]")
           args.append(converted)
         }
-        return "new \(tupleClassName)<>(\(args.joined(separator: ", ")))"
+        return "new \(tupleClassName)(\(args.joined(separator: ", ")))"
 
       case .placeToVar(let inner, let name):
         let inner = inner.render(&printer, placeholder)
@@ -2025,6 +2062,7 @@ extension JNISwift2JavaGenerator {
 
   enum JavaTranslationError: Error {
     case unsupportedSwiftType(SwiftType, fileID: String, line: Int)
+
     static func unsupportedSwiftType(
       _ type: SwiftType,
       _fileID: String = #fileID,
@@ -2060,5 +2098,14 @@ extension JNISwift2JavaGenerator {
 
     /// Set type requires exactly one generic type argument (element).
     case setRequiresElementType(SwiftType)
+
+    /// Empty tuples are not supported in lowering, they should be treated as Void
+    case emptyTuple(file: String, line: Int)
+    static func emptyTuple(
+      _file: String = #fileID,
+      _line: Int = #line
+    ) -> JavaTranslationError {
+      .emptyTuple(file: _file, line: _line)
+    }
   }
 }