Implement Error for RustStringRef

[jnbooth]

With the latest versions of Swift, using Result<_, String> causes two errors:

• 'RustString' is not convertible to 'any Error'
• Thrown expression type 'RustString' does not conform to 'Error

The solution to both errors is for RustStringRef to declare conformance to the Error protocol.

See: Swift Documentation - Error

[chinedufn]

Thanks for making this contribution.

One question about why you introduced the LocalizedError implementation.

[chinedufn]

Just needs an integration test.

Potential approach

Bridge a function that returns -> Result<(), String>. Somewhere in here

swift-bridge/crates/swift-integration-tests/src/result.rs

Lines 3 to 81 in de05902

	#[swift_bridge::bridge]
	mod ffi {
	struct UnitStruct;
	extern "Rust" {
	fn rust_func_reflect_result_opaque_rust(
	arg: Result<ResultTestOpaqueRustType, ResultTestOpaqueRustType>,
	) -> Result<ResultTestOpaqueRustType, ResultTestOpaqueRustType>;
	fn rust_func_takes_result_string(arg: Result<String, String>);
	fn rust_func_takes_result_opaque_swift(
	arg: Result<ResultTestOpaqueSwiftType, ResultTestOpaqueSwiftType>,
	);
	fn rust_func_return_result_null_opaque_rust(
	succeed: bool,
	) -> Result<(), ResultTestOpaqueRustType>;
	fn rust_func_return_result_unit_struct_opaque_rust(
	succeed: bool,
	) -> Result<UnitStruct, ResultTestOpaqueRustType>;
	}
	extern "Rust" {
	type ResultTestOpaqueRustType;
	#[swift_bridge(init)]
	fn new(val: u32) -> ResultTestOpaqueRustType;
	fn val(&self) -> u32;
	}
	extern "Swift" {
	type ResultTestOpaqueSwiftType;
	fn val(&self) -> u32;
	}
	enum ResultTransparentEnum {
	NamedField { data: i32 },
	UnnamedFields(u8, String),
	NoFields,
	}
	extern "Rust" {
	fn rust_func_return_result_opaque_rust_transparent_enum(
	succeed: bool,
	) -> Result<ResultTestOpaqueRustType, ResultTransparentEnum>;
	fn rust_func_return_result_transparent_enum_opaque_rust(
	succeed: bool,
	) -> Result<ResultTransparentEnum, ResultTestOpaqueRustType>;
	}
	extern "Rust" {
	fn rust_func_return_result_unit_type_enum_opaque_rust(
	succeed: bool,
	) -> Result<(), ResultTransparentEnum>;
	}
	enum SameEnum {
	Variant1,
	Variant2,
	}
	extern "Rust" {
	fn same_custom_result_returned_twice_first() -> Result<SameEnum, SameEnum>;
	fn same_custom_result_returned_twice_second() -> Result<SameEnum, SameEnum>;
	}
	extern "Rust" {
	fn rust_func_return_result_of_vec_u32() -> Result<Vec<u32>, ResultTestOpaqueRustType>;
	fn rust_func_return_result_of_vec_opaque(
	) -> Result<Vec<ResultTestOpaqueRustType>, ResultTestOpaqueRustType>;
	}
	extern "Rust" {
	fn rust_func_return_result_tuple_transparent_enum(
	succeed: bool,
	) -> Result<(i32, ResultTestOpaqueRustType, String), ResultTransparentEnum>;
	}
	}

Then add a test case that calls that function somewhere inside here

swift-bridge/SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/ResultTests.swift

Line 10 in de05902

class ResultTests: XCTestCase {

On the test case document that (I'm paraphrasing) around the time of Swift x.y returning -> Result<(), String> started giving errors like Thrown expression type 'RustString' does not conform to 'Error'. And that we solved that by implementing Swift's Error protocol for RustStringRef. And that the test is confirming that the Error protocol is indeed implemented.

Then confirm that if you comment out the extension RustStringRef: Error {} line then tests fail.