Fix dead_code warning when returning Result with bridged type in error case

As of Rust 1.79.0, dead code warnings are emitted from enums where the
compiler cannot infer that the contents are used. Since presumably the
interior of the error _will_ by used by Swift, the enum can be annotated
to allow the code to be generated without warnings.

Author: sax

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

@@ -378,7 +378,9 @@ impl BuiltInResult {
         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,16 @@ mod extern_rust_fn_return_result_opaque_rust_type_and_transparent_enum_type {
         }
     }
 
+    // In Rust 1.79.0 dead_code warnings in code generated by procedural macros began to be surfaced to
+    // callers of the macros. While the wrapped data in results returned to Swift will presumably be read,
+    // rustc does not see its usage and issues a warning.
     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 +489,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 +566,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 +639,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,
 }