kson-effect-param-macro 0.1.0

Macros for the kson 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
64
65
66
67
68
69
70
71

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Data, DeriveInput};

#[proc_macro_derive(Effect)]
pub fn derive_effect_param(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    match &input.data {
        Data::Enum(e) => {
            let mut match_arms = vec![];
            for variant in &e.variants {
                let new_struct_expr = match &variant.fields {
                    syn::Fields::Named(_) => todo!(),
                    syn::Fields::Unnamed(_) => {
                        let input = &input.ident;
                        let variant = &variant.ident;
                        quote!(#input::#variant(Effect::derive(&a,key,param)))
                    }
                    syn::Fields::Unit => panic!("Enum unit variants are not supported"),
                };
                let input = &input.ident;
                let variant = &variant.ident;
                match_arms.push(quote!(#input::#variant(a) => #new_struct_expr,));
            }

            match_arms.push(quote!(_ => panic!("Tried to derive from a different type"),));
            let input = &input.ident;
            proc_macro::TokenStream::from(quote!(
                impl Effect for #input {
                fn derive(&self, key: &str, param: &str) -> Self {
                    match self { #(#match_arms)* }
                }
                fn param_list() -> &'static [&'static str] {
                    &[]
                }
                }
            ))
        }
        Data::Struct(s) => {
            //self << other
            let mut match_arms = vec![];
            let mut fields = vec![];

            for f in &s.fields {
                if let Some(ident) = &f.ident {
                    fields.push(quote!(stringify!(#ident)));
                    match_arms.push(quote!(stringify!(#ident) => Self {
                        #ident: param.parse().unwrap_or_default(),
                        ..self.clone()
                    },))
                }
            }

            match_arms.push(quote!(_ => self.clone()));

            let input = &input.ident;
            proc_macro::TokenStream::from(quote!(
            impl Effect for #input {
                fn derive(&self, key: &str, param: &str) -> Self {
                    match key {#(#match_arms)*}
                }

                fn param_list() -> &'static [&'static str]  {
                    &[#(#fields),*]
                }
            }))
        }
        Data::Union(_) => panic!("Unions are not supported"),
    }
}