我在同一个 crate 的不同文件中有两个模块，crate 启用了 macro_rules。我想在一个模块中使用另一个模块定义的宏。
// macros.rs
#[macro_export] // or not? is ineffectual for this, afaik
macro_rules! my_macro(...)
// something.rs
use macros;
// use macros::my_macro; <-- unresolved import (for obvious reasons)
my_macro!() // <-- how?
我现在遇到了编译错误 "macro undefined: 'my_macro'"... 这很有道理；宏系统在模块系统之前运行。我该如何解决这个问题？
foo::bar!(); // works
mod foo {
macro_rules! bar {
() => ()
}
pub(crate) use bar; // <-- the trick
}
foo::bar!(); // works
使用pub use后，宏可以像任何其他项一样被使用和导入。与旧方法不同的是，这不依赖于源代码顺序，因此您可以在定义宏之前（源代码顺序）使用它。
bar!(); // Does not work! Relies on source code order!
#[macro_use]
mod foo {
macro_rules! bar {
() => ()
}
}
bar!(); // works
如果你想在同一个crate中使用宏，你需要为定义宏的模块添加属性#[macro_use]。请注意，宏只能在已经定义之后使用！
Crate util
#[macro_export]
macro_rules! foo {
() => ()
}
用户
use util::foo;
foo!();
foo 在 mod bar {} 内部，user crate 仍然必须编写 use util::foo; 而不是 use util::bar::foo;。通过使用 pub use，您可以从您的crate的模块中导出一个宏（除了在根目录下导出之外）。#[macro_use] 添加到 extern crate util; 语句，以从其他crate中导入宏。那样会导入 util 的所有宏。现在应该不再需要这种语法。#[macro_use]属性，一直到需要使用它的那个地方。 - Ten#[macro_use]，并且在lib.rs中首先声明 - 仍然不起作用。@Ten的答案有所帮助，我在lib.rs的顶部添加了#[macro_use] - 然后它就起作用了。但我仍然不确定最佳实践是什么，因为我在这里读到“您不应从其他模块导入宏；您应该从定义模块导出宏”。 - Sorin Bolos1.32.0（2018版）的备选方案请注意，虽然@lukas-kalbertodt提供的指南仍然是最新的且有效，但是对于一些人来说，必须记住宏的特殊命名空间规则可能很烦人。
从2018版开始，在Rust的版本1.32.0及以上，有另一种方法同样有效，并且在我看来有一个好处，即更容易教授（例如，它使#[macro_use]过时）。关键思想如下：
重新导出的宏与任何其他项（函数、类型、常量等）行为相同：它在重新导出发生的模块中命名空间。
然后可以使用完全限定路径引用它。
也可以本地使用/引入范围，以无资格方式引用它。
macro_rules! macro_name { ... }
pub(crate) use macro_name; // Now classic paths Just Work™
请随意继续阅读，只有当你不怕信息过载时 ;) 我会详细解释为什么、如何以及何时会起作用。
为了重新导出 (pub(...) use ...) 一个宏，我们需要引用它！这就是原回答中提到的规则有用的地方：一个宏总是可以在定义它的模块内部命名，但只有在那个定义之后才能这样做。
macro_rules! my_macro { ... }
my_macro!(...); // OK
// Not OK
my_macro!(...); /* Error, no `my_macro` in scope! */
macro_rules! my_macro { ... }
In the same fashion that we can do:
struct Foo {}
fn main() {
let _: Foo;
}
We can also do:
fn main() {
let _: A;
}
struct Foo {}
use Foo as A;
The same applies to other items, such as functions, but also to macros!
fn main() {
a!();
}
macro_rules! foo { ... } // foo is only nameable *from now on*
use foo as a; // but `a` is now visible all around the module scope!
And it turns out that we can write use foo as foo;, or the common use foo; shorthand, and it still works.
pub(crate)还是pub？
对于被#[macro_export]宏导出的宏，您可以使用任何您想要的可见性，通常为pub。
对于其他macro_rules!宏，您不能超过pub(crate)。
#[macro_export]ed macromod foo {
use super::example::my_macro;
my_macro!(...); // OK
}
mod example {
macro_rules! my_macro { ... }
pub(crate) use my_macro;
}
example::my_macro!(...); // OK
#[macro_export]-ed macroApplying #[macro_export] on a macro definition makes it visible after the very module where it is defined (so as to be consistent with the behavior of non-#[macro_export]ed macros), but it also puts the macro at the root of the crate (where the macro is defined), in an absolute path fashion.
This means that a pub use macro_name; right after the macro definition, or a pub use crate::macro_name; in any module of that crate will work.
pub mod example {
#[macro_export] // macro nameable at `crate::my_macro`
macro_rules! my_macro { ... }
pub use my_macro; // macro nameable at `crate::example::my_macro`
}
pub mod foo {
pub use crate::my_macro; // macro nameable at `crate::foo::my_macro`
}
pub / pub(crate) use macro_name;时，请注意由于Rust中命名空间的工作方式，您可能还会重新导出常量/函数或类型/模块。这也会导致全局可用的宏（例如#[test]，#[allow(...)]，#[warn(...)]等）存在问题。macro_rules! __test__ { ... }
pub(crate) use __test__ as test; // OK
macro_rules! __warn__ { ... }
pub(crate) use __warn__ as warn; // OK
此外，一些误报的lint可能会触发：
来自过于敏感的clippy工具，当以任何方式执行此技巧时；
来自rustc本身，当在函数体内部定义macro_rules!时执行此操作：https://github.com/rust-lang/rust/issues/78894
a :: b中有一个宏，则无需＃[macro_export]即可在模块 c中使用它）。这是因为c无法声明mod a :: b，而且#[macro_use]不能与诸如use super :: a :: b之类的use语句一起使用。 - Lauren Yimsome_name::some_module::some_macro! 这样。但如果我定义了 macro_rules! some_macro { ... }，然后 pub use some_macro; 编译器会告诉我 some_macro 是私有的。我可以使用答案中展示的 pub(crate)，但那样它就只对该箱子是公开的，只能使用完整路径从该箱子调用。有没有办法可以通过完整路径从另一个箱子调用它？ - user4815162342#[macro_export]的宏的内在可见性最多是pub(crate)。因此，您需要将您的宏标记为#[macro_export]，尽管这将使其出现在crate的根目录中。对于这个“也在crate的根目录中”的问题，没有简单的解决方法，但可以使用文档技巧来隐藏它，或者使用额外的外部帮助器crate（例如在https://crates.io/crates/konst/0.2.4/dependencies中的`konst_macro_rules`中）。 - Daniel H-M截至 Rust 1.1.0-stable，本答案已过时。
您需要在 macros.rs 文件顶部添加 #![macro_escape]，并按照“宏指南”中的说明使用 mod macros; 进行包含。
$ cat macros.rs
#![macro_escape]
#[macro_export]
macro_rules! my_macro {
() => { println!("hi"); }
}
$ cat something.rs
#![feature(macro_rules)]
mod macros;
fn main() {
my_macro!();
}
$ rustc something.rs
$ ./something
hi
供参考，
$ rustc -v
rustc 0.13.0-dev (2790505c1 2014-11-03 14:17:26 +0000)
#[macro_export]属性。只有当宏应该被导出给外部 crate 的用户时才需要使用它。如果宏仅在 crate 内部使用，则不需要使用#[macro_export]。 - Vladimir Matveevsomething.rs 文件使用其他模块，例如 mod foobar;，并且这个 foobar 模块使用了 macro.rs 中的宏，则必须在 mod foobar; 之前放置 mod macro; 才能使程序编译通过。虽然这只是一个小问题，但在我看来并不明显。 - conradkleinespel在包含宏定义的文件顶部添加#![macro_use]将导致所有宏都被引入到main.rs中。
例如，假设这个文件名为node.rs：
#![macro_use]
macro_rules! test {
() => { println!("Nuts"); }
}
macro_rules! best {
() => { println!("Run"); }
}
pub fn fun_times() {
println!("Is it really?");
}
您的 main.rs 文件可能如下所示：
mod node; //We're using node.rs
mod toad; //Also using toad.rs
fn main() {
test!();
best!();
toad::a_thing();
}
最后假设你有一个名为toad.rs的文件，它也需要这些宏：
use node; //Notice this is 'use' not 'mod'
pub fn a_thing() {
test!();
node::fun_times();
}
请注意，一旦使用mod将文件引入到main.rs中，剩下的文件通过use关键字可以访问它们。
#![macro_use] 声明在宏模块内部而不是外部。#![...] 语法表示属性适用于包含它们的作用域，例如 #![feature(...)]（显然如果写成 #[feature(...)] 就没有意义了；它会在语义上要求编译器在创建特定项时启用某些功能，而不是整个根 crate）。所以，正如 @LukeDupin 所说，模块系统是一团糟，尽管可能出现的原因与首次看到的不同。 - usermod node; 这一行出现在 mod toad; 之前。使用 rustfmt 时要小心，因为它可能会按字典顺序重新排列这些行。对我来说，解决方法是在这些行之间加入一个空白的新行。 - Sebastian我在 Rust 1.44.1 中 遇到了同样的问题，而这个解决方案适用于后续版本（已知可用于 Rust 1.7）。
假设您有一个新项目：
src/
main.rs
memory.rs
chunk.rs
#[macro_use]
mod memory;
mod chunk;
fn main() {
println!("Hello, world!");
}
因此，在 memory.rs 中，您可以定义宏，而不需要注释：
macro_rules! grow_capacity {
( $x:expr ) => {
{
if $x < 8 { 8 } else { $x * 2 }
}
};
}
最后，您可以在 chunk.rs 中使用它，您不需要在此处包含宏，因为它已在 main.rs 中完成：
grow_capacity!(8);
main.rs/lib.rs 中声明 mod 的顺序很重要，在宏模块声明之后声明的所有模块都将无法成功调用该宏。#[macro_use]。编译器没有报错说它被放错了地方。 - knh190mod { ... } 和 mod some_file 是相同的并且都创建了一个模块感到困惑。已经有一个被接受的答案展示了 #[macro_use] 的用法，所以_这个_答案并没有提供任何新的东西。 - Shepmastermain.rs 中正确使用 mod 的顺序。如果你写成了 mod chunk; mod memory;，那么在 memory.rs 中的宏调用将会失败。 - ineitipub (crate)和#[macro_use]中使用，并且值得注意的是您永远不需要在其他文件中包含宏。 - Sasha Kondrashov
module::my_macro!()吗？ - u_mulder