Adding derive() macro support to SharedStructs (#198)

This commit adds support for `#[derive(Copy, Clone)]` to `SharedStruct`s.

## Example

```rust
#[swift_bridge::bridge]
mod ffi {
    #[swift_bridge(swift_repr = "struct")]
    #[derive(Copy, Clone)]
    struct Foo {
        field: u8,
    }
}
```

Author: rkreutz

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

@@ -19,6 +19,13 @@ pub(crate) struct SharedStruct {
     pub fields: StructFields,
     pub swift_name: Option<LitStr>,
     pub already_declared: bool,
+    pub derives: StructDerives,
+}
+
+#[derive(Clone)]
+pub(crate) struct StructDerives {
+    pub copy: bool,
+    pub clone: bool,
 }
 
 impl SharedStruct {

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

@@ -32,6 +32,7 @@ mod argument_label_codegen_tests;
 mod async_function_codegen_tests;
 mod boxed_fnonce_codegen_tests;
 mod conditional_compilation_codegen_tests;
+mod derive_struct_attribute_codegen_tests;
 mod extern_rust_function_opaque_rust_type_argument_codegen_tests;
 mod extern_rust_function_opaque_rust_type_return_codegen_tests;
 mod extern_rust_method_swift_class_placement_codegen_tests;

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

@@ -0,0 +1,95 @@
+use super::{CodegenTest, ExpectedCHeader, ExpectedRustTokens, ExpectedSwiftCode};
+use proc_macro2::TokenStream;
+use quote::quote;
+
+/// Verify that we can derive the `Copy` trait on a transparent struct.
+mod derive_copy_struct {
+    use super::*;
+
+    fn bridge_module_tokens() -> TokenStream {
+        quote! {
+            #[swift_bridge::bridge]
+            mod ffi {
+                #[swift_bridge(swift_repr = "struct")]
+                #[derive(Copy)]
+                struct SomeStruct {
+                    field: u8,
+                }
+            }
+        }
+    }
+
+    fn expected_rust_tokens() -> ExpectedRustTokens {
+        ExpectedRustTokens::ContainsMany(vec![quote! {
+            #[derive(Copy)]
+            pub struct SomeStruct {
+                pub field: u8
+            }
+        }])
+    }
+
+    fn expected_swift_code() -> ExpectedSwiftCode {
+        ExpectedSwiftCode::SkipTest
+    }
+
+    fn expected_c_header() -> ExpectedCHeader {
+        ExpectedCHeader::SkipTest
+    }
+
+    #[test]
+    fn generates_struct() {
+        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();
+    }
+}
+
+/// Verify that we can derive the `Clone` trait on a transparent struct.
+mod derive_clone_struct {
+    use super::*;
+
+    fn bridge_module_tokens() -> TokenStream {
+        quote! {
+            #[swift_bridge::bridge]
+            mod ffi {
+                #[swift_bridge(swift_repr = "struct")]
+                #[derive(Clone)]
+                struct SomeStruct {
+                    field: u8,
+                }
+            }
+        }
+    }
+
+    fn expected_rust_tokens() -> ExpectedRustTokens {
+        ExpectedRustTokens::ContainsMany(vec![quote! {
+            #[derive(Clone)]
+            pub struct SomeStruct {
+                pub field: u8
+            }
+        }])
+    }
+
+    fn expected_swift_code() -> ExpectedSwiftCode {
+        ExpectedSwiftCode::SkipTest
+    }
+
+    fn expected_c_header() -> ExpectedCHeader {
+        ExpectedCHeader::SkipTest
+    }
+
+    #[test]
+    fn generates_struct() {
+        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();
+    }
+}

crates/swift-bridge-ir/src/codegen/generate_rust_tokens/shared_struct.rs

@@ -90,7 +90,16 @@ impl SwiftBridgeModule {
             }
         };
 
+        let mut derives: Vec<TokenStream> = vec![];
+        if shared_struct.derives.copy {
+            derives.push(quote! {Copy});
+        }
+        if shared_struct.derives.clone {
+            derives.push(quote! {Clone});
+        }
+
         let definition = quote! {
+            #[derive(#(#derives),*)]
             pub struct #struct_name #struct_fields
 
             #struct_ffi_repr

crates/swift-bridge-ir/src/parse/parse_struct.rs

@@ -1,9 +1,12 @@
-use crate::bridged_type::{SharedStruct, StructFields, StructSwiftRepr};
+use crate::bridged_type::{
+    shared_struct::StructDerives, SharedStruct, StructFields, StructSwiftRepr,
+};
 use crate::errors::{ParseError, ParseErrors};
 use crate::parse::move_input_cursor_to_next_comma;
 use proc_macro2::Ident;
+use quote::ToTokens;
 use syn::parse::{Parse, ParseStream};
-use syn::{ItemStruct, LitStr, Token};
+use syn::{ItemStruct, LitStr, Meta, Token};
 
 pub(crate) struct SharedStructDeclarationParser<'a> {
     pub item_struct: ItemStruct,
@@ -27,6 +30,16 @@ struct StructAttribs {
     swift_repr: Option<(StructSwiftRepr, LitStr)>,
     swift_name: Option<LitStr>,
     already_declared: bool,
+    derives: StructDerives,
+}
+
+impl Default for StructDerives {
+    fn default() -> Self {
+        StructDerives {
+            copy: false,
+            clone: false,
+        }
+    }
 }
 
 struct ParsedAttribs(Vec<StructAttr>);
@@ -81,32 +94,52 @@ impl<'a> SharedStructDeclarationParser<'a> {
         let mut attribs = StructAttribs::default();
 
         for attr in item_struct.attrs {
-            let sections: ParsedAttribs = attr.parse_args()?;
-
-            for attr in sections.0 {
-                match attr {
-                    StructAttr::SwiftRepr((repr, lit_str)) => {
-                        attribs.swift_repr = Some((repr, lit_str));
-                    }
-                    StructAttr::SwiftName(name) => {
-                        attribs.swift_name = Some(name);
+            let attribute_name = attr.path.to_token_stream().to_string();
+
+            match attribute_name.as_str() {
+                "swift_bridge" => {
+                    let sections: ParsedAttribs = attr.parse_args()?;
+
+                    for attr in sections.0 {
+                        match attr {
+                            StructAttr::SwiftRepr((repr, lit_str)) => {
+                                attribs.swift_repr = Some((repr, lit_str));
+                            }
+                            StructAttr::SwiftName(name) => {
+                                attribs.swift_name = Some(name);
+                            }
+                            StructAttr::Error(err) => match err {
+                                StructAttrParseError::InvalidSwiftRepr(val) => {
+                                    self.errors.push(ParseError::StructInvalidSwiftRepr {
+                                        swift_repr_attr_value: val.clone(),
+                                    });
+                                    attribs.swift_repr = Some((StructSwiftRepr::Structure, val));
+                                }
+                                StructAttrParseError::UnrecognizedAttribute(attribute) => {
+                                    self.errors.push(ParseError::StructUnrecognizedAttribute {
+                                        attribute,
+                                    });
+                                }
+                            },
+                            StructAttr::AlreadyDeclared => {
+                                attribs.already_declared = true;
+                            }
+                        };
                     }
-                    StructAttr::Error(err) => match err {
-                        StructAttrParseError::InvalidSwiftRepr(val) => {
-                            self.errors.push(ParseError::StructInvalidSwiftRepr {
-                                swift_repr_attr_value: val.clone(),
-                            });
-                            attribs.swift_repr = Some((StructSwiftRepr::Structure, val));
-                        }
-                        StructAttrParseError::UnrecognizedAttribute(attribute) => {
-                            self.errors
-                                .push(ParseError::StructUnrecognizedAttribute { attribute });
+                }
+                "derive" => match attr.parse_meta()? {
+                    Meta::List(meta_list) => {
+                        for derive in meta_list.nested {
+                            match derive.to_token_stream().to_string().as_str() {
+                                "Copy" => attribs.derives.copy = true,
+                                "Clone" => attribs.derives.clone = true,
+                                _ => {}
+                            }
                         }
-                    },
-                    StructAttr::AlreadyDeclared => {
-                        attribs.already_declared = true;
                     }
-                };
+                    _ => todo!("Push parse error that derive attribute is in incorrect format"),
+                },
+                _ => todo!("Push unsupported attribute error."),
             }
         }
 
@@ -137,6 +170,7 @@ impl<'a> SharedStructDeclarationParser<'a> {
             fields: StructFields::from_syn_fields(item_struct.fields),
             swift_name: attribs.swift_name,
             already_declared: attribs.already_declared,
+            derives: attribs.derives,
         };
 
         Ok(shared_struct)
@@ -302,6 +336,33 @@ mod tests {
         assert_eq!(ty.swift_name.as_ref().unwrap().value(), "FfiFoo");
     }
 
+    /// Verify that we parse the derive(...)
+    #[test]
+    fn parse_derive_attribute() {
+        let tokens = quote! {
+            #[swift_bridge::bridge]
+            mod ffi {
+                #[derive(Copy, Clone)]
+                struct Foo;
+
+                #[derive(Clone)]
+                struct Bar;
+            }
+        };
+
+        let module = parse_ok(tokens);
+
+        let ty = module.types.types()[0].unwrap_shared_struct();
+
+        assert_eq!(ty.derives.copy, true);
+        assert_eq!(ty.derives.clone, true);
+
+        let ty2 = module.types.types()[1].unwrap_shared_struct();
+
+        assert_eq!(ty2.derives.copy, false);
+        assert_eq!(ty2.derives.clone, true);
+    }
+
     /// Verify that we properly parse multiple comma separated struct attributes.
     #[test]
     fn parses_multiple_struct_attributes() {
@@ -322,6 +383,29 @@ mod tests {
         assert_eq!(ty.swift_repr, StructSwiftRepr::Class);
     }
 
+    /// Verify that we properly parse multiple comma separated struct attributes and derive attributes.
+    #[test]
+    fn parses_multiple_struct_attributes_and_derive() {
+        let tokens = quote! {
+            #[swift_bridge::bridge]
+            mod ffi {
+                #[swift_bridge(swift_name = "FfiFoo", swift_repr = "class")]
+                #[derive(Copy, Clone)]
+                struct Foo {
+                    fied: u8
+                }
+            }
+        };
+
+        let module = parse_ok(tokens);
+
+        let ty = module.types.types()[0].unwrap_shared_struct();
+        assert_eq!(ty.swift_name.as_ref().unwrap().value(), "FfiFoo");
+        assert_eq!(ty.swift_repr, StructSwiftRepr::Class);
+        assert_eq!(ty.derives.copy, true);
+        assert_eq!(ty.derives.clone, true);
+    }
+
     /// Verify that we can parse an `already_defined = "struct"` attribute.
     #[test]
     fn parses_struct_already_declared_attribute() {

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

@@ -1,2 +1,3 @@
 mod already_declared;
+mod derive;
 mod swift_name;

crates/swift-integration-tests/src/struct_attributes/derive.rs

@@ -0,0 +1,28 @@
+#[swift_bridge::bridge]
+mod ffi {
+    #[swift_bridge(swift_repr = "struct")]
+    #[derive(Copy, Clone)]
+    struct StructDeriveCopy1;
+
+    #[swift_bridge(swift_repr = "struct")]
+    #[derive(Copy, Clone)]
+    struct StructDeriveCopy2 {
+        field: u8,
+    }
+
+    #[swift_bridge(swift_repr = "struct")]
+    #[derive(Clone)]
+    struct StructDeriveClone1;
+
+    #[swift_bridge(swift_repr = "struct")]
+    #[derive(Clone)]
+    struct StructDeriveClone2 {
+        field: u8,
+    }
+
+    #[swift_bridge(swift_repr = "struct")]
+    #[derive(Clone)]
+    struct StructDeriveClone3 {
+        field: String,
+    }
+}