add support for jextract classes

Author: madsodgaard

Samples/JExtractJNISampleApp/src/test/java/com/example/swift/OptionalsTest.java

@@ -84,8 +84,10 @@ void optionalString() {
     void optionalClass() {
         try (var arena = new ConfinedSwiftMemorySession()) {
             MySwiftClass c = MySwiftClass.init(arena);
-            assertEquals(Optional.empty(), MySwiftLibrary.optionalClass(Optional.empty()));
-            assertEquals(Optional.of(c), MySwiftLibrary.optionalClass(Optional.of(c)));
+            assertEquals(Optional.empty(), MySwiftLibrary.optionalClass(Optional.empty(), arena));
+            Optional<MySwiftClass> optionalClass = MySwiftLibrary.optionalClass(Optional.of(c), arena);
+            assertTrue(optionalClass.isPresent());
+            assertEquals(c.getX(), optionalClass.get().getX());
         }
     }
 }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaTranslation.swift

@@ -362,7 +362,7 @@ extension JNISwift2JavaGenerator {
             throw JavaTranslationError.unsupportedSwiftType(swiftType)
           }
 
-          let (returnType, staticCallee) = switch javaType {
+          let (returnType, optionalClass) = switch javaType {
           case .boolean: ("Optional<Boolean>", "Optional")
           case .byte: ("Optional<Byte>", "Optional")
           case .char: ("Optional<Character>", "Optional")
@@ -387,7 +387,7 @@ extension JNISwift2JavaGenerator {
                 nextIntergralTypeWithSpaceForByte.java,
                 valueType: javaType,
                 valueSizeInBytes: nextIntergralTypeWithSpaceForByte.valueBytes,
-                optionalType: staticCallee
+                optionalType: optionalClass
               )
             )
           } else {
@@ -398,19 +398,11 @@ extension JNISwift2JavaGenerator {
               outParameters: [
                 OutParameter(name: "result_discriminator$", type: .array(.byte), allocation: .newArray(.byte, size: 1))
               ],
-              conversion: .aggregate(
-                name: "result$",
-                type: javaType,
-                [
-                  .ternary(
-                    .equals(
-                      .subscriptOf(.constant("result_discriminator$"), arguments: [.constant("0")]),
-                      .constant("1")
-                    ),
-                    thenExp: .method(.constant(staticCallee), function: "of", arguments: [.constant("result$")]),
-                    elseExp: .method(.constant(staticCallee), function: "empty")
-                  )
-                ]
+              conversion: .toOptionalFromIndirectReturn(
+                discriminatorName: "result_discriminator$",
+                optionalClass: optionalClass,
+                javaType: javaType,
+                toValue: .placeholder
               )
             )
           }
@@ -420,8 +412,20 @@ extension JNISwift2JavaGenerator {
           throw JavaTranslationError.unsupportedSwiftType(swiftType)
         }
 
-        // Assume JExtract imported class
-        throw JavaTranslationError.unsupportedSwiftType(swiftType)
+        // We assume this is a JExtract class.
+        let returnType = JavaType.class(package: nil, name: "Optional<\(nominalTypeName)>")
+        return TranslatedResult(
+          javaType: returnType,
+          outParameters: [
+            OutParameter(name: "result_discriminator$", type: .array(.byte), allocation: .newArray(.byte, size: 1))
+          ],
+          conversion: .toOptionalFromIndirectReturn(
+            discriminatorName: "result_discriminator$",
+            optionalClass: "Optional",
+            javaType: .long,
+            toValue: .constructSwiftValue(.placeholder, .class(package: nil, name: nominalTypeName))
+          )
+        )
 
       default:
         throw JavaTranslationError.unsupportedSwiftType(swiftType)
@@ -558,6 +562,28 @@ extension JNISwift2JavaGenerator {
 
     indirect case subscriptOf(JavaNativeConversionStep, arguments: [JavaNativeConversionStep])
 
+    static func toOptionalFromIndirectReturn(
+      discriminatorName: String,
+      optionalClass: String,
+      javaType: JavaType,
+      toValue valueConversion: JavaNativeConversionStep
+    ) -> JavaNativeConversionStep {
+      .aggregate(
+        name: "result$",
+        type: javaType,
+        [
+          .ternary(
+            .equals(
+              .subscriptOf(.constant(discriminatorName), arguments: [.constant("0")]),
+              .constant("1")
+            ),
+            thenExp: .method(.constant(optionalClass), function: "of", arguments: [valueConversion]),
+            elseExp: .method(.constant(optionalClass), function: "empty")
+          )
+        ]
+      )
+    }
+
     /// Perform multiple conversions using the same input.
     case aggregate(name: String, type: JavaType, [JavaNativeConversionStep])
 
@@ -652,8 +678,8 @@ extension JNISwift2JavaGenerator {
       case .commaSeparated(let list):
         return list.contains(where: { $0.requiresSwiftArena })
 
-      case .method(let inner, _, _):
-        return inner.requiresSwiftArena
+      case .method(let inner, _, let args):
+        return inner.requiresSwiftArena || args.contains(where: \.requiresSwiftArena)
 
       case .combinedValueToOptional(let inner, _, _, _, _):
         return inner.requiresSwiftArena

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+NativeTranslation.swift

@@ -237,7 +237,8 @@ extension JNISwift2JavaGenerator {
             return NativeResult(
               javaType: javaType,
               conversion: .optionalRaisingIndirectReturn(
-                .getJNIValue(.optionalChain(.placeholder)),
+                .getJNIValue(.placeholder),
+                returnType: javaType,
                 discriminatorParameterName: discriminatorName,
                 placeholderValue: .member(
                   .constant("\(swiftType)"),
@@ -257,8 +258,20 @@ extension JNISwift2JavaGenerator {
         }
 
         // Assume JExtract imported class
-        // TODO: Should be the same as above, just with a long and different conversion?
-        throw JavaTranslationError.unsupportedSwiftType(swiftType)
+        let discriminatorName = "result_discriminator$"
+
+        return NativeResult(
+          javaType: .long,
+          conversion: .optionalRaisingIndirectReturn(
+            .getJNIValue(.allocateSwiftValue(name: "_result", swiftType: swiftType)),
+            returnType: .long,
+            discriminatorParameterName: discriminatorName,
+            placeholderValue: .constant("0")
+          ),
+          outParameters: [
+            JavaParameter(name: discriminatorName, type: .array(.byte))
+          ]
+        )
 
       default:
         throw JavaTranslationError.unsupportedSwiftType(swiftType)
@@ -443,7 +456,7 @@ extension JNISwift2JavaGenerator {
 
     indirect case optionalRaisingWidenIntegerType(NativeSwiftConversionStep, valueType: JavaType, combinedSwiftType: String, valueSizeInBytes: Int)
 
-    indirect case optionalRaisingIndirectReturn(NativeSwiftConversionStep, discriminatorParameterName: String, placeholderValue: NativeSwiftConversionStep)
+    indirect case optionalRaisingIndirectReturn(NativeSwiftConversionStep, returnType: JavaType, discriminatorParameterName: String, placeholderValue: NativeSwiftConversionStep)
 
     indirect case method(NativeSwiftConversionStep, function: String, arguments: [(String?, NativeSwiftConversionStep)] = [])
 
@@ -574,17 +587,30 @@ extension JNISwift2JavaGenerator {
         )
         return "value$"
 
-      case .optionalRaisingIndirectReturn(let inner, let discriminatorParameterName, let placeholderValue):
-        let inner = inner.render(&printer, placeholder)
-        let placeholderValue = placeholderValue.render(&printer, placeholder)
-        printer.print(
-          """
-          let result$ = \(inner)
-          var flag$ = result$ != nil ? jbyte(1) : jbyte(2) 
-          environment.interface.SetByteArrayRegion(environment, \(discriminatorParameterName), 0, 1, &flag$)
-          """
-        )
-        return "result$ ?? \(placeholderValue)"
+      case .optionalRaisingIndirectReturn(let inner, let returnType, let discriminatorParameterName, let placeholderValue):
+        printer.print("let result$: \(returnType.jniTypeName)")
+        printer.printBraceBlock("if let innerResult$ = \(placeholder)") { printer in
+          let inner = inner.render(&printer, "innerResult$")
+          printer.print(
+            """
+            result$ = \(inner) 
+            var flag$ = Int8(1)
+            environment.interface.SetByteArrayRegion(environment, \(discriminatorParameterName), 0, 1, &flag$)
+            """
+          )
+        }
+        printer.printBraceBlock("else") { printer in
+          let placeholderValue = placeholderValue.render(&printer, placeholder)
+          printer.print(
+            """
+            result$ = \(placeholderValue)
+            var flag$ = Int8(0)
+            environment.interface.SetByteArrayRegion(environment, \(discriminatorParameterName), 0, 1, &flag$)
+            """
+          )
+        }
+
+        return "result$"
 
       case .method(let inner, let methodName, let arguments):
         let inner = inner.render(&printer, placeholder)