use crate::utils::{generate_crate_access, generate_runtime_interface_include};
use syn::{Data, DeriveInput, Error, Fields, Ident, Result};
use quote::quote;
use proc_macro2::{Span, TokenStream};
pub fn derive_impl(input: DeriveInput) -> Result<TokenStream> {
let crate_include = generate_runtime_interface_include();
let crate_ = generate_crate_access();
let ident = input.ident;
let enum_fields = get_enum_field_idents(&input.data)?
.enumerate()
.map(|(i, v)| {
let i = i as u8;
v.map(|v| (quote!(#i => Ok(#ident::#v)), quote!(#ident::#v => #i)))
})
.collect::<Result<Vec<_>>>()?;
let try_from_variants = enum_fields.iter().map(|i| &i.0);
let into_variants = enum_fields.iter().map(|i| &i.1);
let res = quote! {
const _: () = {
#crate_include
impl #crate_::pass_by::PassBy for #ident {
type PassBy = #crate_::pass_by::Enum<#ident>;
}
impl TryFrom<u8> for #ident {
type Error = ();
fn try_from(inner: u8) -> core::result::Result<Self, ()> {
match inner {
#( #try_from_variants, )*
_ => Err(()),
}
}
}
impl From<#ident> for u8 {
fn from(var: #ident) -> u8 {
match var {
#( #into_variants ),*
}
}
}
};
};
Ok(res)
}
fn get_enum_field_idents(data: &Data) -> Result<impl Iterator<Item = Result<&Ident>>> {
match data {
Data::Enum(d) =>
if d.variants.len() <= 256 {
Ok(d.variants.iter().map(|v| {
if let Fields::Unit = v.fields {
Ok(&v.ident)
} else {
Err(Error::new(
Span::call_site(),
"`PassByEnum` only supports unit variants.",
))
}
}))
} else {
Err(Error::new(Span::call_site(), "`PassByEnum` only supports `256` variants."))
},
_ => Err(Error::new(Span::call_site(), "`PassByEnum` only supports enums as input type.")),
}
}