Auto merge of #121589 - bvanjoi:fix-98291, r=<try>

try to resolve under eager expander

Fixes #98291

I will attempt to clarify the root problem through several examples:

Firstly,

```rs
// rustc code.rs --edition=2018

macro_rules! wrap {
    () => {
        macro_rules! _a {
            () => {
                "Hello world"
            };
        }
    };
}

wrap!();

use _a as a;

fn main() {
    format_args!(_a!());
}
```

The above case will compile successfully because `_a` is defined after the `wrap` expaned, ensuring `_a` can be resolved without any issues.

And,

```rs
// rustc code.rs --edition=2018

macro_rules! wrap {
    () => {
        macro_rules! _a {
            () => {
                "Hello world"
            };
        }
    };
}

wrap!();

use _a as a;

fn main() {
    format_args!("{}", a!());
}
```

The above example will also compile successfully because the `parse_args` in `expand_format_args_impl` will return a value `MacroInput { fmtstr: Expr::Lit::Str, args: [Expr::MacroCall]}`. Since the graph for `args` will be build lately, `a` will eventually be resolved.

However, in the case of:

```rs
// rustc code.rs --edition=2018

macro_rules! wrap {
    () => {
        macro_rules! _a {
            () => {
                "Hello world"
            };
        }
    };
}

wrap!();

use _a as a;

fn main() {
    format_args!(a!());
}
```

The result of `parse_args` is `MacroInput {fmtstr: Expr::Lit::Macro, args: [] }`, we attempt to expand `fmtstr` **eagerly** within `expr_to_spanned_string`. Although we have recorded `(root, _a)` into resolutions, `use _a as a` is an indeterminate import, which will not try to resolve under the conditions of `expander.monotonic = false`.

Therefore, I've altered the strategy for resolving indeterminate imports, ensuring it will also resolve during eager expansion. This could be a significant change to the resolution infra. However, I think it's acceptable if the goal of avoiding resolution under eager expansion is to save time.

r? `@petrochenkov`

Author: bors

compiler/rustc_builtin_macros/src/format.rs

@@ -40,6 +40,7 @@ use PositionUsedAs::*;
 
 use crate::errors;
 
+#[derive(Debug)]
 struct MacroInput {
     fmtstr: P<Expr>,
     args: FormatArguments,

compiler/rustc_expand/src/expand.rs

@@ -549,9 +549,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
     }
 
     fn resolve_imports(&mut self) {
-        if self.monotonic {
-            self.cx.resolver.resolve_imports();
-        }
+        self.cx.resolver.resolve_imports();
     }
 
     /// Collects all macro invocations reachable at this time in this AST fragment, and replace

tests/ui/macros/expand-full-in-format-str.rs

@@ -0,0 +1,22 @@
+//@check-pass
+//@edition: 2018
+
+// https://github.com/rust-lang/rust/issues/98291
+
+macro_rules! wrap {
+    () => {
+        macro_rules! _a {
+            () => {
+                "Hello world"
+            };
+        }
+    };
+}
+
+wrap!();
+
+use _a as a;
+
+fn main() {
+    format_args!(a!());
+}