Macros 2.0: macro defined and used in same function-like scope can't resolve its own items

[arielb1]

Maybe this is just a misunderstanding of hygiene, but if a macro 2.0 is defined and used in the same function-like scope (function/const) then it can't resolve its own items:

#![feature(decl_macro)]

trait Tr { fn foo(self); }

const C: () = {
    macro implit {
        () => {
            fn doit() { println!("Hi"); }
            impl ::Tr for () {
                fn foo(self) {
                    doit();
                }
            }
        }
    }
    
    
    #[cfg(works)]
    const T: () = { implit!(); () }; // this works with no error
    
    #[cfg(not(works))]
    implit!(); //~ ERROR cannot find function `doit` in this scope
};

fn main() {
    ().foo();
}

Expected Result

doit() should resolve to the fn doit in the scope of the macro, printing Hi!

Actual Result

Resolution error.

Note that

1. Having the macro defined and used in a module (i.e., if const C: () was a mod _xyz) does work.
2. Having the macro defined in 1 function-like scope, and used in a child scope of it (see cfg(works)) also works. This error only occurs if the macro is defined and used in the same scope.

cc @petrochenkov @nrc

[petrochenkov]

Looks like a bug rather than misunderstanding.

[lcnr]

similar issue:

#![feature(decl_macro)]

struct FromMacro;
pub macro fun_with_macros() {
    fn my_function() -> FromMacro { FromMacro }

    fn uses_from_macro() {
        let FromMacro = Self::my_function();
    }
}

struct LocalStruct;
struct NoMacro;
impl LocalStruct {
    fun_with_macros!();

    fn my_function() -> NoMacro { NoMacro }

    fn doesnt_use_macro() {
        let NoMacro = Self::my_function();
    }
}

This currently errors because my_function in uses_from_macro is the my_function returning NoMacro.

I believe that hygiene for impl items seems generally undesirable but that seems unrelated to this bug and without having spent too much time on hygiene or decl macros, so 🤷