`macro_rules!` emitted by a path-qualified cross-crate call is not added to textual scope

rust-analyzer version: 1.100.0-nightly (9085017 2026-08-30) (also 1.98.0, 1.99.0-beta.3)

rustc version: 1.98.0 (88d9e12ae 2026-08-18)

editor or extension: Cursor v3.18.9, Extension version 0.4.3032 (Pre-release, same with release)

relevant settings: None

The issue

Crate generator exports a macro that expands to a macro_rules! foo definition. When a consumer invokes that generator by qualified path (generator::gen_foo!(...)), rust-analyzer expands the generator but never registers the generated foo in the module's textual scope, so every later foo!(...) is unresolved macro. rustc resolves it and the code runs.

Invoking the same generator unqualified via #[macro_use] extern crate generator; works in rust-analyzer. So this is not nested macro_rules! in general, and not a rustc/rust-analyzer hygiene disagreement, it is specific to the qualified call form.

Reproducing code

Workspace with three crates. consumer_qualified and consumer_macro_use differ only in how they invoke gen_foo!.

[workspace]
resolver = "3"
members = ["generator", "consumer_qualified", "consumer_macro_use"]

[package]
name = "generator"
version = "0.0.0"
edition = "2024"

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

[package]
name = "consumer_qualified"
version = "0.0.0"
edition = "2024"
[dependencies]
generator = { path = "../generator" }

generator::gen_foo!();

#[macro_use]
mod inner;
pub fn call() -> u32 {
    foo!()
}

#[cfg(test)]
mod tests {
    #[test]
    fn generated_macro_runs() {
        assert_eq!(super::call(), 42);
    }
}

[package]
name = "consumer_macro_use"
version = "0.0.0"
edition = "2024"
[dependencies]
generator = { path = "../generator" }

gen_foo!();

#[macro_use]
extern crate generator;
#[macro_use]
mod inner;
pub fn call() -> u32 {
    foo!()
}

#[cfg(test)]
mod tests {
    #[test]
    fn generated_macro_runs() {
        assert_eq!(super::call(), 42);
    }
}

Expected behavior

Both consumers behave the same since both compile and pass the tests

Actual

In the IDE, consumer_qualified call() is marked as error expected u32, found () (which is the consequence of the not expanded macro).
When running rust-analyzer diagnostics . it produces diagnostics (filtered):

consumer_qualified/src/lib.rs: unresolved-macro-call: unresolved macro `foo!`
consumer_qualified/src/lib.rs: E0308: expected u32, found ()

while silent about consumer_macro_use.