如何通过 Rust 宏将表达式中的一个标识符替换为另一个标识符？
How to replace one identifier in an expression with another one via Rust macro?
我正在尝试构建一个执行某些代码转换的宏，并且应该能够解析它自己的语法。
这是我能想到的最简单的例子：
replace!(x, y, x * 100 + z) ~> y * 100 + z
这个宏应该能够用作为第三个参数提供的表达式中的第二个标识符替换第一个标识符。宏应该对第三个参数的语言有一些了解（在我的特定情况下，与示例相反，不会在 Rust 中解析）并递归地应用它。
在 Rust 中构建这样一个宏的最有效方法是什么？我知道 proc_macro 方法和 macro_rules! 方法。但是我不确定 macro_rules! 是否足够强大来处理这个问题，而且我找不到很多关于如何使用 proc_macro 构建我自己的转换的文档。谁能指出我正确的方向？
使用 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", ).
下推积累在this chapter of "The little book of Rust macros"中有很好的描述。重要的部分是：
All macros in Rust must result in a complete, supported syntax element (such as an expression, item, etc.). This means that it is impossible to have a macro expand to a partial construct.
但通常有必要获得部分结果，例如在使用某些输入处理令牌时。为了解决这个问题，基本上有一个 "out" 参数，它只是一个标记列表，随着每个递归宏调用而增长。这是可行的，因为宏输入可以是任意标记，而不必是有效的 Rust 构造。
此模式仅对作为 "incremental TT munchers" 工作的宏有意义，而我的解决方案正是这样做的。还有a chapter about this pattern in TLBORM.
第二个关键点是检查两个标识符是否相等。这是通过一个有趣的技巧完成的：宏定义了一个新的宏，然后立即使用它。我们看一下代码：
(@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 作为标识符时可能表现得很奇怪。有关该主题的更多信息，请参阅 this chapter。
使用 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!"),
}
}
将此 proc 宏与上面的 main() 示例一起使用完全相同。
注意：此处忽略了错误处理以使示例简短。请参阅 了解如何在 proc 宏中进行错误报告。
除此之外，我认为该代码不需要太多解释。此 proc 宏版本也不会像 macro_rules! 宏那样受到递归限制问题的困扰。
我正在尝试构建一个执行某些代码转换的宏，并且应该能够解析它自己的语法。 这是我能想到的最简单的例子：
replace!(x, y, x * 100 + z) ~> y * 100 + z
这个宏应该能够用作为第三个参数提供的表达式中的第二个标识符替换第一个标识符。宏应该对第三个参数的语言有一些了解（在我的特定情况下，与示例相反，不会在 Rust 中解析）并递归地应用它。
在 Rust 中构建这样一个宏的最有效方法是什么？我知道 proc_macro 方法和 macro_rules! 方法。但是我不确定 macro_rules! 是否足够强大来处理这个问题，而且我找不到很多关于如何使用 proc_macro 构建我自己的转换的文档。谁能指出我正确的方向？
使用 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",
下推积累在this chapter of "The little book of Rust macros"中有很好的描述。重要的部分是：
All macros in Rust must result in a complete, supported syntax element (such as an expression, item, etc.). This means that it is impossible to have a macro expand to a partial construct.
但通常有必要获得部分结果，例如在使用某些输入处理令牌时。为了解决这个问题，基本上有一个 "out" 参数，它只是一个标记列表，随着每个递归宏调用而增长。这是可行的，因为宏输入可以是任意标记，而不必是有效的 Rust 构造。
此模式仅对作为 "incremental TT munchers" 工作的宏有意义，而我的解决方案正是这样做的。还有a chapter about this pattern in TLBORM.
第二个关键点是检查两个标识符是否相等。这是通过一个有趣的技巧完成的：宏定义了一个新的宏，然后立即使用它。我们看一下代码：
(@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作为标识符时可能表现得很奇怪。有关该主题的更多信息，请参阅 this chapter。
使用 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!"),
}
}
将此 proc 宏与上面的 main() 示例一起使用完全相同。
注意：此处忽略了错误处理以使示例简短。请参阅
除此之外，我认为该代码不需要太多解释。此 proc 宏版本也不会像 macro_rules! 宏那样受到递归限制问题的困扰。