architect-derive 0.4.0

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

pub fn derive_from_inner(input: TokenStream) -> TokenStream {
    let DeriveInput { ident: enum_name, data, .. } = parse_macro_input!(input);
    let data_enum = match data {
        Data::Enum(data_enum) => data_enum,
        _ => panic!("FromInner can only be derived for enums"),
    };
    let from_impls: Vec<_> = data_enum
        .variants
        .iter()
        .map(|v| {
            let Variant { ident: variant_name, fields, .. } = v;
            match fields {
                Fields::Unnamed(fields_unnamed) if fields_unnamed.unnamed.len() == 1 => {
                    let field = fields_unnamed.unnamed.first().unwrap();
                    let ty = &field.ty;
                    quote! {
                        impl From<#ty> for #enum_name {
                            fn from(inner: #ty) -> Self {
                                Self::#variant_name(inner)
                            }
                        }
                    }
                }
                _ => panic!("variant `{}` is not a single tuple variant", variant_name),
            }
        })
        .collect();
    let expanded = quote! {
        #(#from_impls)*
    };
    TokenStream::from(expanded)
}