Skip to main content

meta_enum_derive/
lib.rs

1use proc_macro::TokenStream;
2use quote::quote;
3use syn::DeriveInput;
4
5#[proc_macro_derive(MetaEnum)]
6pub fn derive_meta_enum(input: TokenStream) -> TokenStream {
7    let ast: DeriveInput = syn::parse(input).unwrap();
8    let ident = ast.ident;
9    let len = match &ast.data {
10        syn::Data::Enum(data_enum) => Some(data_enum.variants.len()),
11        _ => None,
12    };
13    let variants: Vec<_> = match &ast.data {
14        syn::Data::Enum(data_enum) => data_enum.variants.iter().map(|v| &v.ident).collect(),
15        _ => Vec::new(),
16    };
17    let keys: Vec<_> = match &ast.data {
18        syn::Data::Enum(data_enum) => data_enum
19            .variants
20            .iter()
21            .map(|v| v.ident.to_string())
22            .collect(),
23        _ => Vec::new(),
24    };
25    let mut last_value = -1;
26    let values: Vec<i32> = match &ast.data {
27        syn::Data::Enum(data_enum) => data_enum
28            .variants
29            .iter()
30            .map(|v| match &v.discriminant {
31                Some(discriminant) => match &discriminant.1 {
32                    syn::Expr::Lit(literal) => match &literal.lit {
33                        syn::Lit::Int(value) => {
34                            last_value = value.base10_parse().ok().unwrap();
35                            last_value
36                        }
37                        _ => -1,
38                    },
39                    _ => -1,
40                },
41                None => match v.fields {
42                    syn::Fields::Unit => {
43                        last_value += 1;
44                        last_value
45                    }
46                    _ => -1,
47                },
48            })
49            .collect(),
50        _ => Vec::new(),
51    };
52    if let Some(len) = len {
53        quote! {
54            impl MetaEnum for #ident {
55                fn count() -> usize {
56                    #len
57                }
58                fn keys() -> Vec<String> {
59                    vec![#(#keys),*].into_iter().map(|key|key.to_string()).collect()
60                }
61                fn values() -> Vec<i32> {
62                    vec![#(#values),*]
63                }
64            }
65            impl core::str::FromStr for #ident {
66                type Err = ParseMetaEnumError<#ident>;
67                fn from_str(s: &str) -> Result<Self, Self::Err> {
68                    for (key, variant) in vec![#(#keys),*].into_iter().zip(vec![#(#ident::#variants),*]) {
69                        if key.to_ascii_lowercase() == s.to_ascii_lowercase() {
70                            return Ok(variant);
71                        }
72                    }
73                    Err(ParseMetaEnumError::new())
74                }
75            }
76            impl From<i32> for #ident {
77                fn from(value: i32) -> #ident {
78                    match value {
79                        #(x if x == #ident::#variants as i32 => #ident::#variants),*,
80                        _ => unreachable!(),
81                    }
82                }
83            }
84
85            impl From<u8> for #ident {
86                fn from(value: u8) -> #ident {
87                    match value {
88                        #(x if x == #ident::#variants as u8 => #ident::#variants),*,
89                        _ => unreachable!(),
90                    }
91                }
92            }
93            impl Into<i32> for #ident {
94                fn into(self) -> i32 {
95                    self as i32
96                }
97            }
98            impl Into<u8> for #ident {
99                fn into(self) -> u8 {
100                    self as u8
101                }
102            }
103        }
104        .into()
105    } else {
106        quote! {
107            impl MetaEnum for #ident {
108                fn count() -> usize {
109                    compile_error!("MetaEnum Macro Only works on Enums");
110                }
111                fn keys() -> Vec<String> {
112                    compile_error!("MetaEnum Macro Only works on Enums");
113                }
114                fn values() -> Vec<i32> {
115                    compile_error!("MetaEnum Macro Only works on Enums");
116                }
117            }
118        }
119        .into()
120    }
121}