derive(ArrowField) breaks in macros

[douglas-raillard-arm]

I'm trying to either:

• apply #[derive(ArrowField)] to a struct defined in a macro_rules
• apply my macro_rules on a struct using #[derive(ArrowField)]

The struct def is parsed using this little book of rust macros:
https://veykril.github.io/tlborm/decl-macros/building-blocks/parsing.html#struct

use arrow2_convert::ArrowField;

macro_rules! mymacro {
    (
        $( #[$meta:meta] )*
        //  ^~~~attributes~~~~^
            $vis:vis struct $name:ident {
                $(
                    $( #[$field_meta:meta] )*
                    //          ^~~~field attributes~~~!^
                        $field_vis:vis $field_name:ident : $field_ty:ty
                    //          ^~~~~~~~~~~~~~~~~a single field~~~~~~~~~~~~~~~^
                ),*
                    $(,)? }
    ) => {
        $( #[$meta] )*
            $vis struct $name {
                $(
                    $( #[$field_meta] )*
                        $field_vis $field_name : $field_ty
                ),*
            }
    }
}

mymacro! {
    #[derive(ArrowField)]
    struct Foo2 {
        myfield: u8,
    }
}

Sadly this fails with:

error: proc-macro derive panicked
  --> src/main.rs:97:14
   |
97 |     #[derive(ArrowField)]
   |              ^^^^^^^^^^
   |
   = help: message: Only types are supported atm

error: could not compile `dataframe` due to previous error

The only macro that seemed to work is this one:

macro_rules! mymacro2 {
    ($($tts:tt)*) => { $($tts)* }
}

Other derive macros such as JsonSchema don't seem to have this issue:
https://docs.rs/schemars/latest/schemars/

EDIT: This also fails, but differently:

mymacro! {
    struct Foo2 {
        myfield: u8,
    }
}

#[derive(ArrowField)]
struct Foo3(Foo2);

fails with:

error: proc-macro derive panicked
   --> src/main.rs:114:10
    |
114 | #[derive(ArrowField)]
    |          ^^^^^^^^^^
    |
    = help: message: called `Option::unwrap()` on a `None` value

[douglas-raillard-arm]

From a cursory look at the code, the problems seems to come from there:

arrow2-convert/arrow2_convert_derive/src/derive_struct.rs

Line 45 in 6c37e29

let field_types: Vec<&syn::TypePath> = fields

   let field_types: Vec<&syn::TypePath> = fields
        .iter()
        .map(|field| match &field.field_type {
            syn::Type::Path(path) => path,
            _ => panic!("Only types are supported atm"),
        })
        .collect::<Vec<&syn::TypePath>>();

I've never written any derive macro but it seems from e.g. that SO answer that the way to check if the field as a name is using checking its variant is syn::Fields::Named instead of checking field.field_type to be syn::Type::Path.

https://stackoverflow.com/questions/62837767/rust-how-to-use-derive-macro-to-parse-the-meta-information-of-a-struct:

 let fields = if let syn::Data::Struct(syn::DataStruct {
        fields: syn::Fields::Named(ref fields),
        ..
    }) = ast.data
   
    ...

for field in fields.named.iter() {
    let field_name: &syn::Ident = field.ident.as_ref().unwrap();
    let name: String = field_name.to_string();
}

I'm not sure if it solves the macro issue though

[douglas-raillard-arm]

If anyone hits the same issue, I worked around it using this crate:
https://docs.rs/macro_rules_attribute/latest/macro_rules_attribute/

so instead of that:

mymacro! {
    #[derive(ArrowFied)]
    struct Foo {...}
}

I used that:

#[derive(ArrowFied)]
#[apply(mymacro)]
struct Foo {...}

[ncpenke]

Thanks for filing this @douglas-raillard-arm. I'm glad you found the work around - nice pointer to the macro_rules_attribute crate. I'll take a closer look at the issue you originally encountered when I get a chance, and respond here based on the resolution.