在Rust quote宏中获取结构体字段类型并判断是否为Option

要在Derive派生宏中获取来源结构体字段的类型并判断是否为Option，分两种场景提供实现方案：

稳定方案（无需Nightly编译器） #

不需要在宏展开阶段直接判断类型，而是通过生成辅助Trait，让Rust类型系统在编译时自动处理转换逻辑，兼容所有稳定版本的Rust。

实现代码 #

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Fields, Ident, AttributeArgs, NestedMeta};

#[proc_macro_derive(MyFrom, attributes(my_from))]
pub fn derive_my_from(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let this_struct_name = &input.ident;
    
    // 解析属性中指定的来源结构体名称
    let mut other_struct_name = None;
    for attr in &input.attrs {
        if attr.path().is_ident("my_from") {
            let args = parse_macro_input!(attr.tokens as AttributeArgs);
            for arg in args {
                if let NestedMeta::Meta(syn::Meta::NameValue(nv)) = arg {
                    if nv.path.is_ident("other") {
                        if let syn::Lit::Str(lit) = nv.lit {
                            other_struct_name = Some(Ident::new(&lit.value(), lit.span()));
                        }
                    }
                }
            }
        }
    }
    let other_struct_name = other_struct_name.expect("`my_from`属性必须指定`other`参数");
    
    let fields = match &input.data {
        syn::Data::Struct(s) => &s.fields,
        _ => panic!("MyFrom仅支持为结构体派生实现"),
    };
    
    // 生成辅助Trait，处理Option与非Option类型的转换
    let helper_trait = quote! {
        trait OptionInto<T> {
            fn option_into(self) -> T;
        }
        
        // Option转非Option：unwrap（注意：运行时可能panic，需确保来源字段不为None）
        impl<T> OptionInto<T> for Option<T> {
            fn option_into(self) -> T {
                self.unwrap()
            }
        }
        
        // 非Option转非Option：直接返回
        impl<T> OptionInto<T> for T {
            fn option_into(self) -> T {
                self
            }
        }
        
        // 非Option转Option：包装为Some
        impl<T> OptionInto<Option<T>> for T {
            fn option_into(self) -> Option<T> {
                Some(self)
            }
        }
    };
    
    // 生成字段转换代码
    let fields_from_other = fields.iter().map(|f| {
        let name = &f.ident;
        quote! {
            #name: other.#name.option_into(),
        }
    });
    
    // 生成最终的From实现
    let output = quote! {
        #helper_trait
        
        impl From<#other_struct_name> for #this_struct_name {
            fn from(other: #other_struct_name) -> Self {
                Self {
                    #(#fields_from_other)*
                }
            }
        }
    };
    
    output.into()
}

说明 #

• 自动处理三种转换场景：来源字段是Option/当前字段非Option、来源与当前字段均为非Option、来源非Option/当前字段是Option。
• 无需手动判断类型，由Rust编译时自动匹配对应的Trait实现。

Nightly方案（宏展开阶段判断类型） #

如果必须在宏展开阶段直接获取来源字段的类型并判断是否为Option，可以使用Rust Nightly的不稳定API实现，但该方案依赖编译器内部API，可能随版本变化失效。

实现代码 #

#![feature(rustc_macro)]
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Fields, Ident, AttributeArgs, NestedMeta};
use rustc_macro::{Ty, Path};

#[proc_macro_derive(MyFrom, attributes(my_from))]
pub fn derive_my_from(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let this_struct_name = &input.ident;
    
    // 解析属性中指定的来源结构体路径
    let mut other_struct_path = None;
    for attr in &input.attrs {
        if attr.path().is_ident("my_from") {
            let args = parse_macro_input!(attr.tokens as AttributeArgs);
            for arg in args {
                if let NestedMeta::Meta(syn::Meta::NameValue(nv)) = arg {
                    if nv.path.is_ident("other") {
                        if let syn::Lit::Str(lit) = nv.lit {
                            let path = Path::from_str(&lit.value());
                            other_struct_path = Some(path);
                        }
                    }
                }
            }
        }
    }
    let other_struct_path = other_struct_path.expect("`my_from`属性必须指定`other`参数");
    let other_struct_ty = Ty::from_path(&other_struct_path);
    let other_struct_name = other_struct_path.segments.last().unwrap().ident();
    
    let fields = match &input.data {
        syn::Data::Struct(s) => &s.fields,
        _ => panic!("MyFrom仅支持为结构体派生实现"),
    };
    
    // 生成字段转换代码：宏展开阶段判断是否为Option
    let fields_from_other = fields.iter().map(|f| {
        let name = &f.ident;
        let field_name_str = name.to_string();
        let field_ty = other_struct_ty.field(field_name_str);
        let is_option = field_ty.is_option();
        
        if is_option {
            quote! {
                #name: other.#name.unwrap(),
            }
        } else {
            quote! {
                #name: other.#name,
            }
        }
    });
    
    // 生成最终的From实现
    let output = quote! {
        impl From<#other_struct_name> for #this_struct_name {
            fn from(other: #other_struct_name) -> Self {
                Self {
                    #(#fields_from_other)*
                }
            }
        }
    };
    
    output.into()
}

说明 #

• 使用rustc_macro不稳定API直接获取来源结构体的类型信息，在宏展开阶段判断字段是否为Option。
• 需使用Nightly编译器，并在Cargo.toml中添加rustc_macro依赖。

内容的提问来源于stack exchange，提问作者Alexander Weber