如何让Rust过程宏支持接受字符串拼接表达式作为输入参数？

我完全理解你的困扰——核心功能已经跑通，却卡在了路径参数的灵活性上，明明env!和concat!都是编译期可用的工具，却没法直接传给过程宏，确实有点别扭。

问题的根源在于过程宏的参数解析时机：你原本的代码直接把输入解析成LitStr（纯字符串字面量），但用户写的concat!(env!("CARGO_MANIFEST_DIR"), "/userdata/myconfigfile.json")是一个宏调用表达式，在过程宏执行时还没被展开成字面量，所以syn会抛出"expected a string literal"的错误。

下面给你两种实用的解决方案，分别适配不同的使用场景：

方案一：直接在过程宏中读取环境变量（最简洁） #

如果你的核心需求就是基于CARGO_MANIFEST_DIR构造路径，完全可以让过程宏自己读取这个环境变量，用户只需要传入相对路径即可，不用手动拼接。

修改后的过程宏代码 #

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, LitStr};
use serde_json;
use std::path::Path;

#[proc_macro]
pub fn generate_myenum(input: TokenStream) -> TokenStream {
    // 解析用户传入的相对路径字面量
    let input = parse_macro_input!(input as LitStr);
    let relative_path = input.value();

    // 读取当前调用宏的crate的CARGO_MANIFEST_DIR环境变量
    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR")
        .expect("Failed to get CARGO_MANIFEST_DIR (请使用Cargo编译，不要直接用rustc)");
    
    // 拼接完整路径
    let json_path = Path::new(&manifest_dir).join(relative_path);
    let json_path_str = json_path.to_str()
        .expect("路径包含无效Unicode字符");

    // 以下是你原本的核心逻辑，完全保留
    let json_data = std::fs::read_to_string(json_path_str)
        .expect("读取JSON文件失败");
    let deserialized_data: Vec<serde_json::Value> = serde_json::from_str(&json_data)
        .expect("JSON格式非法");

    let mut my_names = Vec::new();
    for some_elt in deserialized_data {
        if let Some(arr) = some_elt.get("mylist").and_then(|s| s.as_array()) {
            for e in arr {
                if let Some(name) = e.get("name").and_then(|n| n.as_str()) {
                    my_names.push(name.to_string());
                }
            }
        }
    }

    let enum_variants = my_names
        .iter()
        .map(|name| syn::Ident::new(name, proc_macro2::Span::call_site()));

    let output = quote! {
        pub enum UserEnum {
            #(#enum_variants),*
        }
    };

    TokenStream::from(output)
}

用户侧调用方式 #

现在用户只需要传入相对路径，过程宏会自动拼接根目录：

generate_myenum!("userdata/myconfigfile.json");

方案二：手动解析concat!和env!表达式（支持任意拼接） #

如果你需要支持更灵活的路径组合（比如多个环境变量、复杂拼接逻辑），可以修改过程宏的参数解析逻辑，手动处理concat!和env!的调用，计算出最终的路径字符串。

步骤1：更新依赖特性 #

在my_macros crate的Cargo.toml中，确保syn开启了表达式解析的特性：

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

步骤2：修改过程宏代码 #

use proc_macro::TokenStream;
use quote::quote;
use syn::{
    parse_macro_input, Expr, ExprLit, Lit, ExprMacro, LitStr,
    punctuated::Punctuated, token::Comma
};
use serde_json;
use std::env;

// 递归解析表达式，计算出最终的字符串值
fn evaluate_path_expr(expr: &Expr) -> String {
    match expr {
        // 处理普通字符串字面量
        Expr::Lit(ExprLit { lit: Lit::Str(s), .. }) => s.value(),
        
        // 处理concat!宏调用
        Expr::Macro(expr_macro) if expr_macro.mac.path.is_ident("concat") => {
            // 解析concat!的所有参数
            let args = parse_macro_input!(expr_macro.mac.tokens.clone() as Punctuated<Expr, Comma>);
            // 递归计算每个参数的字符串值并拼接
            args.into_iter()
                .map(|arg| evaluate_path_expr(&arg))
                .collect()
        }
        
        // 处理env!宏调用
        Expr::Macro(expr_macro) if expr_macro.mac.path.is_ident("env") => {
            // 解析env!的参数（必须是字符串字面量）
            let env_var = parse_macro_input!(expr_macro.mac.tokens.clone() as LitStr);
            // 读取对应环境变量
            env::var(env_var.value())
                .unwrap_or_else(|e| panic!("读取环境变量{}失败: {}", env_var.value(), e))
        }
        
        // 不支持的表达式类型
        _ => panic!("不支持的路径表达式！仅接受字符串字面量、concat!或env!"),
    }
}

#[proc_macro]
pub fn generate_myenum(input: TokenStream) -> TokenStream {
    // 解析输入为任意表达式
    let input_expr = parse_macro_input!(input as Expr);
    // 计算出最终的路径字符串
    let json_path = evaluate_path_expr(&input_expr);

    // 以下是你原本的核心逻辑，完全保留
    let json_data = std::fs::read_to_string(&json_path)
        .expect("读取JSON文件失败");
    let deserialized_data: Vec<serde_json::Value> = serde_json::from_str(&json_data)
        .expect("JSON格式非法");

    let mut my_names = Vec::new();
    for some_elt in deserialized_data {
        if let Some(arr) = some_elt.get("mylist").and_then(|s| s.as_array()) {
            for e in arr {
                if let Some(name) = e.get("name").and_then(|n| n.as_str()) {
                    my_names.push(name.to_string());
                }
            }
        }
    }

    let enum_variants = my_names
        .iter()
        .map(|name| syn::Ident::new(name, proc_macro2::Span::call_site()));

    let output = quote! {
        pub enum UserEnum {
            #(#enum_variants),*
        }
    };

    TokenStream::from(output)
}

用户侧调用方式 #

现在用户可以直接传入拼接表达式了：

generate_myenum!(concat!(env!("CARGO_MANIFEST_DIR"), "/userdata/myconfigfile.json"));

注意事项 #

1. 过程宏运行在编译期，可以安全地进行文件IO和环境变量读取，但要注意：
   • CARGO_MANIFEST_DIR是Cargo设置的环境变量，直接用rustc编译时不会存在；
   • 路径是相对于调用宏的用户crate，而非过程宏自身的crate。
2. 若需要支持更多表达式类型，可以扩展evaluate_path_expr函数，但解析逻辑会相应变复杂。

备注：内容来源于stack exchange，提问作者MatthieuHAMEL