Revert "Support Rust returning -> Result<_, String> (#296)"

colinmarc · colinmarc · commit db730380e90f · 2025-01-27T14:18:12.000+01:00
This reverts commit c45a38c.
diff --git a/SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/ResultTests.swift b/SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/ResultTests.swift
@@ -13,30 +13,14 @@ class ResultTests: XCTestCase {
         rust_func_takes_result_string(.Ok("Success Message"))
         rust_func_takes_result_string(.Err("Error Message"))
     }
-
-    /// Verify that we can return a Result<String, String> from Rust -> Swift.
-    ///
-    /// The Err case evidences Swift’s `Error` protocol is implemented correctly
-    /// for `RustStringRef`, i.e. `extension RustStringRef: Error {}`
-    func testSwiftCallRustReturnsResultString() throws {
-        let resultOk = try! rust_func_returns_result_string(true)
-        XCTAssertEqual(resultOk.toString(), "Success Message")
-
-        do {
-            let _ = try rust_func_returns_result_string(false)
-            XCTFail("The function should have returned an error.")
-        } catch let error as RustString {
-            XCTAssertEqual(error.toString(), "Error Message")
-        }
-    }
-
+    
     /// Verify that we can pass a Result<OpaqueRust, OpaqueRust> from Swift -> Rust
     func testSwiftCallRustResultOpaqueRust() throws {
         let reflectedOk = try! rust_func_reflect_result_opaque_rust(
             .Ok(ResultTestOpaqueRustType(111))
         )
         XCTAssertEqual(reflectedOk.val(), 111)
-
+        
         do {
             let _ = try rust_func_reflect_result_opaque_rust(
                 .Err(ResultTestOpaqueRustType(222))
@@ -46,7 +30,7 @@ class ResultTests: XCTestCase {
             XCTAssertEqual(error.val(), 222)
         }
     }
-
+    
     /// Verify that we can pass a Result<OpaqueSwift, OpaqueSwift> from Swift -> Rust
     func testSwiftCallRustResultOpaqueSwift() throws {
         rust_func_takes_result_opaque_swift(
@@ -80,7 +64,7 @@ class ResultTests: XCTestCase {
             XCTAssertEqual(error.val(), 222)
         }
     }
-
+    
     /// Verify that we can receive a Result<OpaqueRust, TransparentEnum> from Rust
     func testResultOpaqueRustTransparentEnum() throws {
         XCTContext.runActivity(named: "Should return a ResultTestOpaqueRustType") {
@@ -91,7 +75,7 @@ class ResultTests: XCTestCase {
                 XCTFail()
             }
         }
-
+    
         XCTContext.runActivity(named: "Should throw an error") {
             _ in
             do {
@@ -111,7 +95,7 @@ class ResultTests: XCTestCase {
             }
         }
     }
-
+    
     /// Verify that we can receive a Result<TransparentEnum, OpaqueRust> from Rust
     func testResultTransparentEnumOpaqueRust() throws {
         XCTContext.runActivity(named: "Should return a ResultTestOpaqueRustType") {
@@ -130,7 +114,7 @@ class ResultTests: XCTestCase {
                 XCTFail()
             }
         }
-
+    
         XCTContext.runActivity(named: "Should throw an error") {
             _ in
             do {
@@ -143,7 +127,7 @@ class ResultTests: XCTestCase {
             }
         }
     }
-
+    
     /// Verify that we can receive a Result<(), TransparentEnum> from Rust
     func testResultUnitTypeTransparentEnum() throws {
         XCTContext.runActivity(named: "Should return a Unit type") {
@@ -154,7 +138,7 @@ class ResultTests: XCTestCase {
                 XCTFail()
             }
         }
-
+    
         XCTContext.runActivity(named: "Should throw an error") {
             _ in
             do {
@@ -174,7 +158,7 @@ class ResultTests: XCTestCase {
             }
         }
     }
-
+    
     /// Verify that we can receive a Result<(primitive type, OpaqueRustType, String), TransparentEnum> from Rust
     func testResultTupleTransparentEnum() throws {
         XCTContext.runActivity(named: "Should return a tuple type") {
@@ -188,7 +172,7 @@ class ResultTests: XCTestCase {
                 XCTFail()
             }
         }
-
+        
         XCTContext.runActivity(named: "Should throw an error") {
             _ in
             do {
@@ -265,7 +249,7 @@ class ResultTests: XCTestCase {
             XCTAssertEqual(UInt32(i), value.val())
         }
     }
-
+    
     /// Verify that we can use throwing initializers defined on the Rust side.
     func testThrowingInitializers() throws {
         XCTContext.runActivity(named: "Should fail") {
diff --git a/crates/swift-bridge-build/src/generate_core/rust_string.swift b/crates/swift-bridge-build/src/generate_core/rust_string.swift
@@ -47,9 +47,6 @@ extension RustStringRef {
         __swift_bridge__$RustString$trim(ptr)
     }
 }
-/// exercised in SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/ResultTests.swift:
-///   - see `func testSwiftCallRustReturnsResultString`
-extension RustStringRef: Error {}
 extension RustString: Vectorizable {
     public static func vecOfSelfNew() -> UnsafeMutableRawPointer {
         __swift_bridge__$Vec_RustString$new()
@@ -97,4 +94,4 @@ extension RustString: Vectorizable {
     public static func vecOfSelfLen(vecPtr: UnsafeMutableRawPointer) -> UInt {
         __swift_bridge__$Vec_RustString$len(vecPtr)
     }
-}
+}
diff --git a/crates/swift-bridge-ir/src/codegen/codegen_tests/result_codegen_tests.rs b/crates/swift-bridge-ir/src/codegen/codegen_tests/result_codegen_tests.rs
@@ -4,7 +4,7 @@ use super::{CodegenTest, ExpectedCHeader, ExpectedRustTokens, ExpectedSwiftCode}
 use proc_macro2::TokenStream;
 use quote::quote;
 
-/// Test code generation for Rust function that accepts a Result<T, E>
+/// Test code generation for Rust function that accepts and returns a Result<T, E>
 /// where T and E are Strings.
 mod extern_rust_fn_result_string {
     use super::*;
@@ -64,72 +64,6 @@ void __swift_bridge__$some_function(struct __private__ResultPtrAndPtr arg);
     }
 }
 
-/// Test code generation for Rust function that returns a Result<T, E>
-/// where T and E are Strings.
-mod extern_rust_fn_return_result_string {
-    use super::*;
-
-    fn bridge_module_tokens() -> TokenStream {
-        quote! {
-            mod ffi {
-                extern "Rust" {
-                    fn some_function() -> Result<String, String>;
-                }
-            }
-        }
-    }
-
-    fn expected_rust_tokens() -> ExpectedRustTokens {
-        ExpectedRustTokens::Contains(quote! {
-            #[export_name = "__swift_bridge__$some_function"]
-            pub extern "C" fn __swift_bridge__some_function(
-            ) -> swift_bridge::result::ResultPtrAndPtr {
-                match super::some_function() {
-                    Ok(ok) => {
-                        swift_bridge::result::ResultPtrAndPtr {
-                            is_ok: true,
-                            ok_or_err: swift_bridge::string::RustString(ok).box_into_raw() as *mut std::ffi::c_void
-                        }
-                    }
-                    Err(err) => {
-                        swift_bridge::result::ResultPtrAndPtr {
-                            is_ok: false,
-                            ok_or_err: swift_bridge::string::RustString(err).box_into_raw() as *mut std::ffi::c_void
-                        }
-                    }
-                }
-            }
-        })
-    }
-
-    fn expected_swift_code() -> ExpectedSwiftCode {
-        ExpectedSwiftCode::ContainsAfterTrim(
-            r#"
-public func some_function() throws -> RustString {
-    try { let val = __swift_bridge__$some_function(); if val.is_ok { return RustString(ptr: val.ok_or_err!) } else { throw RustString(ptr: val.ok_or_err!) } }()
-}
-"#,
-        )
-    }
-
-    const EXPECTED_C_HEADER: ExpectedCHeader = ExpectedCHeader::ExactAfterTrim(
-        r#"
-struct __private__ResultPtrAndPtr __swift_bridge__$some_function(void);
-    "#,
-    );
-
-    #[test]
-    fn extern_rust_fn_return_result_string() {
-        CodegenTest {
-            bridge_module: bridge_module_tokens().into(),
-            expected_rust_tokens: expected_rust_tokens(),
-            expected_swift_code: expected_swift_code(),
-            expected_c_header: EXPECTED_C_HEADER,
-        }
-        .test();
-    }
-}
-
 /// Test code generation for Rust function that accepts a Result<T, E> where T and E are
 /// opaque Rust types.
 mod extern_rust_fn_arg_result_opaque_rust {
@@ -515,7 +449,7 @@ public func some_function() throws -> SomeOkType {
             r#"
 typedef enum __swift_bridge__$ResultSomeOkTypeAndSomeErrEnum$Tag {__swift_bridge__$ResultSomeOkTypeAndSomeErrEnum$ResultOk, __swift_bridge__$ResultSomeOkTypeAndSomeErrEnum$ResultErr} __swift_bridge__$ResultSomeOkTypeAndSomeErrEnum$Tag;
 union __swift_bridge__$ResultSomeOkTypeAndSomeErrEnum$Fields {void* ok; struct __swift_bridge__$SomeErrEnum err;};
-typedef struct __swift_bridge__$ResultSomeOkTypeAndSomeErrEnum{__swift_bridge__$ResultSomeOkTypeAndSomeErrEnum$Tag tag; union __swift_bridge__$ResultSomeOkTypeAndSomeErrEnum$Fields payload;} __swift_bridge__$ResultSomeOkTypeAndSomeErrEnum;
+typedef struct __swift_bridge__$ResultSomeOkTypeAndSomeErrEnum{__swift_bridge__$ResultSomeOkTypeAndSomeErrEnum$Tag tag; union __swift_bridge__$ResultSomeOkTypeAndSomeErrEnum$Fields payload;} __swift_bridge__$ResultSomeOkTypeAndSomeErrEnum;        
 "#,
             r#"struct __swift_bridge__$ResultSomeOkTypeAndSomeErrEnum __swift_bridge__$some_function(void)"#,
         ])
@@ -597,7 +531,7 @@ public func some_function() throws -> SomeOkEnum {
             r#"
 typedef enum __swift_bridge__$ResultSomeOkEnumAndSomeErrType$Tag {__swift_bridge__$ResultSomeOkEnumAndSomeErrType$ResultOk, __swift_bridge__$ResultSomeOkEnumAndSomeErrType$ResultErr} __swift_bridge__$ResultSomeOkEnumAndSomeErrType$Tag;
 union __swift_bridge__$ResultSomeOkEnumAndSomeErrType$Fields {struct __swift_bridge__$SomeOkEnum ok; void* err;};
-typedef struct __swift_bridge__$ResultSomeOkEnumAndSomeErrType{__swift_bridge__$ResultSomeOkEnumAndSomeErrType$Tag tag; union __swift_bridge__$ResultSomeOkEnumAndSomeErrType$Fields payload;} __swift_bridge__$ResultSomeOkEnumAndSomeErrType;
+typedef struct __swift_bridge__$ResultSomeOkEnumAndSomeErrType{__swift_bridge__$ResultSomeOkEnumAndSomeErrType$Tag tag; union __swift_bridge__$ResultSomeOkEnumAndSomeErrType$Fields payload;} __swift_bridge__$ResultSomeOkEnumAndSomeErrType;        
 "#,
             r#"struct __swift_bridge__$ResultSomeOkEnumAndSomeErrType __swift_bridge__$some_function(void)"#,
         ])
@@ -672,7 +606,7 @@ public func some_function() throws -> () {
             r#"
 typedef enum __swift_bridge__$ResultVoidAndSomeErrEnum$Tag {__swift_bridge__$ResultVoidAndSomeErrEnum$ResultOk, __swift_bridge__$ResultVoidAndSomeErrEnum$ResultErr} __swift_bridge__$ResultVoidAndSomeErrEnum$Tag;
 union __swift_bridge__$ResultVoidAndSomeErrEnum$Fields {struct __swift_bridge__$SomeErrEnum err;};
-typedef struct __swift_bridge__$ResultVoidAndSomeErrEnum{__swift_bridge__$ResultVoidAndSomeErrEnum$Tag tag; union __swift_bridge__$ResultVoidAndSomeErrEnum$Fields payload;} __swift_bridge__$ResultVoidAndSomeErrEnum;
+typedef struct __swift_bridge__$ResultVoidAndSomeErrEnum{__swift_bridge__$ResultVoidAndSomeErrEnum$Tag tag; union __swift_bridge__$ResultVoidAndSomeErrEnum$Fields payload;} __swift_bridge__$ResultVoidAndSomeErrEnum;        
 "#,
             r#"struct __swift_bridge__$ResultVoidAndSomeErrEnum __swift_bridge__$some_function(void)"#,
         ])
@@ -755,7 +689,7 @@ public func some_function() throws -> (Int32, UInt32) {
             r#"
 typedef enum __swift_bridge__$ResultTupleI32U32AndSomeErrEnum$Tag {__swift_bridge__$ResultTupleI32U32AndSomeErrEnum$ResultOk, __swift_bridge__$ResultTupleI32U32AndSomeErrEnum$ResultErr} __swift_bridge__$ResultTupleI32U32AndSomeErrEnum$Tag;
 union __swift_bridge__$ResultTupleI32U32AndSomeErrEnum$Fields {struct __swift_bridge__$tuple$I32U32 ok; struct __swift_bridge__$SomeErrEnum err;};
-typedef struct __swift_bridge__$ResultTupleI32U32AndSomeErrEnum{__swift_bridge__$ResultTupleI32U32AndSomeErrEnum$Tag tag; union __swift_bridge__$ResultTupleI32U32AndSomeErrEnum$Fields payload;} __swift_bridge__$ResultTupleI32U32AndSomeErrEnum;
+typedef struct __swift_bridge__$ResultTupleI32U32AndSomeErrEnum{__swift_bridge__$ResultTupleI32U32AndSomeErrEnum$Tag tag; union __swift_bridge__$ResultTupleI32U32AndSomeErrEnum$Fields payload;} __swift_bridge__$ResultTupleI32U32AndSomeErrEnum;        
 "#,
             r#"struct __swift_bridge__$ResultTupleI32U32AndSomeErrEnum __swift_bridge__$some_function(void)"#,
             r#"typedef struct __swift_bridge__$tuple$I32U32 { int32_t _0; uint32_t _1; } __swift_bridge__$tuple$I32U32;"#,
diff --git a/crates/swift-integration-tests/src/result.rs b/crates/swift-integration-tests/src/result.rs
@@ -10,8 +10,6 @@ mod ffi {
         ) -> Result<ResultTestOpaqueRustType, ResultTestOpaqueRustType>;
 
         fn rust_func_takes_result_string(arg: Result<String, String>);
-        fn rust_func_returns_result_string(ok: bool) -> Result<String, String>;
-
         fn rust_func_takes_result_opaque_swift(
             arg: Result<ResultTestOpaqueSwiftType, ResultTestOpaqueSwiftType>,
         );
@@ -111,13 +109,6 @@ fn rust_func_takes_result_string(arg: Result<String, String>) {
     }
 }
 
-fn rust_func_returns_result_string(ok: bool) -> Result<String, String> {
-    if !ok {
-        return Err("Error Message".to_string());
-    }
-    Ok("Success Message".to_string())
-}
-
 fn rust_func_reflect_result_opaque_rust(
     arg: Result<ResultTestOpaqueRustType, ResultTestOpaqueRustType>,
 ) -> Result<ResultTestOpaqueRustType, ResultTestOpaqueRustType> {

Original file line number	Diff line number	Diff line change
`@@ -13,30 +13,14 @@ class ResultTests: XCTestCase {`
`13`	`13`	`rust_func_takes_result_string(.Ok("Success Message"))`
`14`	`14`	`rust_func_takes_result_string(.Err("Error Message"))`
`15`	`15`	`}`
`16`		`-`
`17`		`- /// Verify that we can return a Result<String, String> from Rust -> Swift.`
`18`		`- ///`
`19`		- /// The Err case evidences Swift’s `Error` protocol is implemented correctly
`20`		- /// for `RustStringRef`, i.e. `extension RustStringRef: Error {}`
`21`		`- func testSwiftCallRustReturnsResultString() throws {`
`22`		`- let resultOk = try! rust_func_returns_result_string(true)`
`23`		`- XCTAssertEqual(resultOk.toString(), "Success Message")`
`24`		`-`
`25`		`- do {`
`26`		`- let _ = try rust_func_returns_result_string(false)`
`27`		`- XCTFail("The function should have returned an error.")`
`28`		`- } catch let error as RustString {`
`29`		`- XCTAssertEqual(error.toString(), "Error Message")`
`30`		`- }`
`31`		`- }`
`32`		`-`
	`16`	`+`
`33`	`17`	`/// Verify that we can pass a Result<OpaqueRust, OpaqueRust> from Swift -> Rust`
`34`	`18`	`func testSwiftCallRustResultOpaqueRust() throws {`
`35`	`19`	`let reflectedOk = try! rust_func_reflect_result_opaque_rust(`
`36`	`20`	`.Ok(ResultTestOpaqueRustType(111))`
`37`	`21`	`)`
`38`	`22`	`XCTAssertEqual(reflectedOk.val(), 111)`
`39`		`-`
	`23`	`+`
`40`	`24`	`do {`
`41`	`25`	`let _ = try rust_func_reflect_result_opaque_rust(`
`42`	`26`	`.Err(ResultTestOpaqueRustType(222))`
`@@ -46,7 +30,7 @@ class ResultTests: XCTestCase {`
`46`	`30`	`XCTAssertEqual(error.val(), 222)`
`47`	`31`	`}`
`48`	`32`	`}`
`49`		`-`
	`33`	`+`
`50`	`34`	`/// Verify that we can pass a Result<OpaqueSwift, OpaqueSwift> from Swift -> Rust`
`51`	`35`	`func testSwiftCallRustResultOpaqueSwift() throws {`
`52`	`36`	`rust_func_takes_result_opaque_swift(`
`@@ -80,7 +64,7 @@ class ResultTests: XCTestCase {`
`80`	`64`	`XCTAssertEqual(error.val(), 222)`
`81`	`65`	`}`
`82`	`66`	`}`
`83`		`-`
	`67`	`+`
`84`	`68`	`/// Verify that we can receive a Result<OpaqueRust, TransparentEnum> from Rust`
`85`	`69`	`func testResultOpaqueRustTransparentEnum() throws {`
`86`	`70`	`XCTContext.runActivity(named: "Should return a ResultTestOpaqueRustType") {`
`@@ -91,7 +75,7 @@ class ResultTests: XCTestCase {`
`91`	`75`	`XCTFail()`
`92`	`76`	`}`
`93`	`77`	`}`
`94`		`-`
	`78`	`+`
`95`	`79`	`XCTContext.runActivity(named: "Should throw an error") {`
`96`	`80`	`_ in`
`97`	`81`	`do {`
`@@ -111,7 +95,7 @@ class ResultTests: XCTestCase {`
`111`	`95`	`}`
`112`	`96`	`}`
`113`	`97`	`}`
`114`		`-`
	`98`	`+`
`115`	`99`	`/// Verify that we can receive a Result<TransparentEnum, OpaqueRust> from Rust`
`116`	`100`	`func testResultTransparentEnumOpaqueRust() throws {`
`117`	`101`	`XCTContext.runActivity(named: "Should return a ResultTestOpaqueRustType") {`
`@@ -130,7 +114,7 @@ class ResultTests: XCTestCase {`
`130`	`114`	`XCTFail()`
`131`	`115`	`}`
`132`	`116`	`}`
`133`		`-`
	`117`	`+`
`134`	`118`	`XCTContext.runActivity(named: "Should throw an error") {`
`135`	`119`	`_ in`
`136`	`120`	`do {`
`@@ -143,7 +127,7 @@ class ResultTests: XCTestCase {`
`143`	`127`	`}`
`144`	`128`	`}`
`145`	`129`	`}`
`146`		`-`
	`130`	`+`
`147`	`131`	`/// Verify that we can receive a Result<(), TransparentEnum> from Rust`
`148`	`132`	`func testResultUnitTypeTransparentEnum() throws {`
`149`	`133`	`XCTContext.runActivity(named: "Should return a Unit type") {`
`@@ -154,7 +138,7 @@ class ResultTests: XCTestCase {`
`154`	`138`	`XCTFail()`
`155`	`139`	`}`
`156`	`140`	`}`
`157`		`-`
	`141`	`+`
`158`	`142`	`XCTContext.runActivity(named: "Should throw an error") {`
`159`	`143`	`_ in`
`160`	`144`	`do {`
`@@ -174,7 +158,7 @@ class ResultTests: XCTestCase {`
`174`	`158`	`}`
`175`	`159`	`}`
`176`	`160`	`}`
`177`		`-`
	`161`	`+`
`178`	`162`	`/// Verify that we can receive a Result<(primitive type, OpaqueRustType, String), TransparentEnum> from Rust`
`179`	`163`	`func testResultTupleTransparentEnum() throws {`
`180`	`164`	`XCTContext.runActivity(named: "Should return a tuple type") {`
`@@ -188,7 +172,7 @@ class ResultTests: XCTestCase {`
`188`	`172`	`XCTFail()`
`189`	`173`	`}`
`190`	`174`	`}`
`191`		`-`
	`175`	`+`
`192`	`176`	`XCTContext.runActivity(named: "Should throw an error") {`
`193`	`177`	`_ in`
`194`	`178`	`do {`
`@@ -265,7 +249,7 @@ class ResultTests: XCTestCase {`
`265`	`249`	`XCTAssertEqual(UInt32(i), value.val())`
`266`	`250`	`}`
`267`	`251`	`}`
`268`		`-`
	`252`	`+`
`269`	`253`	`/// Verify that we can use throwing initializers defined on the Rust side.`
`270`	`254`	`func testThrowingInitializers() throws {`
`271`	`255`	`XCTContext.runActivity(named: "Should fail") {`
Original file line number	Diff line number	Diff line change
`@@ -47,9 +47,6 @@ extension RustStringRef {`
`47`	`47`	`__swift_bridge__$RustString$trim(ptr)`
`48`	`48`	`}`
`49`	`49`	`}`
`50`		`-/// exercised in SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/ResultTests.swift:`
`51`		-/// - see `func testSwiftCallRustReturnsResultString`
`52`		`-extension RustStringRef: Error {}`
`53`	`50`	`extension RustString: Vectorizable {`
`54`	`51`	`public static func vecOfSelfNew() -> UnsafeMutableRawPointer {`
`55`	`52`	`__swift_bridge__$Vec_RustString$new()`
`@@ -97,4 +94,4 @@ extension RustString: Vectorizable {`
`97`	`94`	`public static func vecOfSelfLen(vecPtr: UnsafeMutableRawPointer) -> UInt {`
`98`	`95`	`__swift_bridge__$Vec_RustString$len(vecPtr)`
`99`	`96`	`}`
`100`		`-}`
	`97`	`+}`