imported_module is a side effect as well.

Author: LorrensP-2158466

compiler/rustc_resolve/src/imports.rs

@@ -41,16 +41,21 @@ use crate::{
 
 type Res = def::Res<NodeId>;
 
-enum SideEffect<'ra> {
+enum SideEffectBindings<'ra> {
     None,
     Single { import_bindings: PerNS<PendingBinding<'ra>> },
     Glob { import_bindings: Vec<(NameBinding<'ra>, BindingKey, bool /* warn_ambiguity */)> },
 }
 
+struct SideEffect<'ra> {
+    imported_module: ModuleOrUniformRoot<'ra>,
+    bindings: SideEffectBindings<'ra>,
+}
+
 #[derive(Default)]
 struct ImportResolutionOutputs<'ra> {
     indeterminate_imports: Vec<Import<'ra>>,
-    determined_imports: Vec<(Import<'ra>, SideEffect<'ra>)>,
+    determined_imports: Vec<(Import<'ra>, Option<SideEffect<'ra>>)>,
 }
 
 impl<'ra> ImportResolutionOutputs<'ra> {
@@ -65,11 +70,17 @@ impl<'ra> ImportResolutionOutputs<'ra> {
         for (import, side_effect) in self.determined_imports {
             r.determined_imports.push(import);
 
+            let Some(SideEffect { imported_module, bindings: side_effect_bindings }) = side_effect
+            else {
+                return;
+            };
+            import.imported_module.set(Some(imported_module));
             let parent = import.parent_scope.module;
-            match (&import.kind, side_effect) {
+
+            match (&import.kind, side_effect_bindings) {
                 (
                     ImportKind::Single { target, bindings, .. },
-                    SideEffect::Single { import_bindings },
+                    SideEffectBindings::Single { import_bindings },
                 ) => {
                     for (ns, pending_binding) in import_bindings.into_iter_with() {
                         match pending_binding {
@@ -87,10 +98,11 @@ impl<'ra> ImportResolutionOutputs<'ra> {
                         bindings[ns].set(pending_binding);
                     }
                 }
-                (ImportKind::Glob { id, .. }, SideEffect::Glob { import_bindings }) => {
+                (ImportKind::Glob { id, .. }, SideEffectBindings::Glob { import_bindings }) => {
                     let ModuleOrUniformRoot::Module(module) = import.imported_module.get().unwrap()
                     else {
-                        unreachable!();
+                        r.dcx().emit_err(CannotGlobImportAllCrates { span: import.span });
+                        continue;
                     };
 
                     module.glob_importers.borrow_mut().push(import);
@@ -108,7 +120,8 @@ impl<'ra> ImportResolutionOutputs<'ra> {
                     r.record_partial_res(*id, PartialRes::new(module.res().unwrap()));
                 }
 
-                (_, SideEffect::None) => {}
+                (_, SideEffectBindings::None) => {}
+
                 // Something weird happened, which shouldn't have happened.
                 _ => unreachable!("Mismatched import kind and side effect"),
             }
@@ -914,7 +927,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     fn resolve_import<'r>(
         self: &mut CmResolver<'r, 'ra, 'tcx>,
         import: Import<'ra>,
-    ) -> (SideEffect<'ra>, usize) {
+    ) -> (Option<SideEffect<'ra>>, usize) {
         debug!(
             "(resolving import for module) resolving import `{}::...` in `{}`",
             Segment::names_to_string(&import.module_path),
@@ -932,20 +945,25 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             match path_res {
                 PathResult::Module(module) => module,
-                PathResult::Indeterminate => return (SideEffect::None, 3),
+                PathResult::Indeterminate => return (None, 3),
                 PathResult::NonModule(..) | PathResult::Failed { .. } => {
-                    return (SideEffect::None, 0);
+                    return (None, 0);
                 }
             }
         };
 
-        import.imported_module.set(Some(module));
         let (source, target, bindings, type_ns_only) = match import.kind {
             ImportKind::Single { source, target, ref bindings, type_ns_only, .. } => {
                 (source, target, bindings, type_ns_only)
             }
             ImportKind::Glob { .. } => {
-                return (self.resolve_glob_import(import), 0);
+                return (
+                    Some(SideEffect {
+                        imported_module: module,
+                        bindings: self.resolve_glob_import(import, module),
+                    }),
+                    0,
+                );
             }
             _ => unreachable!(),
         };
@@ -997,7 +1015,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
         });
 
-        (SideEffect::Single { import_bindings }, indeterminate_count)
+        (
+            Some(SideEffect {
+                imported_module: module,
+                bindings: SideEffectBindings::Single { import_bindings },
+            }),
+            indeterminate_count,
+        )
     }
 
     /// Performs final import resolution, consistency checks and error reporting.
@@ -1540,13 +1564,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     fn resolve_glob_import<'r>(
         self: &mut CmResolver<'r, 'ra, 'tcx>,
         import: Import<'ra>,
-    ) -> SideEffect<'ra> {
+        imported_module: ModuleOrUniformRoot<'ra>,
+    ) -> SideEffectBindings<'ra> {
         // This function is only called for glob imports.
         let ImportKind::Glob { .. } = import.kind else { unreachable!() };
 
-        let ModuleOrUniformRoot::Module(module) = import.imported_module.get().unwrap() else {
-            self.dcx().emit_err(CannotGlobImportAllCrates { span: import.span });
-            return SideEffect::None;
+        let ModuleOrUniformRoot::Module(module) = imported_module else {
+            return SideEffectBindings::None;
         };
 
         if module.is_trait() && !self.tcx.features().import_trait_associated_functions() {
@@ -1560,7 +1584,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
 
         if module == import.parent_scope.module {
-            return SideEffect::None;
+            return SideEffectBindings::None;
         }
 
         // Ensure that `resolutions` isn't borrowed during `try_define`,
@@ -1591,7 +1615,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
 
         // Record the destination of this import
-        SideEffect::Glob { import_bindings }
+        SideEffectBindings::Glob { import_bindings }
     }
 
     // Miscellaneous post-processing, including recording re-exports,