我正在尝试构建一个进行一些代码转换的宏，并且应该能够解析其自身的语法。 这是我能想到的最简单的例子：
replace!(x, y, x * 100 + z) ~> y * 100 + z
此宏应该能够用作为第三参数提供的表达式中的第二个标识符替换第一个标识符。宏应该对第三个参数的语言有所了解（在我的特定情况下，与示例相反，它不会在Rust中进行解析），并对其进行递归应用。
在Rust中构建这种宏的最有效方法是什么？我知道proc_macro方法和macro_rules!方法。但是，我不确定macro_rules!是否足以处理此问题，并且我找不到太多有关如何使用proc_macro构建自己的转换的文档。谁能指出我正确的方向？
答案 0 :(得分：9)
macro_rules!宏的解决方案使用声明性宏（macro_rules!）来实现这一点有些棘手，但可能。但是，有必要使用一些技巧。
但是首先，下面是代码（Playground）：
macro_rules! replace {
// This is the "public interface". The only thing we do here is to delegate
// to the actual implementation. The implementation is more complicated to
// call, because it has an "out" parameter which accumulates the token we
// will generate.
($x:ident, $y:ident, $($e:tt)*) => {
replace!(@impl $x, $y, [], $($e)*)
};
// Recursion stop: if there are no tokens to check anymore, we just emit
// what we accumulated in the out parameter so far.
(@impl $x:ident, $y:ident, [$($out:tt)*], ) => {
$($out)*
};
// This is the arm that's used when the first token in the stream is an
// identifier. We potentially replace the identifier and push it to the
// out tokens.
(@impl $x:ident, $y:ident, [$($out:tt)*], $head:ident $($tail:tt)*) => {{
replace!(
@impl $x, $y,
[$($out)* replace!(@replace $x $y $head)],
$($tail)*
)
}};
// These arms are here to recurse into "groups" (tokens inside of a
// (), [] or {} pair)
(@impl $x:ident, $y:ident, [$($out:tt)*], ( $($head:tt)* ) $($tail:tt)*) => {{
replace!(
@impl $x, $y,
[$($out)* ( replace!($x, $y, $($head)*) ) ],
$($tail)*
)
}};
(@impl $x:ident, $y:ident, [$($out:tt)*], [ $($head:tt)* ] $($tail:tt)*) => {{
replace!(
@impl $x, $y,
[$($out)* [ replace!($x, $y, $($head)*) ] ],
$($tail)*
)
}};
(@impl $x:ident, $y:ident, [$($out:tt)*], { $($head:tt)* } $($tail:tt)*) => {{
replace!(
@impl $x, $y,
[$($out)* { replace!($x, $y, $($head)*) } ],
$($tail)*
)
}};
// This is the standard recusion case: we have a non-identifier token as
// head, so we just put it into the out parameter.
(@impl $x:ident, $y:ident, [$($out:tt)*], $head:tt $($tail:tt)*) => {{
replace!(@impl $x, $y, [$($out)* $head], $($tail)*)
}};
// Helper to replace the identifier if its the needle.
(@replace $needle:ident $replacement:ident $i:ident) => {{
// This is a trick to check two identifiers for equality. Note that
// the patterns in this macro don't contain any meta variables (the
// out meta variables $needle and $i are interpolated).
macro_rules! __inner_helper {
// Identifiers equal, emit $replacement
($needle $needle) => { $replacement };
// Identifiers not equal, emit original
($needle $i) => { $i };
}
__inner_helper!($needle $i)
}}
}
fn main() {
let foo = 3;
let bar = 7;
let z = 5;
dbg!(replace!(abc, foo, bar * 100 + z)); // no replacement
dbg!(replace!(bar, foo, bar * 100 + z)); // replace `bar` with `foo`
}
它输出：
[src/main.rs:56] replace!(abc , foo , bar * 100 + z) = 705
[src/main.rs:57] replace!(bar , foo , bar * 100 + z) = 305
在理解此宏之前，有两个主要技巧需要理解：降低累积量和如何检查两个标识符是否相等。
此外，请确保：宏模式开始处的@foobar不是特殊功能，而只是标记内部帮助程序宏的约定（另请参见："The little book of Macros"，{ {3}}。
下推积累在StackOverflow question中有很好的描述。重要的部分是：
Rust中的所有宏必须会产生一个完整的，受支持的语法元素（例如表达式，项目等）。这意味着不可能将宏扩展为部分构造。
但是经常有必要获得部分结果，例如，在使用某些输入来处理令牌的情况下。为了解决这个问题，基本上有一个“ out”参数，它只是随每个递归宏调用而增长的令牌列表。之所以可行，是因为宏输入可以是任意标记，而不必是有效的Rust构造。
此模式仅对可用作“增量TT杀手”的宏有意义，而我的解决方案确实如此。还有this chapter of "The little book of Rust macros"。
第二个关键点是检查两个标识符是否相等。这是通过一个有趣的技巧完成的：宏定义了一个新的宏，然后立即使用它。让我们看一下代码：
(@replace $needle:ident $replacement:ident $i:ident) => {{
macro_rules! __inner_helper {
($needle $needle) => { $replacement };
($needle $i) => { $i };
}
__inner_helper!($needle $i)
}}
让我们经历两个不同的调用：
replace!(@replace foo bar baz)：扩展为：
macro_rules! __inner_helper {
(foo foo) => { bar };
(foo baz) => { baz };
}
__inner_helper!(foo baz)
现在inner_helper!调用显然采用第二种模式，结果为baz。
replace!(@replace foo bar foo)扩展为：
macro_rules! __inner_helper {
(foo foo) => { bar };
(foo foo) => { foo };
}
__inner_helper!(foo foo)
这次，inner_helper!调用采用第一个模式，结果为bar。
我从一个箱子中学到了这个技巧，该箱子基本上只提供以下内容：宏检查两个标识符是否相等。但不幸的是，我再也找不到这个箱子了。让我知道您是否知道该板条箱的名称！
此实现有一些限制，但是：
作为增量TT muncher，它针对输入中的每个令牌递归。因此很容易达到递归限制（可以增加，但不是最佳的）。可能可以编写此宏的非递归版本，但到目前为止，我还没有找到实现此目的的方法。
macro_rules!宏在标识符方面有点奇怪。上面介绍的解决方案在以self作为标识符的情况下可能表现得很奇怪。有关该主题的更多信息，请参见a chapter about this pattern in TLBORM。
当然，这也可以通过proc-macro完成。它还涉及较少的奇怪技巧。我的解决方案如下所示：
extern crate proc_macro;
use proc_macro::{
Ident, TokenStream, TokenTree,
token_stream,
};
#[proc_macro]
pub fn replace(input: TokenStream) -> TokenStream {
let mut it = input.into_iter();
// Get first parameters
let needle = get_ident(&mut it);
let _comma = it.next().unwrap();
let replacement = get_ident(&mut it);
let _comma = it.next().unwrap();
// Return the remaining tokens, but replace identifiers.
it.map(|tt| {
match tt {
// Comparing `Ident`s can only be done via string comparison right
// now. Note that this ignores syntax contexts which can be a
// problem in some situation.
TokenTree::Ident(ref i) if i.to_string() == needle.to_string() => {
TokenTree::Ident(replacement.clone())
}
// All other tokens are just forwarded
other => other,
}
}).collect()
}
/// Extract an identifier from the iterator.
fn get_ident(it: &mut token_stream::IntoIter) -> Ident {
match it.next() {
Some(TokenTree::Ident(i)) => i,
_ => panic!("oh noes!"),
}
}
在上面的main()示例中使用此proc宏的工作原理完全相同。
注意：此处的错误处理被忽略，以简化示例。请参阅this chapter，了解如何在proc宏中进行错误报告。
除此以外，我认为该代码不需要太多解释。此proc宏版本也不会像macro_rules!宏那样受到递归限制的困扰。