Support calling async Swift throwing functions from Rust via Result<(), E>

SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunner/AsyncSwiftFunctions.swift

@@ -35,3 +35,57 @@ func swift_async_throws(succeed: Bool) async throws(SwiftAsyncError) -> UInt32 {
         throw SwiftAsyncError.ErrorWithValue(456)
     }
 }
+
+/// An async Swift function that throws but returns void (maps to Result<(), E> in Rust)
+/// Uses typed throws (Swift 5.9+) to ensure compile-time verification of error type
+func swift_async_throws_void(succeed: Bool) async throws(SwiftAsyncVoidError) {
+    try? await Task.sleep(nanoseconds: 1_000_000) // 1ms
+    if !succeed {
+        throw SwiftAsyncVoidError.ErrorWithValue(789)
+    }
+    // On success, just return (void)
+}
+
+// =============================================================================
+// Async Swift class with methods that can be called from Rust
+// =============================================================================
+
+/// A Swift class with async methods for testing async method calls from Rust
+class AsyncSwiftType {
+    private let value: UInt32
+
+    init(value: UInt32) {
+        self.value = value
+    }
+
+    /// Simple async method returning the stored value
+    func get_value() async -> UInt32 {
+        try? await Task.sleep(nanoseconds: 1_000_000) // 1ms
+        return value
+    }
+
+    /// Async method with an argument that adds to the stored value
+    func add_to_value(amount: UInt32) async -> UInt32 {
+        try? await Task.sleep(nanoseconds: 1_000_000) // 1ms
+        return value + amount
+    }
+
+    /// Async method that can throw an error (maps to Result<T, E> in Rust)
+    func maybe_get_value(succeed: Bool) async throws(SwiftAsyncMethodError) -> UInt32 {
+        try? await Task.sleep(nanoseconds: 1_000_000) // 1ms
+        if succeed {
+            return value
+        } else {
+            throw SwiftAsyncMethodError.ErrorWithValue(value)
+        }
+    }
+
+    /// Async method that throws but returns void (maps to Result<(), E> in Rust)
+    func maybe_succeed(succeed: Bool) async throws(SwiftAsyncMethodError) {
+        try? await Task.sleep(nanoseconds: 1_000_000) // 1ms
+        if !succeed {
+            throw SwiftAsyncMethodError.ErrorWithValue(555)
+        }
+        // On success, just return (void)
+    }
+}

SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunner/Result.swift

@@ -55,6 +55,12 @@ extension AsyncResultErrEnum: Error {}
 extension SwiftAsyncError: @unchecked Sendable {}
 extension SwiftAsyncError: Error {}
 
+extension SwiftAsyncVoidError: @unchecked Sendable {}
+extension SwiftAsyncVoidError: Error {}
+
+extension SwiftAsyncMethodError: @unchecked Sendable {}
+extension SwiftAsyncMethodError: Error {}
+
 // ============================================================================
 // Sync Swift throwing functions (called from Rust)
 // ============================================================================

SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/AsyncTests.swift

@@ -225,5 +225,57 @@ class AsyncTests: XCTestCase {
         let result = rust_calls_swift_async_throws_err()
         XCTAssertEqual(result, 456)
     }
+
+    /// Test that Rust can call an async Swift function that throws void (Result<(), E>) - success case
+    func testRustCallsSwiftAsyncThrowsVoidOk() throws {
+        let result = rust_calls_swift_async_throws_void_ok()
+        XCTAssertTrue(result)
+    }
+
+    /// Test that Rust can call an async Swift function that throws void (Result<(), E>) - error case
+    func testRustCallsSwiftAsyncThrowsVoidErr() throws {
+        let result = rust_calls_swift_async_throws_void_err()
+        XCTAssertEqual(result, 789)
+    }
+
+    // =========================================================================
+    // Tests for Rust calling async Swift methods with &self
+    // =========================================================================
+
+    /// Test that Rust can call an async Swift method that returns u32
+    func testRustCallsSwiftAsyncMethodReturnU32() throws {
+        let result = rust_calls_swift_async_method_return_u32()
+        XCTAssertEqual(result, 42)
+    }
+
+    /// Test that Rust can call an async Swift method with arguments
+    func testRustCallsSwiftAsyncMethodWithArgs() throws {
+        let result = rust_calls_swift_async_method_with_args()
+        XCTAssertEqual(result, 150) // 100 + 50
+    }
+
+    /// Test that Rust can call an async Swift method that throws - success case
+    func testRustCallsSwiftAsyncMethodThrowsOk() throws {
+        let result = rust_calls_swift_async_method_throws_ok()
+        XCTAssertEqual(result, 999)
+    }
+
+    /// Test that Rust can call an async Swift method that throws - error case
+    func testRustCallsSwiftAsyncMethodThrowsErr() throws {
+        let result = rust_calls_swift_async_method_throws_err()
+        XCTAssertEqual(result, 123) // The value stored in the object
+    }
+
+    /// Test that Rust can call an async Swift method that throws void (Result<(), E>) - success case
+    func testRustCallsSwiftAsyncMethodThrowsVoidOk() throws {
+        let result = rust_calls_swift_async_method_throws_void_ok()
+        XCTAssertTrue(result)
+    }
+
+    /// Test that Rust can call an async Swift method that throws void (Result<(), E>) - error case
+    func testRustCallsSwiftAsyncMethodThrowsVoidErr() throws {
+        let result = rust_calls_swift_async_method_throws_void_err()
+        XCTAssertEqual(result, 555)
+    }
 }