Rust 宏系统与元编程：声明宏、过程宏与 derive 实战

// 最简单的宏：类似 C 的替代，但类型安全
macro_rules! say {
    ($x:expr) => { println!("{}", $x); };
}

fn main() {
    say!("hello");
    let n = 42;
    say!(n * 2);
}

macro_rules! vec2 {
    ( $( $x:expr ),* ) => {
        {
            let mut temp_vec = Vec::new();
            $( temp_vec.push($x); )*   // 重复展开
            temp_vec
        }
    };
}

fn main() {
    let v = vec2![1, 2, 3, 4];
    assert_eq!(v, vec![1, 2, 3, 4]);
}

macro_rules! count_comma {
    ( $($x:expr),* ) => { /* 逗号分隔 */ };
    ( $($x:expr);+ ) => { /* 分号分隔 */ };
}

// 通用：记录 n 个表达式
macro_rules! n_args {
    () => { 0 };
    ($a:expr) => { 1 };
    ($a:expr, $($rest:expr),*) => { 1 + n_args!($($rest),*) };
}

// 经典：计算到 0 为止
macro_rules! count_down {
    () => { println!("0"); };
    ($n:expr) => {
        println!("{}", $n);
        count_down!($n - 1);  // 注意：表达式递归要小心求值顺序
    };
}

// Cargo.toml（需要单独 proc-macro crate）
[lib]
proc-macro = true

use proc_macro::TokenStream;

#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
    // 解析结构体，生成 impl HelloMacro
    input
}

// 使用
#[derive(HelloMacro)]
struct Pancakes;

#[proc_macro_attribute]
pub fn route(attr: TokenStream, item: TokenStream) -> TokenStream {
    // attr = #[route("/x")] 里的 "/x"
    // item = 函数定义
    item
}

#[proc_macro]
pub fn sql(input: TokenStream) -> TokenStream {
    // 解析 SQL，生成类型安全的查询代码
    input
}

// 使用
let user = sql!(SELECT * FROM users WHERE id = $1);

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

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

#[proc_macro_derive(MyDebug)]
pub fn my_debug(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;

    let expanded = quote! {
        impl std::fmt::Debug for #name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(f, "自定义 Debug: {}", stringify!(#name))
            }
        }
    };
    expanded.into()
}

use syn::{Data, Fields};

let data = &input.data;
if let Data::Struct(data) = data {
    if let Fields::Named(fields) = &data.fields {
        for field in &fields.named {
            let ident = &field.ident;
            let ty = &field.ty;
            // 生成: self.field 访问
            let _ = quote! { self.#ident: #ty };
        }
    }
}

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

#[proc_macro_derive(FromEnv, attributes(env))]
pub fn from_env(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;

    let mut set_fields = Vec::new();
    if let Data::Struct(s) = &input.data {
        if let Fields::Named(fields) = &s.fields {
            for field in &fields.named {
                let ident = &field.ident;
                // 读取 #[env("NAME")] 属性，否则用字段名大写
                let env_name = field
                    .attrs
                    .iter()
                    .find_map(|a| {
                        if a.path().is_ident("env") {
                            a.parse_args::<syn::LitStr>().ok().map(|s| s.value())
                        } else { None }
                    })
                    .unwrap_or_else(|| ident.as_ref().unwrap().to_uppercase());

                set_fields.push(quote! {
                    #ident: std::env::var(#env_name)
                        .unwrap_or_default()
                        .parse()
                        .unwrap_or_default(),
                });
            }
        }
    }

    let expanded = quote! {
        impl #name {
            pub fn from_env() -> Self {
                Self { #(#set_fields)* }
            }
        }
    };
    expanded.into()
}

#[derive(FromEnv)]
struct Config {
    #[env("HOST")]
    host: String,
    port: u16,
}

fn main() {
    std::env::set_var("HOST", "0.0.0.0");
    std::env::set_var("PORT", "8080");
    let cfg = Config::from_env();
    println!("{}:{}", cfg.host, cfg.port);
}

#[proc_macro_attribute]
pub fn timed(attr: TokenStream, item: TokenStream) -> TokenStream {
    let func = parse_macro_input!(item as syn::ItemFn);
    let name = &func.sig.ident;
    let block = &func.block;

    let expanded = quote! {
        #func
        // 或生成包装函数
        fn #name() {
            let start = std::time::Instant::now();
            #block
            println!("{} 耗时 {:?}", stringify!(#name), start.elapsed());
        }
    };
    expanded.into()
}

#[proc_macro]
pub fn build(input: TokenStream) -> TokenStream {
    // 把结构体字面量拆成 builder 链
    input
}

# cargo expand：看宏展开后的真实代码
cargo install cargo-expand
cargo expand

# 依赖默认 nightly 特性

// $crate 用法：确保宏引用的辅助函数解析到自己 crate
macro_rules! try_ok {
    ($e:expr) => {{
        #[allow(unused_mut)]
        let mut __x = $e;
        match __x { Ok(v) => v, Err(e) => return Err(e.into()) }
    }};
}

rustc --pretty expanded    # 旧方式
cargo expand --target-dir /tmp/exp   # 不污染原 target