jextract/jni: Overhaul enum associated value retrieval

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/Enums.swift

@@ -31,3 +31,9 @@ public enum EnumWithCaseNameValue {
     public var message: String
   }
 }
+
+public enum ComplexAssociatedValues {
+  case generic(MyID<Int>, GenericEnum<Int>)
+  case optionalTypealiasedGeneric(id: MyIntID?)
+  case array([String])
+}

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/GenericType.swift

@@ -22,6 +22,8 @@ public struct MyID<T> {
   }
 }
 
+public typealias MyIntID = MyID<Int>
+
 public enum MyIDs {
   public static func makeIntID(_ value: Int) -> MyID<Int> {
     MyID(value)

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/Tuples.swift

@@ -24,6 +24,10 @@ public func labeledTuple() -> (x: Int32, y: Int32) {
   (x: 10, y: 20)
 }
 
+public func echoSingleTuple(input: (String)) -> (String) {
+  input
+}
+
 public func echoTriple(triple: (Bool, Double, Int64)) -> (Bool, Double, Int64) {
   triple
 }

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

@@ -19,6 +19,9 @@
 
 import static org.junit.jupiter.api.Assertions.*;
 
+import java.util.List;
+import java.util.Optional;
+
 public class EnumTest {
     @Test
     void enumWithValueCases() {
@@ -42,11 +45,54 @@ void enumWithCaseNameValue() {
         try (var arena = SwiftArena.ofConfined()) {
             var success = EnumWithCaseNameValue.Success.init("ok", arena);
             EnumWithCaseNameValue e = EnumWithCaseNameValue.success(success, arena);
-         
+
             switch (e.getCase(arena)) {
             case EnumWithCaseNameValue.Case.Success(var s):
                 assertEquals("ok", s.getMessage());
             }
         }
     }
+
+    @Test
+    void complexAssociatedValues_generic() {
+        try (var arena = SwiftArena.ofConfined()) {
+            var e = ComplexAssociatedValues.generic(
+                    MyIDs.makeIntID(42L, arena),
+                    MySwiftLibrary.makeIntGenericEnum(arena),
+                    arena
+            );
+            assertEquals(
+                    Optional.of("42"),
+                    e.getAsGeneric(arena).map(v -> v.arg0().getDescription())
+            );
+        }
+    }
+
+    @Test
+    void complexAssociatedValues_optionalTypealiasedGeneric() {
+        try (var arena = SwiftArena.ofConfined()) {
+            var e = ComplexAssociatedValues.optionalTypealiasedGeneric(
+                    Optional.of(MyIDs.makeIntID(42L, arena)),
+                    arena
+            );
+            assertDoesNotThrow(() -> {
+                var id = e.getAsOptionalTypealiasedGeneric(arena).orElseThrow().id();
+                assertEquals(Optional.of("42"), id.map(MyID::getDescription));
+            });
+        }
+    }
+
+    @Test
+    void complexAssociatedValues_array() {
+        try (var arena = SwiftArena.ofConfined()) {
+            var e = ComplexAssociatedValues.array(
+                    new String[]{"Hello", "World"},
+                    arena
+            );
+            assertDoesNotThrow(() -> {
+                var value = e.getAsArray().orElseThrow().arg0();
+                assertArrayEquals(new String[]{"Hello", "World"}, value);
+            });
+        }
+    }
 }

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

@@ -56,6 +56,13 @@ void labeledTuple() {
         Tuple2<Integer, Integer> check = result;
     }
 
+    @Test
+    void echoSingleTuple() {
+        var input = "Swift";
+        String result = MySwiftLibrary.echoSingleTuple(input);
+        assertEquals(input, result);
+    }
+
     @Test
     void echoTriple() {
         Tuple3<Boolean, Double, Long> input = new Tuple3<>(true, 3.14, 100L);

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -503,22 +503,12 @@ extension JNISwift2JavaGenerator {
           continue
         }
 
-        let members = translatedCase.translatedValues.map {
-          $0.parameter.renderParameter()
+        let members = translatedCase.parameters.map {
+          $0.renderParameter()
         }
-        let caseName = enumCase.name.firstCharacterUppercased
 
         // Print record
-        printer.printBraceBlock("record \(caseName)(\(members.joined(separator: ", "))) implements Case") {
-          printer in
-          let nativeParameters = zip(translatedCase.translatedValues, translatedCase.parameterConversions).map {
-            value,
-            conversion in
-            "\(conversion.native.javaType) \(value.parameter.name)"
-          }
-
-          printer.print("record _NativeParameters(\(nativeParameters.joined(separator: ", "))) {}")
-        }
+        printer.print("record \(translatedCase.name)(\(members.joined(separator: ", "))) implements Case {}")
       }
     }
     printer.println()
@@ -533,10 +523,16 @@ extension JNISwift2JavaGenerator {
           guard let translatedCase = self.translatedEnumCase(for: enumCase) else {
             continue
           }
-          let arenaArgument = translatedCase.requiresSwiftArena ? "swiftArena" : ""
-          printer.print(
-            "case \(enumCase.name.uppercased()) -> this.getAs\(enumCase.name.firstCharacterUppercased)(\(arenaArgument)).orElseThrow();"
-          )
+          if enumCase.parameters.isEmpty {
+            printer.print(
+              "case \(enumCase.name.uppercased()) -> new Case.\(translatedCase.name)();"
+            )
+          } else {
+            let arenaArgument = translatedCase.requiresSwiftArena ? "swiftArena" : ""
+            printer.print(
+              "case \(enumCase.name.uppercased()) -> this.getAs\(translatedCase.name)(\(arenaArgument)).orElseThrow();"
+            )
+          }
         }
       }
     }
@@ -557,10 +553,49 @@ extension JNISwift2JavaGenerator {
   private func printEnumCases(_ printer: inout CodePrinter, _ decl: ImportedNominalType) {
     for enumCase in decl.cases {
       guard let translatedCase = self.translatedEnumCase(for: enumCase) else {
-        return
+        continue
+      }
+
+      let caseType = JavaType.class(package: nil, name: "Case.\(translatedCase.name)")
+      let resultType = JavaType.optional(caseType)
+      if let getAsCaseFunctionDecl = translatedCase.getAsCaseFunction,
+        var getAsCaseFunction = self.translatedDecl(for: getAsCaseFunctionDecl)
+      {
+        let args =
+          if enumCase.parameters.count == 1 {
+            "t"
+          } else {
+            (0..<enumCase.parameters.count).map { i in
+              "t.$\(i)"
+            }.joined(separator: ", ")
+          }
+        let translatedResult = getAsCaseFunction.translatedFunctionSignature.result
+        getAsCaseFunction.translatedFunctionSignature.result.conversion = .method(
+          .placeToVar(translatedResult.conversion, name: "associatedValues$", type: translatedResult.javaType),
+          function: "map",
+          arguments: [
+            .lambda(
+              args: ["t"],
+              body: .constructJavaClass(.constant(args), caseType)
+            )
+          ]
+        )
+        getAsCaseFunction.translatedFunctionSignature.result.javaType = resultType
+        printJavaBindingWrapperMethod(&printer, getAsCaseFunction, skipMethodBody: false)
+      } else {
+        let getAsCaseName = "getAs\(translatedCase.name)"
+        printer.print(
+          """
+          public \(resultType) \(getAsCaseName)() {
+            if (getDiscriminator() != Discriminator.\(enumCase.name.uppercased())) {
+              return java.util.Optional.empty();
+            }
+            return java.util.Optional.of(new Case.\(translatedCase.name)());
+          }
+          """
+        )
       }
 
-      self.printJavaBindingWrapperMethod(&printer, translatedCase.getAsCaseFunction, skipMethodBody: false)
       printer.println()
     }
   }