Fix to make incorrect return type into error (#169)

MikuroXina · web-flow · commit e7aef343da03 · 2023-02-15T11:15:58.000-05:00
This commit introduces a compile time error for incorrect return types.

For example, the following will now fail to compile:

```rust
#[swift_bridge::bridge]
mod ffi {
    extern "Rust" {
        fn get_reference() -&gt; SomeType;
    }
}

fn get_reference() -&gt; &amp;'static SomeType {
    &amp;SomeType
}
```

Before this commit the above example would compile and calling `get_reference` would cause undefined behavior.
diff --git a/crates/swift-bridge-ir/src/bridged_type/bridged_opaque_type.rs b/crates/swift-bridge-ir/src/bridged_type/bridged_opaque_type.rs
@@ -211,7 +211,10 @@ impl BridgeableType for OpaqueForeignType {
                     .generics
                     .angle_bracketed_concrete_generics_tokens(types);
                 quote! {
-                    Box::into_raw(Box::new(#expression)) as *mut super::#ty_name #generics
+                    Box::into_raw(Box::new({
+                        let val: super::#ty_name #generics = #expression;
+                        val
+                    })) as *mut super::#ty_name #generics
                 }
             }
         } else {
diff --git a/crates/swift-bridge-ir/src/codegen/codegen_tests/async_function_codegen_tests.rs b/crates/swift-bridge-ir/src/codegen/codegen_tests/async_function_codegen_tests.rs
@@ -564,13 +564,19 @@ mod extern_rust_async_function_returns_result_opaque {
                     Ok(ok) => {
                         swift_bridge::result::ResultPtrAndPtr {
                             is_ok: true,
-                            ok_or_err: Box::into_raw(Box::new(ok)) as *mut super::OkType as *mut std::ffi::c_void
+                            ok_or_err: Box::into_raw(Box::new({
+                                let val: super::OkType = ok;
+                                val
+                            })) as *mut super::OkType as *mut std::ffi::c_void
                         }
                     }
                     Err(err) => {
                         swift_bridge::result::ResultPtrAndPtr {
                             is_ok: false,
-                            ok_or_err: Box::into_raw(Box::new(err)) as *mut super::ErrorType as *mut std::ffi::c_void
+                            ok_or_err: Box::into_raw(Box::new({
+                                let val: super::ErrorType = err;
+                                val
+                            })) as *mut super::ErrorType as *mut std::ffi::c_void
                         }
                     }
                 };
diff --git a/crates/swift-bridge-ir/src/codegen/codegen_tests/boxed_fnonce_codegen_tests.rs b/crates/swift-bridge-ir/src/codegen/codegen_tests/boxed_fnonce_codegen_tests.rs
@@ -411,7 +411,10 @@ mod test_swift_takes_callback_return_opaque_rust_type {
             quote! {
                 #[export_name = "__swift_bridge__$some_function$param0"]
                 pub extern "C" fn some_function_param0(some_function_callback: *mut Box<dyn FnOnce() -> super::ARustType>) -> *mut super::ARustType {
-                    Box::into_raw(Box::new(unsafe { Box::from_raw(some_function_callback)() })) as *mut super::ARustType
+                    Box::into_raw(Box::new({
+                        let val: super::ARustType = unsafe { Box::from_raw(some_function_callback)() };
+                        val
+                    })) as *mut super::ARustType
                 }
 
                 #[export_name = "__swift_bridge__$some_function$_free$param0"]
diff --git a/crates/swift-bridge-ir/src/codegen/codegen_tests/extern_rust_function_opaque_rust_type_return_codegen_tests.rs b/crates/swift-bridge-ir/src/codegen/codegen_tests/extern_rust_function_opaque_rust_type_return_codegen_tests.rs
@@ -23,7 +23,10 @@ mod test_extern_rust_function_owned_opaque_rust_type_return {
         ExpectedRustTokens::Contains(quote! {
             #[export_name = "__swift_bridge__$some_function"]
             pub extern "C" fn __swift_bridge__some_function () -> *mut super::SomeType {
-                Box::into_raw(Box::new(super::some_function())) as *mut super::SomeType
+                Box::into_raw(Box::new({
+                    let val: super::SomeType = super::some_function();
+                    val
+                })) as *mut super::SomeType
             }
         })
     }
diff --git a/crates/swift-bridge-ir/src/codegen/codegen_tests/generic_opaque_rust_type_codegen_tests.rs b/crates/swift-bridge-ir/src/codegen/codegen_tests/generic_opaque_rust_type_codegen_tests.rs
@@ -218,7 +218,10 @@ mod generic_opaque_rust_type_return {
         ExpectedRustTokens::Contains(quote! {
             #[export_name = "__swift_bridge__$some_function"]
             pub extern "C" fn __swift_bridge__some_function () -> *mut super::SomeType<u32> {
-                 Box::into_raw(Box::new(super::some_function())) as *mut super::SomeType<u32>
+                Box::into_raw(Box::new({
+                    let val: super::SomeType<u32> = super::some_function();
+                    val
+                })) as *mut super::SomeType<u32>
             }
         })
     }
diff --git a/crates/swift-bridge-ir/src/codegen/codegen_tests/opaque_rust_type_codegen_tests.rs b/crates/swift-bridge-ir/src/codegen/codegen_tests/opaque_rust_type_codegen_tests.rs
@@ -126,7 +126,7 @@ extension HashableTypeRef: Hashable{
     fn expected_c_header() -> ExpectedCHeader {
         ExpectedCHeader::ContainsManyAfterTrim(vec![
             r#"
-uint64_t __swift_bridge__$HashableType$_hash(void* self);  
+uint64_t __swift_bridge__$HashableType$_hash(void* self);
     "#,
             r#"
 "#,
@@ -416,7 +416,10 @@ mod extern_swift_freestanding_fn_with_owned_opaque_rust_type_arg {
     fn expected_rust_tokens() -> ExpectedRustTokens {
         ExpectedRustTokens::Contains(quote! {
             pub fn some_function (arg: super::MyType) {
-                unsafe { __swift_bridge__some_function( Box::into_raw(Box::new(arg)) as *mut super::MyType ) }
+                unsafe { __swift_bridge__some_function( Box::into_raw(Box::new({
+                    let val: super::MyType = arg;
+                    val
+                })) as *mut super::MyType ) }
             }
 
             extern "C" {
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
@@ -151,13 +151,19 @@ mod extern_rust_fn_return_result_opaque_rust {
                     Ok(ok) => {
                         swift_bridge::result::ResultPtrAndPtr {
                             is_ok: true,
-                            ok_or_err: Box::into_raw(Box::new(ok)) as *mut super::SomeType as *mut std::ffi::c_void
+                            ok_or_err: Box::into_raw(Box::new({
+                                let val: super::SomeType = ok;
+                                val
+                            })) as *mut super::SomeType as *mut std::ffi::c_void
                         }
                     }
                     Err(err) => {
                         swift_bridge::result::ResultPtrAndPtr {
                             is_ok: false,
-                            ok_or_err: Box::into_raw(Box::new(err)) as *mut super::SomeType as *mut std::ffi::c_void
+                            ok_or_err: Box::into_raw(Box::new({
+                                let val: super::SomeType = err;
+                                val
+                            })) as *mut super::SomeType as *mut std::ffi::c_void
                         }
                     }
                 }
diff --git a/crates/swift-bridge-ir/src/codegen/generate_rust_tokens.rs b/crates/swift-bridge-ir/src/codegen/generate_rust_tokens.rs
@@ -507,7 +507,10 @@ mod tests {
         let expected_func = quote! {
             #[export_name = "__swift_bridge__$some_function"]
             pub extern "C" fn __swift_bridge__some_function () -> *mut super::Foo {
-                Box::into_raw(Box::new(super::another_function())) as *mut super::Foo
+                Box::into_raw(Box::new({
+                    let val: super::Foo = super::another_function();
+                    val
+                })) as *mut super::Foo
             }
         };
 
@@ -531,7 +534,10 @@ mod tests {
         let expected_func = quote! {
             #[export_name = "__swift_bridge__$some_function"]
             pub extern "C" fn __swift_bridge__some_function () -> *mut super::Foo {
-                Box::into_raw(Box::new(super::some_function().into())) as *mut super::Foo
+                Box::into_raw(Box::new({
+                    let val: super::Foo = super::some_function().into();
+                    val
+                })) as *mut super::Foo
             }
         };
 
@@ -630,7 +636,10 @@ mod tests {
         let expected = quote! {
             #[export_name = "__swift_bridge__$SomeType$new"]
             pub extern "C" fn __swift_bridge__SomeType_new () -> *mut super::SomeType {
-                Box::into_raw(Box::new(super::SomeType::new())) as *mut super::SomeType
+                Box::into_raw(Box::new({
+                    let val: super::SomeType = super::SomeType::new();
+                    val
+                })) as *mut super::SomeType
             }
         };
 
diff --git a/crates/swift-bridge-macro/tests/ui/incorrect-return-type.rs b/crates/swift-bridge-macro/tests/ui/incorrect-return-type.rs
@@ -0,0 +1,26 @@
+//! # To Run
+//! cargo test -p swift-bridge-macro -- ui trybuild=incorrect-return-type.rs
+
+pub struct SomeType;
+
+#[swift_bridge::bridge]
+mod ffi {
+    extern "Rust" {
+        type SomeType;
+
+        #[swift_bridge(rust_name = "some_function")]
+        fn fn1() -> SomeType;
+        #[swift_bridge(rust_name = "another_function")]
+        fn fn2() -> SomeType;
+    }
+}
+
+fn some_function() -> &'static SomeType {
+    &SomeType
+}
+
+fn another_function() -> Option<SomeType> {
+    None
+}
+
+fn main() {}
diff --git a/crates/swift-bridge-macro/tests/ui/incorrect-return-type.stderr b/crates/swift-bridge-macro/tests/ui/incorrect-return-type.stderr
@@ -0,0 +1,23 @@
+error[E0308]: mismatched types
+ --> tests/ui/incorrect-return-type.rs:6:1
+  |
+6 | #[swift_bridge::bridge]
+  | ^^^^^^^^^^^^^^^^^^^^^^^
+  | |
+  | expected struct `SomeType`, found `&SomeType`
+  | expected due to this
+  |
+  = note: this error originates in the attribute macro `swift_bridge::bridge` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0308]: mismatched types
+ --> tests/ui/incorrect-return-type.rs:6:1
+  |
+6 | #[swift_bridge::bridge]
+  | ^^^^^^^^^^^^^^^^^^^^^^^
+  | |
+  | expected struct `SomeType`, found enum `Option`
+  | expected due to this
+  |
+  = note: expected struct `SomeType`
+               found enum `Option<SomeType>`
+  = note: this error originates in the attribute macro `swift_bridge::bridge` (in Nightly builds, run with -Z macro-backtrace for more info)

Original file line number	Diff line number	Diff line change
`@@ -211,7 +211,10 @@ impl BridgeableType for OpaqueForeignType {`
`211`	`211`	`.generics`
`212`	`212`	`.angle_bracketed_concrete_generics_tokens(types);`
`213`	`213`	`quote! {`
`214`		`- Box::into_raw(Box::new(#expression)) as *mut super::#ty_name #generics`
	`214`	`+ Box::into_raw(Box::new({`
	`215`	`+ let val: super::#ty_name #generics = #expression;`
	`216`	`+ val`
	`217`	`+ })) as *mut super::#ty_name #generics`
`215`	`218`	`}`
`216`	`219`	`}`
`217`	`220`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -564,13 +564,19 @@ mod extern_rust_async_function_returns_result_opaque {`
`564`	`564`	`Ok(ok) => {`
`565`	`565`	`swift_bridge::result::ResultPtrAndPtr {`
`566`	`566`	`is_ok: true,`
`567`		`- ok_or_err: Box::into_raw(Box::new(ok)) as mut super::OkType as mut std::ffi::c_void`
	`567`	`+ ok_or_err: Box::into_raw(Box::new({`
	`568`	`+ let val: super::OkType = ok;`
	`569`	`+ val`
	`570`	`+ })) as mut super::OkType as mut std::ffi::c_void`
`568`	`571`	`}`
`569`	`572`	`}`
`570`	`573`	`Err(err) => {`
`571`	`574`	`swift_bridge::result::ResultPtrAndPtr {`
`572`	`575`	`is_ok: false,`
`573`		`- ok_or_err: Box::into_raw(Box::new(err)) as mut super::ErrorType as mut std::ffi::c_void`
	`576`	`+ ok_or_err: Box::into_raw(Box::new({`
	`577`	`+ let val: super::ErrorType = err;`
	`578`	`+ val`
	`579`	`+ })) as mut super::ErrorType as mut std::ffi::c_void`
`574`	`580`	`}`
`575`	`581`	`}`
`576`	`582`	`};`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,10 @@ mod test_extern_rust_function_owned_opaque_rust_type_return {`
`23`	`23`	`ExpectedRustTokens::Contains(quote! {`
`24`	`24`	`#[export_name = "__swift_bridge__$some_function"]`
`25`	`25`	`pub extern "C" fn __swift_bridge__some_function () -> *mut super::SomeType {`
`26`		`- Box::into_raw(Box::new(super::some_function())) as *mut super::SomeType`
	`26`	`+ Box::into_raw(Box::new({`
	`27`	`+ let val: super::SomeType = super::some_function();`
	`28`	`+ val`
	`29`	`+ })) as *mut super::SomeType`
`27`	`30`	`}`
`28`	`31`	`})`
`29`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -218,7 +218,10 @@ mod generic_opaque_rust_type_return {`
`218`	`218`	`ExpectedRustTokens::Contains(quote! {`
`219`	`219`	`#[export_name = "__swift_bridge__$some_function"]`
`220`	`220`	`pub extern "C" fn __swift_bridge__some_function () -> *mut super::SomeType<u32> {`
`221`		`- Box::into_raw(Box::new(super::some_function())) as *mut super::SomeType<u32>`
	`221`	`+ Box::into_raw(Box::new({`
	`222`	`+ let val: super::SomeType<u32> = super::some_function();`
	`223`	`+ val`
	`224`	`+ })) as *mut super::SomeType<u32>`
`222`	`225`	`}`
`223`	`226`	`})`
`224`	`227`	`}`
Original file line number	Diff line number	Diff line change
`@@ -151,13 +151,19 @@ mod extern_rust_fn_return_result_opaque_rust {`
`151`	`151`	`Ok(ok) => {`
`152`	`152`	`swift_bridge::result::ResultPtrAndPtr {`
`153`	`153`	`is_ok: true,`
`154`		`- ok_or_err: Box::into_raw(Box::new(ok)) as mut super::SomeType as mut std::ffi::c_void`
	`154`	`+ ok_or_err: Box::into_raw(Box::new({`
	`155`	`+ let val: super::SomeType = ok;`
	`156`	`+ val`
	`157`	`+ })) as mut super::SomeType as mut std::ffi::c_void`
`155`	`158`	`}`
`156`	`159`	`}`
`157`	`160`	`Err(err) => {`
`158`	`161`	`swift_bridge::result::ResultPtrAndPtr {`
`159`	`162`	`is_ok: false,`
`160`		`- ok_or_err: Box::into_raw(Box::new(err)) as mut super::SomeType as mut std::ffi::c_void`
	`163`	`+ ok_or_err: Box::into_raw(Box::new({`
	`164`	`+ let val: super::SomeType = err;`
	`165`	`+ val`
	`166`	`+ })) as mut super::SomeType as mut std::ffi::c_void`
`161`	`167`	`}`
`162`	`168`	`}`
`163`	`169`	`}`