Como faço para usar uma macro em arquivos de módulo?

Tenho dois módulos em arquivos separados dentro da mesma caixa, onde a caixa foi macro_rulesativada. Quero usar as macros definidas em um módulo em outro módulo.

// 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?

Atualmente, encontro o erro do compilador " macro undefined: 'my_macro'" ... o que faz sentido; o sistema macro é executado antes do sistema de módulo. Como faço para contornar isso?

Macros dentro da mesma caixa

#[macro_use]
mod foo {
    macro_rules! bar {
        () => ()
    }
}

bar!();    // works

Se você quiser usar a macro na mesma caixa, o módulo em que sua macro está definida precisa do atributo #[macro_use].

As macros só podem ser usadas depois de definidas. Isso significa que isso não funciona:

bar!();  // ERROR: cannot find macro `bar!` in this scope

#[macro_use]
mod foo {
    macro_rules! bar {
        () => ()
    }
}

Macros em caixas

Para usar sua macro_rules!macro de outras caixas, a própria macro precisa do atributo #[macro_export]. A caixa de importação pode então importar a macro via use crate_name::macro_name;.

Caixote util

#[macro_export]
macro_rules! foo {
    () => ()
}

Caixote user

use util::foo;

foo!();

Observe que as macros sempre vivem no nível superior de uma caixa; então, mesmo fooque estivesse dentro de um mod bar {}, a usercaixa ainda teria que escrever use util::foo;e não use util::bar::foo; .

Antes do Rust 2018, você tinha que importar macro de outras caixas adicionando o atributo #[macro_use]à extern crate util;instrução. Isso importaria todas as macros de util. Como alternativa, #[macro_use(cat, dog)]pode ser usado apenas para importar as macros cate dog. Esta sintaxe não deve ser mais necessária.

Mais informações estão disponíveis no capítulo The Rust Programming Language sobre macros .

Esta resposta está desatualizada no Rust 1.1.0-stable.

Você precisa adicionar #![macro_escape]no topo macros.rse incluí-lo usando mod macros;conforme mencionado no Guia de 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

Para referência futura,

$ rustc -v
rustc 0.13.0-dev (2790505c1 2014-11-03 14:17:26 +0000)

Adicionar #![macro_use]ao início do arquivo que contém macros fará com que todas as macros sejam puxadas para main.rs.

Por exemplo, vamos supor que este arquivo se chame node.rs:

#![macro_use]

macro_rules! test {
    () => { println!("Nuts"); }
}

macro_rules! best {
    () => { println!("Run"); }
}

pub fn fun_times() {
    println!("Is it really?");
}

Em algum momento, seu main.rs se pareceria com o seguinte:

mod node;  //We're using node.rs
mod toad;  //Also using toad.rs

fn main() {
    test!();
    best!();
    toad::a_thing();
}

Finalmente, digamos que você tenha um arquivo chamado toad.rs que também requer estas macros:

use node; //Notice this is 'use' not 'mod'

pub fn a_thing() {
  test!();

  node::fun_times();
}

Observe que, uma vez que os arquivos são puxados para main.rs com mod, o restante dos seus arquivos tem acesso a eles por meio da usepalavra - chave.

Eu me deparei com o mesmo problema no Rust 1.44.1, e esta solução funciona para versões posteriores (funcionamento conhecido para o Rust 1.7).

Digamos que você tenha um novo projeto como:

src/
    main.rs
    memory.rs
    chunk.rs

Em main.rs , você precisa anotar que está importando macros da fonte, caso contrário, não servirá para você.

#[macro_use]
mod memory;
mod chunk;

fn main() {
    println!("Hello, world!");
}

Portanto, em memory.rs você pode definir as macros e não precisa de anotações:

macro_rules! grow_capacity {
    ( $x:expr ) => {
        {
            if $x < 8 { 8 } else { $x * 2 }
        }
    };
}

Por fim, você pode usá-lo em chunk.rs e não precisa incluir a macro aqui, porque é feito em main.rs:

grow_capacity!(8);

A resposta votada causou confusão para mim, com este documento por exemplo , seria útil também.