Allow unused returning transparent structs or enums in Results

Author: sax

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

@@ -375,10 +375,14 @@ impl BuiltInResult {
             .err_ty
             .to_ffi_compatible_rust_type(swift_bridge_path, types);
         let mut custom_rust_ffi_types = vec![];
+        // TODO: remove allowances when rustc no longer issues dead code warnings for `#[repr(C)]`
+        //  structs or enums: https://github.com/rust-lang/rust/issues/126706
         custom_rust_ffi_types.push(quote! {
             #[repr(C)]
             pub enum #ty {
+                #[allow(unused)]
                 Ok #ok,
+                #[allow(unused)]
                 Err(#err),
             }
         });

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

@@ -407,11 +407,15 @@ mod extern_rust_fn_return_result_opaque_rust_type_and_transparent_enum_type {
         }
     }
 
+    // In Rust 1.79.0 dead_code warnings are issued for wrapped data in enums in spite of the enum
+    // having `#[repr(C)]`.
     fn expected_rust_tokens() -> ExpectedRustTokens {
         ExpectedRustTokens::Contains(quote! {
             #[repr(C)]
             pub enum ResultSomeOkTypeAndSomeErrEnum{
+                #[allow(unused)]
                 Ok(*mut super::SomeOkType),
+                #[allow(unused)]
                 Err(__swift_bridge__SomeErrEnum),
             }
 
@@ -484,11 +488,14 @@ mod extern_rust_fn_return_result_transparent_enum_type_and_opaque_rust_type {
         }
     }
 
+    // Allows unused to avoid dead_code warnings in Rust 1.79.0 or later.
     fn expected_rust_tokens() -> ExpectedRustTokens {
         ExpectedRustTokens::Contains(quote! {
             #[repr(C)]
             pub enum ResultSomeOkEnumAndSomeErrType{
+                #[allow(unused)]
                 Ok(__swift_bridge__SomeOkEnum),
+                #[allow(unused)]
                 Err(*mut super::SomeErrType),
             }
 
@@ -558,11 +565,14 @@ mod extern_rust_fn_return_result_unit_type_and_transparent_enum_type {
         }
     }
 
+    // Allows unused to avoid dead_code warnings in Rust 1.79.0 or later.
     fn expected_rust_tokens() -> ExpectedRustTokens {
         ExpectedRustTokens::Contains(quote! {
             #[repr(C)]
             pub enum ResultVoidAndSomeErrEnum{
+                #[allow(unused)]
                 Ok,
+                #[allow(unused)]
                 Err(__swift_bridge__SomeErrEnum),
             }
 
@@ -628,12 +638,15 @@ mod extern_rust_fn_return_result_tuple_type_and_transparent_enum_type {
         }
     }
 
+    // Allows unused to avoid dead_code warnings in Rust 1.79.0 or later.
     fn expected_rust_tokens() -> ExpectedRustTokens {
         ExpectedRustTokens::ContainsMany(vec![
             quote! {
                 #[repr(C)]
                 pub enum ResultTupleI32U32AndSomeErrEnum{
+                    #[allow(unused)]
                     Ok(__swift_bridge__tuple_I32U32),
+                    #[allow(unused)]
                     Err(__swift_bridge__SomeErrEnum),
                 }
             },

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

@@ -1,8 +1,4 @@
 //! See also: crates/swift-bridge-ir/src/codegen/codegen_tests/result_codegen_tests.rs
-// This is a temporary workaround until https://github.com/chinedufn/swift-bridge/issues/270
-// is closed. When tests are compiled they have `-D warnings` (deny warnings) enabled, so
-// tests won't even compile unless this warning is ignored.
-#![allow(dead_code)]
 
 #[swift_bridge::bridge]
 mod ffi {
@@ -41,6 +37,15 @@ mod ffi {
         fn val(&self) -> u32;
     }
 
+    #[swift_bridge(swift_repr = "struct")]
+    struct ResultTestTransparentStruct(pub String);
+
+    extern "Rust" {
+        fn rust_func_returns_result_null_transparent_struct(
+            succeed: bool,
+        ) -> Result<(), ResultTestTransparentStruct>;
+    }
+
     enum ResultTransparentEnum {
         NamedField { data: i32 },
         UnnamedFields(u8, String),
@@ -141,6 +146,30 @@ fn rust_func_return_result_unit_struct_opaque_rust(
     }
 }
 
+fn rust_func_returns_result_null_transparent_struct(
+    succeed: bool,
+) -> Result<(), ffi::ResultTestTransparentStruct> {
+    if succeed {
+        Ok(())
+    } else {
+        Err(ffi::ResultTestTransparentStruct("failed".to_string()))
+    }
+}
+
+impl std::error::Error for ffi::ResultTestTransparentStruct {}
+
+impl std::fmt::Debug for ffi::ResultTestTransparentStruct {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+impl std::fmt::Display for ffi::ResultTestTransparentStruct {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 pub struct ResultTestOpaqueRustType {
     val: u32,
 }