Rust中如何在format!调用及宏场景下允许未使用的非Display命名参数？

这确实是Rust格式化宏里一个挺棘手的场景，尤其是当你需要在自定义错误库中处理那些没法实现Display的参数时。我来一步步给你拆解可行的解决方案：

核心要绕开Rust格式化宏的两个限制：未使用参数的编译错误和参数必须实现Display的要求，下面是具体实现思路：

1. 定义“忽略输出”的包装类型 #

首先我们需要一个能包裹任意类型、且实现Display但不输出任何内容的类型，这样可以让非Display类型顺利通过编译：

#[derive(Debug, Clone, Copy)]
pub struct Ignore<T>(pub T);

impl<T> std::fmt::Display for Ignore<T> {
    fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Ok(()) // 不产生任何输出内容
    }
}

// 实现From trait，让包装操作更简洁
impl<T> From<T> for Ignore<T> {
    fn from(value: T) -> Self {
        Self(value)
    }
}

2. 用过程宏自动处理格式串与参数 #

因为你需要在宏场景下处理不透明的格式串，无法静态判断哪些参数被引用，所以最可靠的方式是用过程宏解析格式串中的占位符，自动处理未被引用的参数：

过程宏核心逻辑 #

1. 解析输入的格式字符串，提取所有被引用的命名占位符（比如{age}中的age）；
2. 分离出格式串中未被引用的参数；
3. 构造新的格式字符串：原始格式串 + 未引用参数的占位符（比如{birthday}）；
4. 生成format!调用：被引用的参数直接传递，未引用的参数用Ignore包装。

完整过程宏代码 #

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Expr, ExprAssign, ExprCall, ExprLit, ExprPath, LitStr};

#[proc_macro]
pub fn my_format(input: TokenStream) -> TokenStream {
    // 解析宏调用结构：my_format!("格式串", 参数名=参数值, ...)
    let call = parse_macro_input!(input as ExprCall);
    let format_str = match call.args.first().unwrap() {
        Expr::Lit(ExprLit { lit: LitStr(s), .. }) => s,
        _ => panic!("格式串必须是字符串字面量！"),
    };

    // 提取格式串中所有已被引用的命名占位符
    let used_param_names = extract_named_placeholders(&format_str.value());

    // 分离已使用和未使用的参数
    let mut used_args = Vec::new();
    let mut unused_args = Vec::new();

    for arg in call.args.iter().skip(1) {
        let (name, value) = match arg {
            Expr::Assign(ExprAssign { left, right, .. }) => {
                let ident = match left.as_ref() {
                    Expr::Path(ExprPath { path, .. }) => path.get_ident().unwrap().to_string(),
                    _ => panic!("参数必须是`参数名=参数值`的命名格式！"),
                };
                (ident, right.clone())
            }
            _ => panic!("参数必须是`参数名=参数值`的命名格式！"),
        };

        if used_param_names.contains(&name.as_str()) {
            used_args.push((name, value));
        } else {
            unused_args.push((name, value));
        }
    }

    // 构建新的格式字符串：原始串 + 未使用参数的占位符
    let new_format_str = format!(
        "{}{}",
        format_str.value(),
        unused_args.iter()
            .map(|(name, _)| format!("{{{name}}}"))
            .collect::<String>()
    );

    // 生成format!调用的参数列表
    let used_tokens = used_args.iter().map(|(name, expr)| {
        quote! { #name = #expr }
    });
    let unused_tokens = unused_args.iter().map(|(name, expr)| {
        quote! { #name = crate::Ignore::from(#expr) }
    });

    // 生成最终编译代码
    let output = quote! {
        format!(#new_format_str, #(#used_tokens,)* #(#unused_tokens,)*)
    };

    output.into()
}

// 辅助函数：从格式串中提取所有命名占位符
fn extract_named_placeholders(s: &str) -> Vec<&str> {
    let mut names = Vec::new();
    let mut chars = s.chars().peekable();

    while let Some(c) = chars.next() {
        if c == '{' {
            let mut name = String::new();
            // 读取占位符名称，直到遇到`}`或格式说明符的`:`
            while let Some(&next) = chars.peek() {
                if next == '}' || next == ':' {
                    break;
                }
                name.push(chars.next().unwrap());
            }
            if !name.is_empty() {
                names.push(name.as_str());
            }
        }
    }

    names
}

3. 使用示例 #

假设你有一个自定义错误场景，其中birthday是一个未实现Display的类型：

// 未实现Display的自定义类型
struct Birthday(u64);

fn main() {
    let age = 30;
    let birthday = Birthday(19930515);

    // 使用自定义宏my_format!
    let message = my_format!("You are {age} years old", age=age, birthday=birthday);
    println!("{}", message); // 输出：You are 30 years old
}

这个调用会被宏自动展开为：

format!(
    "You are {age} years old{birthday}",
    age=age,
    birthday=Ignore::from(birthday)
)

这样既避免了未使用参数的编译错误，又不需要birthday实现Display，同时最终输出完全符合原始格式串的预期。

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