使用过程宏将带有命名数据的枚举变体转换为单独的结构

[dependencies]
syn = "1.0"
quote = "1.0"
proc-macro2 = "1.0"

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

#[proc_macro_derive(EnumConversion)]
pub fn enum_conversion(input: TokenStream) -> TokenStream {
    // 解析输入的TokenStream为DeriveInput
    let input = parse_macro_input!(input as DeriveInput);

    // 获取枚举名称
    let name = input.ident;

    // 获取枚举变体
    let variants = match input.data {
        Data::Enum(enum_data) => enum_data.variants,
        _ => panic!("EnumConversion can only be used with enums"),
    };

    // 生成单独的结构体定义
    let struct_def = variants.iter().map(|variant| {
        let variant_name = &variant.ident;
        let struct_name = format!("{}{}", name, variant_name);
        let fields = match &variant.fields {
            syn::Fields::Named(fields) => &fields.named,
            _ => panic!("Enum variants must have named fields"),
        };
        let field_names = fields.iter().map(|field| field.ident.as_ref().unwrap());
        let field_types = fields.iter().map(|field| &field.ty);
        quote! {
            pub struct #struct_name {
                #(pub #field_names: #field_types),*
            }
        }
    });

    // 生成转换函数的实现
    let conversion_impl = variants.iter().map(|variant| {
        let variant_name = &variant.ident;
        let struct_name = format!("{}{}", name, variant_name);
        let fields = match &variant.fields {
            syn::Fields::Named(fields) => &fields.named,
            _ => panic!("Enum variants must have named fields"),
        };
        let field_names = fields.iter().map(|field| field.ident.as_ref().unwrap());
        let field_values = fields.iter().map(|field| &field.ident.as_ref().unwrap());
        quote! {
            impl From<#name> for #struct_name {
                fn from(enum_value: #name) -> Self {
                    match enum_value {
                        #name::#variant_name { #( #field_names ),* } => {
                            #struct_name { #( #field_values ),* }
                        }
                        _ => panic!("Invalid enum variant"),
                    }
                }
            }
        }
    });

    // 生成转换函数的实现
    let conversion_impl = variants.iter().map(|variant| {
        let variant_name = &variant.ident;
        let struct_name = format!("{}{}", name, variant_name);
        let fields = match &variant.fields {
            syn::Fields::Named(fields) => &fields.named,
            _ => panic!("Enum variants must have named fields"),
        };
        let field_names = fields.iter().map(|field| field.ident.as_ref().unwrap());
        let field_values = fields.iter().map(|field| &field.ident.as_ref().unwrap());
        quote! {
            impl From<#name> for #struct_name {
                fn from(enum_value: #name) -> Self {
                    match enum_value {
                        #name::#variant_name { #( #field_names ),* } => {
                            #struct_name { #( #field_values ),* }
                        }
                        _ => panic!("Invalid enum variant"),
                    }
                }
            }
        }
    });

    // 生成转换函数的实现
    let conversion_impl = variants.iter().map(|variant| {
        let variant_name = &variant.ident;
        let struct_name = format!("{}{}", name, variant_name);
        let fields = match &variant.fields {
            syn::Fields::Named(fields) => &fields.named,
            _ => panic!("Enum variants must have named fields"),
        };
        let field_names = fields.iter().map(|field| field.ident.as_ref().unwrap());
        let field_values = fields.iter().map(|field| &field.ident.as_ref().unwrap());
        quote! {
            impl From<#struct_name> for #name {
                fn from(struct_value: #struct_name) -> Self {
                    #name::#variant_name { #( #field_names: struct_value.#field_values ),* }
                }
            }
        }
    });

    // 生成最终的代码
    let expanded = quote! {
        #( #struct_def )*
        #( #conversion_impl )*
    };

    // 将生成的代码转换为TokenStream并返回
    TokenStream::from(expanded)
}

#[derive(EnumConversion)]
enum MyEnum {
    VariantA { field1: u32, field2: String },
    VariantB { field3: bool },
}