work around prelude hack

Author: LorrensP-2158466

compiler/rustc_resolve/src/diagnostics.rs

@@ -1112,7 +1112,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     );
                 }
                 Scope::StdLibPrelude => {
-                    if let Some(prelude) = this.prelude {
+                    if let Some(prelude) = this.prelude.get() {
                         let mut tmp_suggestions = Vec::new();
                         this.add_module_candidates(prelude, &mut tmp_suggestions, filter_fn, None);
                         suggestions.extend(

compiler/rustc_resolve/src/ident.rs

@@ -575,7 +575,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     },
                     Scope::StdLibPrelude => {
                         let mut result = Err(Determinacy::Determined);
-                        if let Some(prelude) = this.prelude
+                        if let Some(prelude) = this.prelude.get()
                             && let Ok(binding) = this.reborrow().resolve_ident_in_module_unadjusted(
                                 ModuleOrUniformRoot::Module(prelude),
                                 ident,

compiler/rustc_resolve/src/imports.rs

@@ -48,14 +48,16 @@ pub(crate) struct ImportResolver<'r, 'ra, 'tcx> {
 
     // outputs
     determined_imports: Vec<Import<'ra>>,
-    glob_imports: Vec<Import<'ra>>,
+    glob_import_outputs: Vec<(Module<'ra>, BindingKey, NameBinding<'ra>, bool)>,
+    glob_res_outputs: Vec<(NodeId, PartialRes)>,
     import_bindings: PerNS<Vec<(Module<'ra>, Import<'ra>, PendingBinding<'ra>)>>,
 }
 
 struct ImportResolutionOutputs<'ra> {
     indeterminate_imports: Vec<Import<'ra>>,
     determined_imports: Vec<Import<'ra>>,
-    glob_imports: Vec<Import<'ra>>,
+    glob_import_outputs: Vec<(Module<'ra>, BindingKey, NameBinding<'ra>, bool)>,
+    glob_res_outputs: Vec<(NodeId, PartialRes)>,
     import_bindings: PerNS<Vec<(Module<'ra>, Import<'ra>, PendingBinding<'ra>)>>,
 }
 
@@ -65,17 +67,19 @@ impl<'r, 'ra, 'tcx> ImportResolver<'r, 'ra, 'tcx> {
             r: cmr,
             batch,
             determined_imports: Vec::new(),
-            glob_imports: Vec::new(),
             import_bindings: PerNS::default(),
+            glob_import_outputs: Vec::new(),
+            glob_res_outputs: Vec::new(),
         }
     }
 
     fn into_outputs(self) -> ImportResolutionOutputs<'ra> {
         ImportResolutionOutputs {
             indeterminate_imports: self.batch,
             determined_imports: self.determined_imports,
-            glob_imports: self.glob_imports,
             import_bindings: self.import_bindings,
+            glob_import_outputs: self.glob_import_outputs,
+            glob_res_outputs: self.glob_res_outputs,
         }
     }
 }
@@ -85,8 +89,12 @@ impl<'ra> ImportResolutionOutputs<'ra> {
         r.indeterminate_imports = self.indeterminate_imports;
         r.determined_imports.extend(self.determined_imports);
 
-        for glob in self.glob_imports {
-            r.resolve_glob_import(glob);
+        for (module, key, binding, warn_ambiguity) in self.glob_import_outputs {
+            let _ = r.try_define_local(module, key.ident.0, key.ns, binding, warn_ambiguity);
+        }
+
+        for (id, res) in self.glob_res_outputs {
+            r.record_partial_res(id, res);
         }
 
         for (ns, import_bindings) in self.import_bindings.into_iter_with() {
@@ -964,14 +972,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             ImportKind::Single { source, target, ref bindings, type_ns_only, .. } => {
                 (source, target, bindings, type_ns_only)
             }
-            ImportKind::Glob { is_prelude, .. } => {
-                if is_prelude
-                    && let ModuleOrUniformRoot::Module(module) =
-                        import.imported_module.get().unwrap()
-                {
-                    self.r._get_mut_unchecked().prelude = Some(module);
-                }
-                self.glob_imports.push(import);
+            ImportKind::Glob { .. } => {
+                self.resolve_glob_import(import);
                 return 0;
             }
             _ => unreachable!(),
@@ -1565,7 +1567,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         false
     }
 
-    fn resolve_glob_import(&mut self, import: Import<'ra>) {
+    fn resolve_glob_import<'r>(self: &mut ImportResolver<'r, 'ra, 'tcx>, import: Import<'ra>) {
         // This function is only called for glob imports.
         let ImportKind::Glob { id, is_prelude, .. } = import.kind else { unreachable!() };
 
@@ -1587,7 +1589,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         if module == import.parent_scope.module {
             return;
         } else if is_prelude {
-            self.prelude = Some(module);
+            self.r.prelude.set(Some(module));
             return;
         }
 
@@ -1616,18 +1618,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     .resolution(import.parent_scope.module, key)
                     .and_then(|r| r.binding())
                     .is_some_and(|binding| binding.warn_ambiguity_recursive());
-                let _ = self.try_define_local(
+                self.glob_import_outputs.push((
                     import.parent_scope.module,
-                    key.ident.0,
-                    key.ns,
+                    key,
                     imported_binding,
                     warn_ambiguity,
-                );
+                ));
             }
         }
 
         // Record the destination of this import
-        self.record_partial_res(id, PartialRes::new(module.res().unwrap()));
+        self.glob_res_outputs.push((id, PartialRes::new(module.res().unwrap())));
     }
 
     // Miscellaneous post-processing, including recording re-exports,

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -2485,7 +2485,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                                     .then_some(TypoSuggestion::typo_from_ident(ident.0, res))
                             }));
 
-                            if let Some(prelude) = self.r.prelude {
+                            if let Some(prelude) = self.r.prelude.get() {
                                 self.r.add_module_candidates(prelude, &mut names, &filter_fn, None);
                             }
                         }

compiler/rustc_resolve/src/lib.rs

@@ -1058,7 +1058,7 @@ pub struct Resolver<'ra, 'tcx> {
     /// Assert that we are in speculative resolution mode.
     assert_speculative: bool,
 
-    prelude: Option<Module<'ra>>,
+    prelude: Cell<Option<Module<'ra>>>,
     extern_prelude: FxIndexMap<Macros20NormalizedIdent, ExternPreludeEntry<'ra>>,
 
     /// N.B., this is used only for better diagnostics, not name resolution itself.
@@ -1533,7 +1533,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             // AST.
             graph_root,
             assert_speculative: false, // Only set/cleared in Resolver::resolve_imports for now
-            prelude: None,
+            prelude: Cell::new(None),
             extern_prelude,
 
             field_names: Default::default(),
@@ -1881,7 +1881,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     this.get_mut().traits_in_module(module, assoc_item, &mut found_traits);
                 }
                 Scope::StdLibPrelude => {
-                    if let Some(module) = this.prelude {
+                    if let Some(module) = this.prelude.get() {
                         this.get_mut().traits_in_module(module, assoc_item, &mut found_traits);
                     }
                 }
@@ -2024,7 +2024,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             if let ImportKind::MacroUse { warn_private: true } = import.kind {
                 // Do not report the lint if the macro name resolves in stdlib prelude
                 // even without the problematic `macro_use` import.
-                let found_in_stdlib_prelude = self.prelude.is_some_and(|prelude| {
+                let found_in_stdlib_prelude = self.prelude.get().is_some_and(|prelude| {
                     let empty_module = self.empty_module;
                     let arenas = self.arenas;
                     self.cm()