add support for async throws

Author: madsodgaard

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/Async.swift

@@ -19,8 +19,8 @@ public func asyncSum(i1: Int64, i2: Int64) async -> Int64 {
   return i1 + i2
 }
 
-public func asyncCopy(myClass: MySwiftClass) async -> MySwiftClass {
+public func asyncCopy(myClass: MySwiftClass) async throws -> MySwiftClass {
   let new = MySwiftClass(x: myClass.x, y: myClass.y)
-  try? await Task.sleep(for: .milliseconds(500))
+  try await Task.sleep(for: .milliseconds(500))
   return new
 }

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/MySwiftError.swift

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+enum MySwiftError: Error {
+  case swiftError
+}

Samples/SwiftJavaExtractJNISampleApp/Sources/MySwiftLibrary/Optionals.swift

@@ -62,6 +62,10 @@ public func optionalJavaKitLong(input: Optional<JavaLong>) -> Int64? {
   }
 }
 
+public func optionalThrowing() throws -> Int64? {
+  throw MySwiftError.swiftError
+}
+
 public func multipleOptionals(
   input1: Optional<Int8>,
   input2: Optional<Int16>,

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

@@ -14,6 +14,7 @@
 
 package com.example.swift;
 
+import com.example.swift.MySwiftLibrary;
 import org.junit.jupiter.api.Test;
 import org.swift.swiftkit.core.SwiftArena;
 
@@ -22,8 +23,7 @@
 import java.util.OptionalInt;
 import java.util.OptionalLong;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class OptionalsTest {
     @Test
@@ -113,4 +113,13 @@ void multipleOptionals() {
             assertEquals(result, OptionalLong.of(1L));
         }
     }
+
+    @Test
+    void optionalThrows() {
+        try (var arena = SwiftArena.ofConfined()) {
+            Exception exception = assertThrows(Exception.class, () -> MySwiftLibrary.optionalThrowing());
+
+            assertEquals("swiftError", exception.getMessage());
+        }
+    }
 }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+NativeTranslation.swift

@@ -526,6 +526,7 @@ extension JNISwift2JavaGenerator {
           javaType: result.javaType,
           conversion: .asyncBlocking(
             result.conversion,
+            isThrowing: functionSignature.effectSpecifiers.contains(.throws),
             swiftFunctionResultType: functionSignature.result.type
           ),
           outParameters: result.outParameters
@@ -619,7 +620,7 @@ extension JNISwift2JavaGenerator {
 
     indirect case unwrapOptional(NativeSwiftConversionStep, name: String, fatalErrorMessage: String)
 
-    indirect case asyncBlocking(NativeSwiftConversionStep, swiftFunctionResultType: SwiftType)
+    indirect case asyncBlocking(NativeSwiftConversionStep, isThrowing: Bool, swiftFunctionResultType: SwiftType)
 
     /// Returns the conversion string applied to the placeholder.
     func render(_ printer: inout CodePrinter, _ placeholder: String) -> String {
@@ -849,24 +850,30 @@ extension JNISwift2JavaGenerator {
         )
         return unwrappedName
 
-      case .asyncBlocking(let inner, let swiftFunctionResultType):
+      case .asyncBlocking(let inner, let isThrowing, let swiftFunctionResultType):
         printer.print("let _semaphore$ = SwiftJava._Semaphore(value: 0)")
-        printer.print("var swiftResult$: \(swiftFunctionResultType)!")
+        let resultType = isThrowing ? "Result<\(swiftFunctionResultType), any Error>" : swiftFunctionResultType.description
+        printer.print("var swiftResult$: \(resultType)!")
 
         printer.printBraceBlock("Task") { printer in
-          printer.print(
-            """
-            swiftResult$ = await \(placeholder)
-            _semaphore$.signal()
-            """
-          )
+          if isThrowing {
+            printer.printBraceBlock("do") { printer in
+              printer.print("swiftResult$ = await Result.success(\(placeholder))")
+            }
+            printer.printBraceBlock("catch") { printer in
+              printer.print("swiftResult$ = Result.failure(error)")
+            }
+          } else {
+            printer.print("swiftResult$ = await \(placeholder)")
+          }
+          printer.print("_semaphore$.signal()")
         }
         printer.print(
           """
           _semaphore$.wait() 
           """
         )
-        let inner = inner.render(&printer, "swiftResult$")
+        let inner = inner.render(&printer, isThrowing ? "try swiftResult$.get()" : "swiftResult$")
         return inner
       }
     }

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+SwiftThunkPrinting.swift

@@ -353,29 +353,41 @@ extension JNISwift2JavaGenerator {
     }
 
     // Lower the result.
-    let innerBody: String
-    if !decl.functionSignature.result.type.isVoid {
-      let loweredResult = nativeSignature.result.conversion.render(&printer, result)
-      innerBody = "return \(loweredResult)"
-    } else {
-      innerBody = result
+    func innerBody(in printer: inout CodePrinter) -> String {
+      if !decl.functionSignature.result.type.isVoid {
+        let loweredResult = nativeSignature.result.conversion.render(&printer, result)
+        return "return \(loweredResult)"
+      } else {
+        return result
+      }
     }
 
     if decl.isThrowing {
-      // TODO: Handle classes for dummy value
-      let dummyReturn = !nativeSignature.result.javaType.isVoid ? "return \(decl.functionSignature.result.type).jniPlaceholderValue" : ""
+      let dummyReturn: String
+
+      if nativeSignature.result.javaType.isVoid {
+        dummyReturn = ""
+      } else {
+        // We assume it is something that implements JavaValue
+        dummyReturn = "return \(nativeSignature.result.javaType.swiftTypeName(resolver: { _ in "" })).jniPlaceholderValue"
+      }
+
+      printer.print("do {")
+      printer.indent()
+      printer.print(innerBody(in: &printer))
+      printer.outdent()
+      printer.print("} catch {")
+      printer.indent()
       printer.print(
-          """
-          do {
-            \(innerBody)
-          } catch {
-            environment.throwAsException(error)
-            \(dummyReturn)
-          }
-          """
+        """
+        environment.throwAsException(error)
+        \(dummyReturn)
+        """
       )
+      printer.outdent()
+      printer.print("}")
     } else {
-      printer.print(innerBody)
+      printer.print(innerBody(in: &printer))
     }
   }
 

Sources/JExtractSwiftLib/SwiftTypes/SwiftFunctionSignature.swift

@@ -245,7 +245,7 @@ extension SwiftFunctionSignature {
     if signature.effectSpecifiers?.throwsClause != nil {
       effectSpecifiers.append(.throws)
     }
-    if let asyncSpecifier = signature.effectSpecifiers?.asyncSpecifier {
+    if signature.effectSpecifiers?.asyncSpecifier != nil {
       effectSpecifiers.append(.async)
     }