moxy-derive 0.0.4

derive macros for moxy crate
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use proc_macro2::TokenStream;
use quote::quote;

use crate::{Render, core::Field, params};

use super::syntax::ForwardSyntax;

#[derive(Clone, Default)]
pub struct StructSyntax;

impl Render for StructSyntax {
    type Args = params::StructParams;

    fn render(&self, args: Self::Args) -> syn::Result<TokenStream> {
        let ident = &args.input.ident;
        let (impl_generics, type_generics, where_generics) = args.input.generics.split_for_impl();
        let fields: Vec<_> = args
            .data
            .fields
            .iter()
            .enumerate()
            .map(|(i, field)| Field::parse(i, field))
            .collect::<syn::Result<Vec<_>>>()?;

        let mut methods = Vec::new();

        for field in &fields {
            let fwd = ForwardSyntax::parse(field.attrs())?;

            if fwd.sigs.is_empty() {
                continue;
            }

            let field_name = field.name();

            for s in &fwd.sigs {
                let method_name = &s.ident;
                let output = &s.output;
                let inputs = &s.inputs;
                let arg_names: Vec<_> = s
                    .inputs
                    .iter()
                    .filter_map(|arg| match arg {
                        syn::FnArg::Typed(pat) => Some(&*pat.pat),
                        _ => None,
                    })
                    .collect();

                methods.push(quote! {
                    pub fn #method_name(#inputs) #output {
                        self.#field_name.#method_name(#(#arg_names),*)
                    }
                });
            }
        }

        Ok(quote! {
            impl #impl_generics #ident #type_generics #where_generics {
                #(#methods)*
            }
        })
    }
}