bk2d-macro 0.3.0

Useful macro for impl BK2D
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use darling::FromVariant;
use proc_macro2::TokenStream;
use quote::quote;
use syn::{Data, DeriveInput};

#[derive(Default, FromVariant)]
#[darling(attributes(action), default)]
struct StageAttrs {
    stage: Option<u32>,
}

macro_rules! match_arms {
    ( $x:ident, $input:expr ) => {
        match $input.data {
            Data::Enum(ref data) => data
                .variants
                .iter()
                .flat_map(|variant| m::$x(&$input.ident, variant))
                .collect(),
            _ => panic!("unsupported data structure"),
        };
    };
}

mod m {
    use super::StageAttrs;

    use darling::FromVariant;
    use proc_macro2::{Span, TokenStream};
    use quote::quote;
    use syn::{Fields, Ident, Token, Variant};

    pub fn name(name: &Ident, variant: &Variant) -> TokenStream {
        let ident = &variant.ident;
        let ident_s = ident.to_string();
        match &variant.fields {
            Fields::Unit => {
                quote! {
                    #name::#ident => #ident_s,
                }
            }
            Fields::Unnamed(fields) => {
                let bindings = vec![Token![_](Span::call_site()); fields.unnamed.len()];
                quote! {
                    #name::#ident(#(#bindings),*) => #ident_s,
                }
            }
            Fields::Named(_) => {
                quote! {
                    #name::#ident { .. } => #ident_s,
                }
            }
        }
    }

    pub fn stage(name: &Ident, variant: &Variant) -> TokenStream {
        let stage = StageAttrs::from_variant(&variant)
            .expect("failed to parse stage attributes")
            .stage
            .unwrap_or(0);
        let ident = &variant.ident;
        match &variant.fields {
            Fields::Unit => {
                quote! {
                    #name::#ident => #stage,
                }
            }
            Fields::Unnamed(fields) => {
                let bindings = vec![Token![_](Span::call_site()); fields.unnamed.len()];
                quote! {
                    #name::#ident(#(#bindings),*) => #stage,
                }
            }
            Fields::Named(_) => {
                quote! {
                    #name::#ident { .. } => #stage,
                }
            }
        }
    }
}

pub fn derive(input: DeriveInput) -> TokenStream {
    let name = &input.ident;
    let name_body: TokenStream = match_arms!(name, input);
    let stage_body: TokenStream = match_arms!(stage, input);
    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
    quote! {
        impl#impl_generics ::bk2d::Action for #name#ty_generics #where_clause {
            fn name(&self) -> &'static str {
                match self {
                    #name_body
                }
            }

            fn stage(&self) -> u32 {
                match self {
                    #stage_body
                }
            }
        }
    }
}