Nested macro invocation doesn't follow proper scoping rules

[lilyball]

When one macro invokes another macro, it always looks up the nested macro from the point of the outer invocation, instead of from the point of the macro definition. I don't know if this is intentional.

Example:

fn main() {
    macro_rules! foo(
        () => (println!("outer"))
    );
    {
        macro_rules! bar(
            () => (foo!())
        );
        {
            macro_rules! foo(
                () => (println!("inner"))
            );
            bar!()
        }
    }
}

If these were functions, it would print outer, but instead it prints inner.

[huonw]

cc @jbclements

[jbclements]

Yes, this is definitely a bug. The bar! macro should expand into a use of the outer foo! macro, not the inner one; this otherwise subverts the definition of the bar! macro completely. Put differently, it violates the macro-writer's bill of rights (yes, that's a thing. though I may be mis-using the term).

The solution? Hygiene for macro names. One thing at a time...

@huonw , thanks for the cc: !

[frewsxcv]

@kballard Are you able to confirm if this is still valid with the latest Rust? Your original code block doesn't compile currently.

[lilyball]

@frewsxcv It's still broken. I just updated the original code block with something that compiles.

[Ryman]

I think this example is related:

macro_rules! foo {
    ($v:ident) => (
        let $v = 3;
        println!("{}", $v); // If you comment this then it's fine.
    );
}

fn main() {
    foo!(x);
    println!("{}", x);
}

[jbclements]

@Ryman No... I think that's a different problem. Can you file a separate issue for that, and send me mail when you're done? (BTW, be sure to include the expected and actual behavior when you do.)

[Ryman]

@jbclements Opened #26223

[steveklabnik]

Triage: same error today, in that it prints inner.

[steveklabnik]

Triage: macro_rules is not being worked on anymore, with macro as its replacement. Given that there's been no substantial comments since 2015, and it still reproduced in 2017, I don't believe this will be changed. Closing.

[petrochenkov]

This is expected behavior for macro_rules macros which are hygienic only for local variables and labels.

Macros 2.0 (macro) change this behavior and the example prints "outer".

#![feature(decl_macro)]

fn main() {
    macro foo{
        () => (println!("outer"))
    }
    {
        macro bar{
            () => (foo!())
        }
        {
            macro foo{
                () => (println!("inner"))
            }
            bar!()
        }
    }
}

Declarative macros 2.0 are deeply unstable and macro_rules is still the primary declarative macro system in Rust, so they are worked on in terms of both bugs and occasionally extensions.