resolve: Split Scope::Module into two scopes for non-glob and glob bindings

petrochenkov · petrochenkov · commit 38812a3dcbf1 · 2025-12-06T17:38:34.000+03:00
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1205,9 +1205,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         }
                     }
                 }
-                Scope::Module(module, _) => {
+                Scope::ModuleNonGlobs(module, _) => {
                     this.add_module_candidates(module, suggestions, filter_fn, None);
                 }
+                Scope::ModuleGlobs(..) => {
+                    // Already handled in `ModuleNonGlobs`.
+                }
                 Scope::MacroUsePrelude => {
                     suggestions.extend(this.macro_use_prelude.iter().filter_map(
                         |(name, binding)| {
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
@@ -127,9 +127,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let module_and_extern_prelude = matches!(scope_set, ScopeSet::ModuleAndExternPrelude(..));
         let extern_prelude = matches!(scope_set, ScopeSet::ExternPrelude);
         let mut scope = match ns {
-            _ if module_and_extern_prelude => Scope::Module(module, None),
+            _ if module_and_extern_prelude => Scope::ModuleNonGlobs(module, None),
             _ if extern_prelude => Scope::ExternPreludeItems,
-            TypeNS | ValueNS => Scope::Module(module, None),
+            TypeNS | ValueNS => Scope::ModuleNonGlobs(module, None),
             MacroNS => Scope::DeriveHelpers(parent_scope.expansion),
         };
         let mut ctxt = ctxt.normalize_to_macros_2_0();
@@ -156,7 +156,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     }
                     true
                 }
-                Scope::Module(..) => true,
+                Scope::ModuleNonGlobs(..) | Scope::ModuleGlobs(..) => true,
                 Scope::MacroUsePrelude => use_prelude || rust_2015,
                 Scope::BuiltinAttrs => true,
                 Scope::ExternPreludeItems | Scope::ExternPreludeFlags => {
@@ -197,20 +197,21 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     MacroRulesScope::Invocation(invoc_id) => {
                         Scope::MacroRules(self.invocation_parent_scopes[&invoc_id].macro_rules)
                     }
-                    MacroRulesScope::Empty => Scope::Module(module, None),
+                    MacroRulesScope::Empty => Scope::ModuleNonGlobs(module, None),
                 },
-                Scope::Module(..) if module_and_extern_prelude => match ns {
+                Scope::ModuleNonGlobs(module, lint_id) => Scope::ModuleGlobs(module, lint_id),
+                Scope::ModuleGlobs(..) if module_and_extern_prelude => match ns {
                     TypeNS => {
                         ctxt.adjust(ExpnId::root());
                         Scope::ExternPreludeItems
                     }
                     ValueNS | MacroNS => break,
                 },
-                Scope::Module(module, prev_lint_id) => {
+                Scope::ModuleGlobs(module, prev_lint_id) => {
                     use_prelude = !module.no_implicit_prelude;
                     match self.hygienic_lexical_parent(module, &mut ctxt, derive_fallback_lint_id) {
                         Some((parent_module, lint_id)) => {
-                            Scope::Module(parent_module, lint_id.or(prev_lint_id))
+                            Scope::ModuleNonGlobs(parent_module, lint_id.or(prev_lint_id))
                         }
                         None => {
                             ctxt.adjust(ExpnId::root());
@@ -584,7 +585,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 MacroRulesScope::Invocation(_) => Err(Determinacy::Undetermined),
                 _ => Err(Determinacy::Determined),
             },
-            Scope::Module(module, derive_fallback_lint_id) => {
+            Scope::ModuleNonGlobs(module, derive_fallback_lint_id) => {
                 let (adjusted_parent_scope, adjusted_finalize) =
                     if matches!(scope_set, ScopeSet::ModuleAndExternPrelude(..)) {
                         (parent_scope, finalize)
@@ -594,7 +595,58 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             finalize.map(|f| Finalize { used: Used::Scope, ..f }),
                         )
                     };
-                let binding = self.reborrow().resolve_ident_in_module_unadjusted(
+                let binding = self.reborrow().resolve_ident_in_module_non_globs_unadjusted(
+                    module,
+                    ident,
+                    ns,
+                    adjusted_parent_scope,
+                    Shadowing::Restricted,
+                    adjusted_finalize,
+                    ignore_binding,
+                    ignore_import,
+                );
+                match binding {
+                    Ok(binding) => {
+                        if let Some(lint_id) = derive_fallback_lint_id {
+                            self.get_mut().lint_buffer.buffer_lint(
+                                PROC_MACRO_DERIVE_RESOLUTION_FALLBACK,
+                                lint_id,
+                                orig_ident.span,
+                                errors::ProcMacroDeriveResolutionFallback {
+                                    span: orig_ident.span,
+                                    ns_descr: ns.descr(),
+                                    ident,
+                                },
+                            );
+                        }
+                        let misc_flags = if module == self.graph_root {
+                            Flags::MISC_SUGGEST_CRATE
+                        } else if module.is_normal() {
+                            Flags::MISC_SUGGEST_SELF
+                        } else {
+                            Flags::empty()
+                        };
+                        Ok((binding, Flags::MODULE | misc_flags))
+                    }
+                    Err(ControlFlow::Continue(determinacy)) => Err(determinacy),
+                    Err(ControlFlow::Break(Determinacy::Undetermined)) => {
+                        return Err(ControlFlow::Break(Determinacy::determined(force)));
+                    }
+                    // Privacy errors, do not happen during in scope resolution.
+                    Err(ControlFlow::Break(Determinacy::Determined)) => unreachable!(),
+                }
+            }
+            Scope::ModuleGlobs(module, derive_fallback_lint_id) => {
+                let (adjusted_parent_scope, adjusted_finalize) =
+                    if matches!(scope_set, ScopeSet::ModuleAndExternPrelude(..)) {
+                        (parent_scope, finalize)
+                    } else {
+                        (
+                            &ParentScope { module, ..*parent_scope },
+                            finalize.map(|f| Finalize { used: Used::Scope, ..f }),
+                        )
+                    };
+                let binding = self.reborrow().resolve_ident_in_module_globs_unadjusted(
                     module,
                     ident,
                     ns,
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
@@ -122,10 +122,14 @@ enum Scope<'ra> {
     DeriveHelpersCompat,
     /// Textual `let`-like scopes introduced by `macro_rules!` items.
     MacroRules(MacroRulesScopeRef<'ra>),
-    /// Names declared in the given module.
+    /// Non-glob names declared in the given module.
     /// The node ID is for reporting the `PROC_MACRO_DERIVE_RESOLUTION_FALLBACK`
     /// lint if it should be reported.
-    Module(Module<'ra>, Option<NodeId>),
+    ModuleNonGlobs(Module<'ra>, Option<NodeId>),
+    /// Glob names declared in the given module.
+    /// The node ID is for reporting the `PROC_MACRO_DERIVE_RESOLUTION_FALLBACK`
+    /// lint if it should be reported.
+    ModuleGlobs(Module<'ra>, Option<NodeId>),
     /// Names introduced by `#[macro_use]` attributes on `extern crate` items.
     MacroUsePrelude,
     /// Built-in attributes.
@@ -1898,9 +1902,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let scope_set = ScopeSet::All(TypeNS);
         self.cm().visit_scopes(scope_set, parent_scope, ctxt, None, |this, scope, _, _| {
             match scope {
-                Scope::Module(module, _) => {
+                Scope::ModuleNonGlobs(module, _) => {
                     this.get_mut().traits_in_module(module, assoc_item, &mut found_traits);
                 }
+                Scope::ModuleGlobs(..) => {
+                    // Already handled in `ModuleNonGlobs` (but see #144993).
+                }
                 Scope::StdLibPrelude => {
                     if let Some(module) = this.prelude {
                         this.get_mut().traits_in_module(module, assoc_item, &mut found_traits);
diff --git a/tests/ui/imports/issue-114682-1.rs b/tests/ui/imports/issue-114682-1.rs
@@ -22,4 +22,5 @@ mac!();
 fn main() {
     A!();
     //~^ ERROR `A` is ambiguous
+    //~| ERROR `A` is ambiguous
 }
diff --git a/tests/ui/imports/issue-114682-1.stderr b/tests/ui/imports/issue-114682-1.stderr
@@ -23,6 +23,32 @@ LL | pub use m::*;
    = help: consider adding an explicit import of `A` to disambiguate
    = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 1 previous error
+error[E0659]: `A` is ambiguous
+  --> $DIR/issue-114682-1.rs:23:5
+   |
+LL |     A!();
+   |     ^ ambiguous name
+   |
+   = note: ambiguous because of a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution
+note: `A` could refer to the macro defined here
+  --> $DIR/issue-114682-1.rs:7:9
+   |
+LL | /         pub macro A() {
+LL | |             println!("non import")
+LL | |         }
+   | |_________^
+...
+LL |   mac!();
+   |   ------ in this macro invocation
+   = help: use `crate::A` to refer to this macro unambiguously
+note: `A` could also refer to the macro imported here
+  --> $DIR/issue-114682-1.rs:19:9
+   |
+LL | pub use m::*;
+   |         ^^^^
+   = help: use `crate::A` to refer to this macro unambiguously
+   = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/local-modularized-tricky-fail-1.rs b/tests/ui/imports/local-modularized-tricky-fail-1.rs
@@ -27,6 +27,7 @@ mod inner1 {
 }
 
 exported!(); //~ ERROR `exported` is ambiguous
+             //~| ERROR `exported` is ambiguous
 
 mod inner2 {
     define_exported!();
diff --git a/tests/ui/imports/local-modularized-tricky-fail-1.stderr b/tests/ui/imports/local-modularized-tricky-fail-1.stderr
@@ -23,8 +23,34 @@ LL | use inner1::*;
    = help: consider adding an explicit import of `exported` to disambiguate
    = note: this error originates in the macro `define_exported` (in Nightly builds, run with -Z macro-backtrace for more info)
 
+error[E0659]: `exported` is ambiguous
+  --> $DIR/local-modularized-tricky-fail-1.rs:29:1
+   |
+LL | exported!();
+   | ^^^^^^^^ ambiguous name
+   |
+   = note: ambiguous because of a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution
+note: `exported` could refer to the macro defined here
+  --> $DIR/local-modularized-tricky-fail-1.rs:6:5
+   |
+LL | /     macro_rules! exported {
+LL | |         () => ()
+LL | |     }
+   | |_____^
+...
+LL |       define_exported!();
+   |       ------------------ in this macro invocation
+   = help: use `crate::exported` to refer to this macro unambiguously
+note: `exported` could also refer to the macro imported here
+  --> $DIR/local-modularized-tricky-fail-1.rs:23:5
+   |
+LL | use inner1::*;
+   |     ^^^^^^^^^
+   = help: use `crate::exported` to refer to this macro unambiguously
+   = note: this error originates in the macro `define_exported` (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error[E0659]: `panic` is ambiguous
-  --> $DIR/local-modularized-tricky-fail-1.rs:36:5
+  --> $DIR/local-modularized-tricky-fail-1.rs:37:5
    |
 LL |     panic!();
    |     ^^^^^ ambiguous name
@@ -45,7 +71,7 @@ LL |       define_panic!();
    = note: this error originates in the macro `define_panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0659]: `include` is ambiguous
-  --> $DIR/local-modularized-tricky-fail-1.rs:47:1
+  --> $DIR/local-modularized-tricky-fail-1.rs:48:1
    |
 LL | include!();
    | ^^^^^^^ ambiguous name
@@ -65,6 +91,6 @@ LL |       define_include!();
    = help: use `crate::include` to refer to this macro unambiguously
    = note: this error originates in the macro `define_include` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/imports/macro-paths.rs b/tests/ui/imports/macro-paths.rs
@@ -11,6 +11,7 @@ mod foo {
 fn f() {
     use foo::*;
     bar::m! { //~ ERROR ambiguous
+              //~| ERROR `bar` is ambiguous
         mod bar { pub use two_macros::m; }
     }
 }
diff --git a/tests/ui/imports/macro-paths.stderr b/tests/ui/imports/macro-paths.stderr
@@ -6,7 +6,7 @@ LL |     bar::m! {
    |
    = note: ambiguous because of a conflict between a name from a glob import and a macro-expanded name in the same module during import or macro resolution
 note: `bar` could refer to the module defined here
-  --> $DIR/macro-paths.rs:14:9
+  --> $DIR/macro-paths.rs:15:9
    |
 LL |         mod bar { pub use two_macros::m; }
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,27 +17,45 @@ LL |     use foo::*;
    |         ^^^^^^
    = help: consider adding an explicit import of `bar` to disambiguate
 
+error[E0659]: `bar` is ambiguous
+  --> $DIR/macro-paths.rs:13:5
+   |
+LL |     bar::m! {
+   |     ^^^ ambiguous name
+   |
+   = note: ambiguous because of a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution
+note: `bar` could refer to the module defined here
+  --> $DIR/macro-paths.rs:15:9
+   |
+LL |         mod bar { pub use two_macros::m; }
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: `bar` could also refer to the module imported here
+  --> $DIR/macro-paths.rs:12:9
+   |
+LL |     use foo::*;
+   |         ^^^^^^
+
 error[E0659]: `baz` is ambiguous
-  --> $DIR/macro-paths.rs:23:5
+  --> $DIR/macro-paths.rs:24:5
    |
 LL |     baz::m! {
    |     ^^^ ambiguous name
    |
    = note: ambiguous because of a conflict between a macro-expanded name and a less macro-expanded name from outer scope during import or macro resolution
 note: `baz` could refer to the module defined here
-  --> $DIR/macro-paths.rs:24:9
+  --> $DIR/macro-paths.rs:25:9
    |
 LL |         mod baz { pub use two_macros::m; }
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: `baz` could also refer to the module defined here
-  --> $DIR/macro-paths.rs:18:1
+  --> $DIR/macro-paths.rs:19:1
    |
 LL | / pub mod baz {
 LL | |     pub use two_macros::m;
 LL | | }
    | |_^
    = help: use `crate::baz` to refer to this module unambiguously
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0659`.

Original file line number	Diff line number	Diff line change
`@@ -1205,9 +1205,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {`
`1205`	`1205`	`}`
`1206`	`1206`	`}`
`1207`	`1207`	`}`
`1208`		`- Scope::Module(module, _) => {`
	`1208`	`+ Scope::ModuleNonGlobs(module, _) => {`
`1209`	`1209`	`this.add_module_candidates(module, suggestions, filter_fn, None);`
`1210`	`1210`	`}`
	`1211`	`+ Scope::ModuleGlobs(..) => {`
	`1212`	+ // Already handled in `ModuleNonGlobs`.
	`1213`	`+ }`
`1211`	`1214`	`Scope::MacroUsePrelude => {`
`1212`	`1215`	`suggestions.extend(this.macro_use_prelude.iter().filter_map(`
`1213`	`1216`	`\|(name, binding)\| {`
Original file line number	Diff line number	Diff line change
`@@ -22,4 +22,5 @@ mac!();`
`22`	`22`	`fn main() {`
`23`	`23`	`A!();`
`24`	`24`	//~^ ERROR `A` is ambiguous
	`25`	+ //~\| ERROR `A` is ambiguous
`25`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@ mod inner1 {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	exported!(); //~ ERROR `exported` is ambiguous
	`30`	+ //~\| ERROR `exported` is ambiguous
`30`	`31`
`31`	`32`	`mod inner2 {`
`32`	`33`	`define_exported!();`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ mod foo {`
`11`	`11`	`fn f() {`
`12`	`12`	`use foo::*;`
`13`	`13`	`bar::m! { //~ ERROR ambiguous`
	`14`	+ //~\| ERROR `bar` is ambiguous
`14`	`15`	`mod bar { pub use two_macros::m; }`
`15`	`16`	`}`
`16`	`17`	`}`