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}