Rust中能否在编译期断言结构体字段均存在于另一结构体？

Rust 标准的derive宏不支持带参数（像你写的#[derive(MyMacro(User))]语法不符合规范），但可以通过属性宏 + 编译时 trait 检查的方式实现你的需求，全程在编译阶段完成字段合法性校验，无运行时开销。

实现步骤 #

1. 创建过程宏项目 #

新建一个库类型的 Cargo 项目，启用过程宏支持：

[package]
name = "field_validator_macro"
version = "0.1.0"
edition = "2021"

[lib]
proc-macro = true

[dependencies]
syn = { version = "2.0", features = ["full"] }
quote = "1.0"
proc-macro2 = "1.0"

2. 编写宏代码 #

在src/lib.rs中实现两个核心部分：自动生成字段访问 trait 的derive宏，以及校验字段的属性宏：

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

// 用于编译时获取结构体字段类型的 trait
pub trait FieldAccessor<Field> {
    type Type;
}

// 自动为结构体生成 FieldAccessor 实现的 derive 宏
#[proc_macro_derive(FieldAccessor)]
pub fn derive_field_accessor(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let struct_name = input.ident;

    // 只处理带命名字段的结构体
    let fields = match input.data {
        syn::Data::Struct(syn::DataStruct { fields: syn::Fields::Named(fields), .. }) => fields.named,
        _ => panic!("FieldAccessor 仅支持带命名字段的结构体"),
    };

    // 为每个字段生成对应的 FieldAccessor 实现
    let field_impls = fields.iter().map(|field| {
        let field_name = field.ident.as_ref().unwrap();
        let field_type = &field.ty;
        quote! {
            impl $crate::FieldAccessor<#field_name> for #struct_name {
                type Type = #field_type;
            }
        }
    });

    quote! { #(#field_impls)* }.into()
}

// 校验结构体字段是否来自指定父结构体的属性宏
#[proc_macro_attribute]
pub fn validate_fields(args: TokenStream, input: TokenStream) -> TokenStream {
    // 解析属性参数（比如 User）
    let args = parse_macro_input!(args as AttributeArgs);
    let parent_struct_name = match args.first() {
        Some(NestedMeta::Path(path)) => path.get_ident().unwrap().clone(),
        _ => panic!("请传入父结构体名称，例如 #[validate_fields(User)]"),
    };

    // 解析当前要校验的结构体
    let input_struct = parse_macro_input!(input as ItemStruct);
    let fields = input_struct.fields;

    // 生成编译时检查代码：每个字段必须在父结构体中存在且类型匹配
    let checks = fields.iter().map(|field| {
        let field_name = field.ident.as_ref().unwrap();
        let field_type = &field.ty;

        quote! {
            const _: () = {
                // 尝试获取父结构体对应字段的类型
                type ParentFieldType = <#parent_struct_name as $crate::FieldAccessor<#field_name>>::Type;
                // 强制类型匹配，不匹配则编译报错
                const _: ParentFieldType = #field_type::default();
            };
        }
    });

    // 保留原结构体代码，插入校验逻辑
    let expanded = quote! {
        #input_struct
        #(#checks)*
    };

    expanded.into()
}

3. 在业务代码中使用 #

use field_validator_macro::{validate_fields, FieldAccessor};

// 定义父结构体，自动生成 FieldAccessor 实现
#[derive(FieldAccessor)]
struct User {
    id: u32,
    first_name: String,
    last_name: String,
}

// 合法：字段均来自 User 且类型匹配
#[validate_fields(User)]
struct UserData1 {
    id: u32,
    first_name: String,
}

// 不合法：foo 不是 User 的字段，编译阶段会报错
#[validate_fields(User)]
struct UserData2 {
    id: u32,
    foo: String,
}

工作原理 #

1. FieldAccessor trait 用于在编译时关联结构体字段与对应的类型
2. #[derive(FieldAccessor)] 自动为父结构体的每个字段生成 trait 实现
3. #[validate_fields(User)] 属性宏会遍历当前结构体的所有字段，尝试通过FieldAccessor获取父结构体对应字段的类型：
   • 如果字段不存在，编译器会找不到对应的 trait 实现，直接报错
   • 如果字段类型不匹配，类型强制赋值的代码会触发编译错误

内容的提问来源于stack exchange，提问作者Gregory Presser