jextract/jni: Support generic types within Optional and Tuple

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/GenericType.swift

@@ -22,20 +22,50 @@ public struct MyID<T> {
   }
 }
 
-public func makeIntID(_ value: Int) -> MyID<Int> {
-  MyID(value)
-}
+public enum MyIDs {
+  public static func makeIntID(_ value: Int) -> MyID<Int> {
+    MyID(value)
+  }
 
-public func makeStringID(_ value: String) -> MyID<String> {
-  MyID(value)
-}
+  public static func takeIntValue(from value: MyID<Int>) -> Int {
+    value.rawValue
+  }
 
-public func takeIntValue(from value: MyID<Int>) -> Int {
-  value.rawValue
-}
+  public static func makeStringID(_ value: String) -> MyID<String> {
+    MyID(value)
+  }
 
-public func takeStringValue(from value: MyID<String>) -> String {
-  value.rawValue
+  public static func takeStringValue(from value: MyID<String>) -> String {
+    value.rawValue
+  }
+
+  public static func makeIDs(_ stringValue: String, _ intValue: Int) -> (MyID<String>, MyID<Int>) {
+    (MyID(stringValue), MyID(intValue))
+  }
+
+  public static func takeValuesFromTuple(_ tuple: (MyID<String>, MyID<Int>)) -> (String, Int) {
+    (tuple.0.rawValue, tuple.1.rawValue)
+  }
+
+  public static func makeDoubleIDOptional(_ value: Double) -> MyID<Double>? {
+    MyID(value)
+  }
+
+  public static func takeDoubleValueOptional(from id: MyID<Double>?) -> Double? {
+    id?.rawValue
+  }
+
+  public static func takeDoubleValue(from value: MyID<Double>) -> Double {
+    value.rawValue
+  }
+
+  public static func makeOptionalStringID(_ value: String?) -> MyID<String?> {
+    MyID(value)
+  }
+
+  public static func takeOptionalStringValue(from id: MyID<String?>) -> String? {
+    id.rawValue
+  }
 }
 
 public struct MyEntity {

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

@@ -14,29 +14,47 @@
 
 package com.example.swift;
 
+import java.util.Optional;
+import java.util.OptionalLong;
 import org.junit.jupiter.api.Test;
 import org.swift.swiftkit.core.SwiftArena;
+import org.swift.swiftkit.core.tuple.Tuple2;
 
 import static org.junit.jupiter.api.Assertions.*;
 
 public class GenericTypeTest {
     @Test
     void genericTypeValueRoundtrip() {
         try (var arena = SwiftArena.ofConfined()) {
-            MyID<String> stringId = MySwiftLibrary.makeStringID("Java", arena);
+            MyID<String> stringId = MyIDs.makeStringID("Java", arena);
             assertEquals("Java", stringId.getDescription());
-            assertEquals("Java", MySwiftLibrary.takeStringValue(stringId));
+            assertEquals("Java", MyIDs.takeStringValue(stringId));
 
-            MyID<Long> intId = MySwiftLibrary.makeIntID(42, arena);
+            MyID<Long> intId = MyIDs.makeIntID(42, arena);
             assertEquals("42", intId.getDescription());
-            assertEquals(42, MySwiftLibrary.takeIntValue(intId));
+            assertEquals(42, MyIDs.takeIntValue(intId));
+
+            Tuple2<MyID<String>, MyID<Long>> ids = MyIDs.makeIDs("Java", 42, arena);
+            assertEquals("Java", ids.$0.getDescription());
+            assertEquals("42", ids.$1.getDescription());
+            assertEquals("Java", MyIDs.takeValuesFromTuple(ids).$0);
+            assertEquals(42, MyIDs.takeValuesFromTuple(ids).$1);
+
+            Optional<MyID<Double>> doubleIdOptional = MyIDs.makeDoubleIDOptional(42.195, arena);
+            assertTrue(doubleIdOptional.isPresent());
+            assertEquals(42.195, MyIDs.takeDoubleValueOptional(doubleIdOptional).getAsDouble());
+            assertEquals(42.195, MyIDs.takeDoubleValue(doubleIdOptional.get())); // ensure wrapped value is alive
+
+            MyID<Optional<String>> optionalStringId = MyIDs.makeOptionalStringID(Optional.of("Java"), arena);
+            assertEquals("Optional(\"Java\")", optionalStringId.getDescription());
+            assertEquals("Java", MyIDs.takeOptionalStringValue(optionalStringId).get());
         }
     }
 
     @Test
     void genericTypeProperty() {
         try (var arena = SwiftArena.ofConfined()) {
-            MyID<Long> intId = MySwiftLibrary.makeIntID(42, arena);
+            MyID<Long> intId = MyIDs.makeIntID(42, arena);
             MyEntity entity = MyEntity.init(intId, "name", arena);
             assertEquals("42", entity.getId(arena).getDescription());
         }

Sources/JExtractSwiftLib/Convenience/JavaType+Extensions.swift

@@ -164,18 +164,31 @@ extension JavaType {
   /// 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
+    case .boolean: return "Boolean"
+    case .byte: return "Byte"
+    case .char: return "Character"
+    case .short: return "Short"
+    case .int: return "Integer"
+    case .long: return "Long"
+    case .float: return "Float"
+    case .double: return "Double"
+    case .void: return "Void"
+    case .javaLangString: return "String"
+    case .class(let package, let name, let typeParameters):
+      let packagePart: String =
+        if let package {
+          "\(package)."
+        } else {
+          ""
+        }
+      let genericClause: String =
+        if !typeParameters.isEmpty {
+          "<\(typeParameters.map(\.boxedName).joined(separator: ", "))>"
+        } else {
+          ""
+        }
+      return "\(packagePart)\(name)\(genericClause)"
+    case .array: return description
     }
   }
 }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -732,7 +732,13 @@ extension JNISwift2JavaGenerator {
     if translatedFunctionSignature.resultType.javaType.isVoid {
       printer.print("\(downcall);")
     } else {
-      let result = translatedFunctionSignature.resultType.conversion.render(&printer, downcall)
+      let result: String
+      if translatedDecl.nativeFunctionSignature.result.javaType.isVoid {
+        printer.print("\(downcall);")
+        result = translatedFunctionSignature.resultType.conversion.render(&printer, "")
+      } else {
+        result = translatedFunctionSignature.resultType.conversion.render(&printer, downcall)
+      }
       printer.print("return \(result);")
     }
   }