Support Rust async fn ret Result<(),enum> (#189)

This commit adds support for returning Result<(), TransparentEnum> from Rust async functions.

Here's an example of using this:

```Rust
//Rust
#[swift_bridge::bridge]
mod ffi {
    enum SomeEnum {
       //...
    }
    extern "Rust" {
        async fn some_function() -> Result<(), SomeEnum>;
    }
}
```

```Swift
//Swift
do {
    let value = try await some_function()
    //...
} catch let error as SomeEnum {
    //...
} catch {
    //...
}
```

Author: NiwakaDev

SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/AsyncTests.swift

@@ -87,8 +87,6 @@ class AsyncTests: XCTestCase {
             XCTFail()
         } catch let error as AsyncResultErrEnum {
             switch error {
-            case .NoFields:
-                XCTFail()
             case .UnnamedFields(_, _):
                 XCTFail()
             case .NamedFields(let valueUInt32):
@@ -114,8 +112,6 @@ class AsyncTests: XCTestCase {
             let _: AsyncResultOpaqueRustType1 = try await rust_async_func_return_result_opaque_rust_and_transparent_enum(false)
         } catch let error as AsyncResultErrEnum {
             switch error {
-            case .NoFields:
-                XCTFail()
             case .UnnamedFields(_, _):
                 XCTFail()
             case .NamedFields(let value):
@@ -155,6 +151,32 @@ class AsyncTests: XCTestCase {
 
     }
 
+    /// Verify that we can return a Result<(), TransparentEnum> from async Rust function
+    func testSwiftCallsRustAsyncFnReturnResultNullTransparentEnum() async throws {
+        //Should return an Unit type
+        do {
+            let _: () = try await rust_async_func_return_result_null_and_transparent_enum(true)
+        } catch {
+            XCTFail()
+        }
+        
+        //Should throw an AsyncResultErrEnum
+        do {
+            let _ = try await rust_async_func_return_result_null_and_transparent_enum(false)
+            XCTFail()
+        } catch let error as AsyncResultErrEnum {
+            switch error {
+            case .UnnamedFields(let valueString, let valueInt32):
+                XCTAssertEqual(valueString.toString(), "foo")
+                XCTAssertEqual(valueInt32, 123)
+            case .NamedFields(_):
+                XCTFail()
+            }
+        } catch {
+            XCTFail()
+        }
+    }
+    
     func testSwiftCallsRustAsyncFnRetStruct() async throws {
         let _: AsyncRustFnReturnStruct = await rust_async_return_struct()
     }

crates/swift-bridge-ir/src/bridged_type/bridgeable_result.rs

@@ -184,9 +184,6 @@ impl BuiltInResult {
                 )
             }
             TypePosition::SwiftCallsRustAsyncOnCompleteReturnTy => {
-                if self.ok_ty.can_be_encoded_with_zero_bytes() {
-                    todo!()
-                }
                 if self.err_ty.can_be_encoded_with_zero_bytes() {
                     todo!()
                 }
@@ -417,11 +414,15 @@ typedef struct {c_enum_name}{{{c_tag_name} tag; union {c_fields_name} payload;}}
         types: &TypeDeclarations,
     ) -> String {
         if self.is_custom_result_type() {
-            let ok = self.ok_ty.convert_ffi_expression_to_swift_type(
-                &format!("{expression}.payload.ok"),
-                type_pos,
-                types,
-            );
+            let ok = if self.ok_ty.can_be_encoded_with_zero_bytes() {
+                "()".to_string()
+            } else {
+                self.ok_ty.convert_ffi_expression_to_swift_type(
+                    &format!("{expression}.payload.ok"),
+                    type_pos,
+                    types,
+                )
+            };
             let err = self.err_ty.convert_ffi_expression_to_swift_type(
                 &format!("{expression}.payload.err"),
                 type_pos,

crates/swift-bridge-ir/src/codegen/codegen_tests/async_function_codegen_tests.rs

@@ -852,3 +852,100 @@ void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge_
         .test();
     }
 }
+
+/// Verify that we generate the correct code for extern "Rust" async functions that returns a Result<(), TransparentEnum>.
+mod extern_rust_async_function_returns_result_null_transparent_enum {
+    use super::*;
+
+    fn bridge_module() -> TokenStream {
+        quote! {
+            #[swift_bridge::bridge]
+            mod ffi {
+                enum ErrEnum {
+                    ErrVariant1,
+                    ErrVariant2,
+                }
+                extern "Rust" {
+                    async fn some_function() -> Result<(), ErrEnum>;
+                }
+            }
+        }
+    }
+
+    fn expected_rust_tokens() -> ExpectedRustTokens {
+        ExpectedRustTokens::Contains(quote! {
+             pub extern "C" fn __swift_bridge__some_function(
+                callback_wrapper: *mut std::ffi::c_void,
+                callback: extern "C" fn(*mut std::ffi::c_void, ResultVoidAndErrEnum) -> (),
+            ) {
+                let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
+                let fut = super::some_function();
+                let task = async move {
+                let val = match fut.await {
+                    Ok(ok) => ResultVoidAndErrEnum::Ok,
+                    Err(err) => ResultVoidAndErrEnum::Err(err.into_ffi_repr()),
+                };
+                    let callback_wrapper = callback_wrapper;
+                    let callback_wrapper = callback_wrapper.0;
+
+                    (callback)(callback_wrapper, val)
+                };
+                swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
+            }
+        })
+    }
+
+    // TODO: Replace `Error` with the concrete error type `ErrorType`.
+    // As of Feb 2023 using the concrete error type leads to a compile time error.
+    // This seems like a bug in the Swift compiler.
+
+    fn expected_swift_code() -> ExpectedSwiftCode {
+        ExpectedSwiftCode::ContainsAfterTrim(
+            r#"
+public func some_function() async throws -> () {
+    func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?, rustFnRetVal: __swift_bridge__$ResultVoidAndErrEnum) {
+        let wrapper = Unmanaged<CbWrapper$some_function>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
+        switch rustFnRetVal.tag { case __swift_bridge__$ResultVoidAndErrEnum$ResultOk: wrapper.cb(.success(())) case __swift_bridge__$ResultVoidAndErrEnum$ResultErr: wrapper.cb(.failure(rustFnRetVal.payload.err.intoSwiftRepr())) default: fatalError() }
+    }
+
+    return try await withCheckedThrowingContinuation({ (continuation: CheckedContinuation<(), Error>) in
+        let callback = { rustFnRetVal in
+            continuation.resume(with: rustFnRetVal)
+        }
+
+        let wrapper = CbWrapper$some_function(cb: callback)
+        let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
+
+        __swift_bridge__$some_function(wrapperPtr, onComplete)
+    })
+}
+class CbWrapper$some_function {
+    var cb: (Result<(), Error>) -> ()
+
+    public init(cb: @escaping (Result<(), Error>) -> ()) {
+        self.cb = cb
+    }
+}
+"#,
+        )
+    }
+
+    fn expected_c_header() -> ExpectedCHeader {
+        ExpectedCHeader::ContainsAfterTrim(
+            r#"
+void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge__$some_function$async(void* callback_wrapper, struct __swift_bridge__$ResultVoidAndErrEnum ret));
+    "#,
+        )
+    }
+
+    #[test]
+    fn extern_rust_async_function_returns_result_null_transparent_enum() {
+        CodegenTest {
+            bridge_module: bridge_module().into(),
+            expected_rust_tokens: expected_rust_tokens(),
+            expected_swift_code: expected_swift_code(),
+            expected_c_header: expected_c_header(),
+        }
+        .test();
+    }
+}

crates/swift-integration-tests/src/async_function.rs

@@ -46,7 +46,6 @@ mod ffi {
     }
 
     enum AsyncResultErrEnum {
-        NoFields,
         UnnamedFields(String, i32),
         NamedFields { value: u32 },
     }
@@ -61,6 +60,9 @@ mod ffi {
         async fn rust_async_func_return_result_transparent_enum_and_opaque_rust(
             succeed: bool,
         ) -> Result<AsyncResultOkEnum, AsyncResultOpaqueRustType1>;
+        async fn rust_async_func_return_result_null_and_transparent_enum(
+            succeed: bool,
+        ) -> Result<(), AsyncResultErrEnum>;
     }
 }
 
@@ -161,3 +163,16 @@ async fn rust_async_func_return_result_transparent_enum_and_opaque_rust(
         Err(AsyncResultOpaqueRustType1(1000))
     }
 }
+
+async fn rust_async_func_return_result_null_and_transparent_enum(
+    succeed: bool,
+) -> Result<(), ffi::AsyncResultErrEnum> {
+    if succeed {
+        Ok(())
+    } else {
+        Err(ffi::AsyncResultErrEnum::UnnamedFields(
+            "foo".to_string(),
+            123,
+        ))
+    }
+}