Rust 2026 经验谈 - 声明宏 vs 过程宏选型

1
use syn::spanned::Spanned;
2

3
#[proc_macro_derive(MyTrait)]
4
pub fn my_trait_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
5
    let input = parse_macro_input!(input as DeriveInput);
6

7
    match &input.data {
8
        syn::Data::Union(_) => {
9
            return syn::Error::new(
10
                input.span(),
11
                "MyTrait 只能派生给 struct 或 enum，不支持 union"
12
            ).to_compile_error().into();
13
        }
14
        _ => {}
15
    }
16

17
    // ...
18
}

1
// 方案 1（过程宏）：prost-wkt 的 #[derive(Message)]
2
// 适合：少量手动定义的消息
3
// 问题：大 schema（1000+ 消息）时编译很慢
4

5
// 方案 2（build script）：prost 的 build.rs
6
// 适合：大 schema
7
// 优势：只在 .proto 文件变化时重新生成
8

9
// build.rs
10
fn main() {
11
    prost_build::Config::new()
12
        .file("proto/my_service.proto")
13
        .out_dir(std::path::PathBuf::from("src/proto"))
14
        .compile_protos(
15
            &["proto/my_service.proto"],
16
            &["proto/"],
17
        )
18
        .unwrap();
19
}

1
// build.rs：从数据库 schema 生成模型
2
fn main() {
3
    let schema = std::fs::read_to_string("schema.sql").unwrap();
4
    let models = parse_schema(&schema);
5

6
    let mut output = String::new();
7
    for model in &models {
8
        output.push_str(&generate_struct(model));
9
        output.push_str(&generate_impl(model));
10
    }
11

12
    let out_dir = std::env::var("OUT_DIR").unwrap();
13
    let dest_path = std::path::Path::new(&out_dir).join("models.rs");
14
    std::fs::write(&dest_path, output).unwrap();
15

16
    println!("cargo:rerun-if-changed=schema.sql");
17
}

1
// build.rs 生成基础数据结构
2
// 声明宏提供便捷的 DSL 包装
3

4
macro_rules! define_api {
5
    ($($method:ident => $handler:ty),* $(,)?) => {
6
        $(
7
            pub fn $method() -> $handler {
8
                $handler::new()
9
            }
10
        )*
11
    };
12
}
13

14
// build.rs 生成的代码中使用声明宏
15
define_api! {
16
    get_users => UsersHandler,
17
    create_user => CreateUserHandler,
18
    delete_user => DeleteUserHandler,
19
}

1
// 场景：ORM 框架
2
// build.rs：从 schema 生成基础结构体
3
// #[derive(Model)]：为结构体添加 CRUD 方法
4
// macro_rules!：提供查询 DSL
5

6
macro_rules! query {
7
    ($table:ident . $field:ident == $val:expr) => {
8
        Query::new(stringify!($table))
9
            .where_eq(stringify!($field), $val)
10
    };
11
    ($table:ident . $field:ident > $val:expr) => {
12
        Query::new(stringify!($table))
13
            .where_gt(stringify!($field), $val)
14
    };
15
}
16

17
// 使用
18
#[derive(Model)]
19
#[table("users")]
20
struct User {
21
    id: i64,
22
    name: String,
23
}
24

25
let q = query!(users.id == 42);

1
macro_rules! from_str_impl {
2
    ($enum:ident { $($variant:ident),* $(,)? }) => {
3
        impl std::str::FromStr for $enum {
4
            type Err = String;
5
            fn from_str(s: &str) -> Result<Self, Self::Err> {
6
                match s {
7
                    $(stringify!($variant) => Ok($enum::$variant),)*
8
                    _ => Err(format!("unknown variant: {}", s)),
9
                }
10
            }
11
        }
12
    };
13
}
14

15
enum Color { Red, Green, Blue }
16

17
from_str_impl!(Color { Red, Green, Blue });