如何在Rust中实现类似C #define的纯文本替换以简化语法？

Rust本身没有C预处理器那样的全局纯文本替换宏，但可以通过两种方案实现你要的语法简化需求：

一、使用Rust过程宏（Procedural Macros） #

这是最贴合Rust生态的方案，过程宏能在编译阶段对代码做自定义语法转换。你可以写一个通用的过程宏，实现你需要的两个替换规则：

1. 将!!.替换为.unwrap()
2. 将Type??替换为Option<Type>

实现步骤 #

1. 新建一个proc-macro类型的库项目，在Cargo.toml中添加依赖：

[lib]
proc-macro = true

[dependencies]
proc-macro2 = "1.0"
syn = "2.0"
quote = "1.0"
regex = "1.10"

2. 编写过程宏代码：

use proc_macro::TokenStream;
use regex::Regex;

#[proc_macro]
pub fn simplify(input: TokenStream) -> TokenStream {
    // 将TokenStream转为字符串进行处理
    let mut code = input.to_string();
    
    // 替换自定义可选类型语法：Type?? → Option<Type>
    let type_pattern = Regex::new(r"(\w+)\?\?").unwrap();
    code = type_pattern.replace_all(&code, "Option<$1>").to_string();
    
    // 替换非空断言语法：!!. → .unwrap()
    let unwrap_pattern = Regex::new(r"!!\.").unwrap();
    code = unwrap_pattern.replace_all(&code, ".unwrap()").to_string();
    
    // 将处理后的字符串转回TokenStream返回
    code.parse().unwrap()
}

3. 在业务代码中使用该宏：

// 引入自定义宏
use your_macro_crate::simplify;

simplify! {
    struct ReturnPath {
        name: String??,
        file_type: String??,
        mtime: i64??
    }

    fn demo() {
        let opt_num: Option<i32> = Some(42);
        let num = opt_num!!.to_string();
        println!("{}", num);
    }
}

注意：正则替换存在局限性，比如会误处理字符串字面量中的!!.或??。如果要更严谨，建议用syn crate解析Rust语法树，针对性修改语法节点，避免误替换。

二、使用外部预处理脚本 #

如果不想写Rust宏，也可以用外部脚本（如Python、Shell）在编译前手动转换自定义语法为标准Rust代码，再交给rustc编译。

示例Python预处理脚本 #

import re
import sys

def transform_code(raw_code):
    # 替换Type??为Option<Type>
    processed = re.sub(r"(\w+)\?\?", r"Option<\1>", raw_code)
    # 替换!!.为.unwrap()
    processed = re.sub(r"!!\.", r".unwrap()", processed)
    return processed

if __name__ == "__main__":
    # 读取自定义语法文件，输出标准Rust文件
    with open(sys.argv[1], 'r', encoding='utf-8') as f:
        content = f.read()
    with open(sys.argv[2], 'w', encoding='utf-8') as f:
        f.write(transform_code(content))

配置自动预处理 #

在项目的build.rs中添加逻辑，让编译前自动执行脚本：

use std::process::Command;

fn main() {
    // 执行预处理脚本，将src/main.custom.rs转为src/main.rs
    Command::new("python")
        .arg("preprocess.py")
        .arg("src/main.custom.rs")
        .arg("src/main.rs")
        .status()
        .expect("预处理脚本执行失败");
}

这种方式完全是纯文本替换，和C预处理器逻辑一致，但缺点是IDE无法识别自定义语法，会失去语法提示和检查功能。

注意事项 #

• Rust的宏系统本质是语法树操作，纯文本替换并非原生设计，所以过程宏方案更推荐用语法树解析而非正则，避免潜在的替换错误。
• 自定义语法会增加团队协作的学习成本，仅建议在内部统一约定的场景下使用。

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