如何在程序宏生成的代码中创建卫生标识符？

Question

在编写声明性（ macro_rules! ）宏时，我们会自动获得宏卫生。 在这个例子中，我在宏中声明了一个名为f的变量，并传入了一个标识符f ，它变成了一个局部变量：

macro_rules! decl_example {
    ($tname:ident, $mname:ident, ($($fstr:tt),*)) => {
        impl std::fmt::Display for $tname {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                let Self { $mname } = self;
                write!(f, $($fstr),*)
            }
        }
    }
}

struct Foo {
    f: String,
}

decl_example!(Foo, f, ("I am a Foo: {}", f));

fn main() {
    let f = Foo {
        f: "with a member named `f`".into(),
    };
    println!("{}", f);
}

这段代码可以编译，但如果你查看部分展开的代码，你会发现存在明显的冲突：

impl std::fmt::Display for Foo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let Self { f } = self;
        write!(f, "I am a Foo: {}", f)
    }
}

我正在编写这个声明性宏的等价物作为过程宏，但不知道如何避免用户提供的标识符和我的宏创建的标识符之间的潜在名称冲突。 据我所知，生成的代码没有卫生概念，只是一个字符串：

src/main.rs

use my_derive::MyDerive;

#[derive(MyDerive)]
#[my_derive(f)]
struct Foo {
    f: String,
}

fn main() {
    let f = Foo {
        f: "with a member named `f`".into(),
    };
    println!("{}", f);
}

Cargo.toml

[package]
name = "example"
version = "0.1.0"
edition = "2018"

[dependencies]
my_derive = { path = "my_derive" }

my_derive/src/lib.rs

extern crate proc_macro;

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

#[proc_macro_derive(MyDerive, attributes(my_derive))]
pub fn my_macro(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    let name = input.ident;

    let attr = input.attrs.into_iter().filter(|a| a.path.is_ident("my_derive")).next().expect("No name passed");
    let meta = attr.parse_meta().expect("Unknown attribute format");
    let meta = match meta {
        Meta::List(ml) => ml,
        _ => panic!("Invalid attribute format"),
    };
    let meta = meta.nested.first().expect("Must have one path");
    let meta = match meta {
        NestedMeta::Meta(Meta::Path(p)) => p,
        _ => panic!("Invalid nested attribute format"),
    };
    let field_name = meta.get_ident().expect("Not an ident");

    let expanded = quote! {
        impl std::fmt::Display for #name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                let Self { #field_name } = self;
                write!(f, "I am a Foo: {}", #field_name)
            }
        }
    };

    TokenStream::from(expanded)
}

my_derive/Cargo.toml

[package]
name = "my_derive"
version = "0.1.0"
edition = "2018"

[lib]
proc-macro = true

[dependencies]
syn = "1.0.13"
quote = "1.0.2"
proc-macro2 = "1.0.7"

在 Rust 1.40 中，这会产生编译器错误：

error[E0599]: no method named `write_fmt` found for type `&std::string::String` in the current scope
 --> src/main.rs:3:10
  |
3 | #[derive(MyDerive)]
  |          ^^^^^^^^ method not found in `&std::string::String`
  |
  = help: items from traits can only be used if the trait is in scope
  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
help: the following trait is implemented but not in scope; perhaps add a `use` for it:
  |
1 | use std::fmt::Write;
  |

存在哪些技术可以将我的标识符命名为不受我控制的标识符？

Answer 1

总结：你还不能在稳定的 Rust 上使用带有 proc 宏的卫生标识符。 最好的办法是使用一个特别难看的名字，比如__your_crate_your_name 。

---

您正在使用quote!创建标识符（特别是f ） quote! . 这当然很方便，但它只是编译器提供的实际 proc 宏 API 的辅助工具。 那么让我们来看看那个 API，看看我们如何创建标识符！ 最后我们需要一个TokenStream ，因为那是我们的 proc 宏返回的。 我们如何构建这样的令牌流？

我们可以从字符串中解析它，例如"let f = 3;".parse::<TokenStream>() 。 但这基本上是一个早期的解决方案，现在不鼓励。 在任何情况下，以这种方式创建的所有标识符都以不卫生的方式运行，因此这不会解决您的问题。

第二种方式（其quote!引擎盖下应用）是创建TokenStream通过创建一堆手动TokenTree小号。 一种TokenTree是Ident （标识符）。 我们可以通过new创建一个Ident ：

fn new(string: &str, span: Span) -> Ident

string参数是不言自明的，但span参数是有趣的部分！ Span存储源代码中某些内容的位置，通常用于错误报告（例如，为了让rustc指向拼写错误的变量名称）。 但是在 Rust 编译器中，span 携带的不仅仅是位置信息：那种卫生！ 我们可以看到Span两个构造函数：

• fn call_site() -> Span ：创建一个带有呼叫站点卫生的跨度。 这就是你所说的“不卫生”，相当于“复制粘贴”。 如果两个标识符具有相同的字符串，它们将相互碰撞或遮蔽。

• fn def_site() -> Span ：这就是你所追求的。 技术上称为定义站点卫​​生，这就是您所说的“卫生”。 您定义的标识符和您的用户的标识符存在于不同的宇宙中，永远不会发生冲突。 正如您在文档中所见，此方法仍然不稳定，因此只能在夜间编译器上使用。 无赖！

没有真正好的解决方法。 显而易见的是使用一个非常丑陋的名字，比如__your_crate_some_variable 。 为了让您更轻松，您可以创建该标识符一次并在quote!使用它quote! （这里稍微好一点的解决方案）：

let ugly_name = quote! { __your_crate_some_variable };
quote! {
    let #ugly_name = 3;
    println!("{}", #ugly_name);
}

有时，您甚至可以搜索可能与您的用户标识符发生冲突的所有用户标识符，然后通过算法简单地选择一个不会发生冲突的标识符。 这实际上是我们为auto_impl ，带有一个超级丑陋的后备名称。 这主要是为了改进生成的文档中包含超级丑陋的名字。

除此之外，恐怕你真的什么也做不了。

Answer 2

你可以感谢一个 UUID：

fn generate_unique_ident(prefix: &str) -> Ident {
    let uuid = uuid::Uuid::new_v4();
    let ident = format!("{}_{}", prefix, uuid).replace('-', "_");

    Ident::new(&ident, Span::call_site())
}